mantarimay/Aegisub
1
0
Fork 0
forked from mia/Aegisub
Code Pull requests Activity

Update libass and adjust to API changes.

Browse source 
Update the internal libass copy to git commit cf7c6e4c and fix the
libass provider; libass types were renamed.

Originally committed to SVN as r3446.
This commit is contained in:
Grigori Goronzy 2009-09-02 01:23:51 +00:00
parent f263c0f599
commit a9b80dea4c
25 changed files with 2165 additions and 1761 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
aegisub/libass/Makefile.am
View file

@ -15,7 +15,8 @@ libass_aegisub_a_SOURCES = \
ass_fontconfig.c \
ass_library.c \
ass_render.c \
ass_utils.c
ass_utils.c \
ass_parse.c
libass_aegisub_a_SOURCES += \
*.h

134
aegisub/libass/ass.c
View file

@ -38,11 +38,16 @@
#include "ass_utils.h"
#include "ass_library.h"
typedef enum { PST_UNKNOWN =
0, PST_INFO, PST_STYLES, PST_EVENTS, PST_FONTS } parser_state_t;
typedef enum {
PST_UNKNOWN = 0,
PST_INFO,
PST_STYLES,
PST_EVENTS,
PST_FONTS
} ParserState;
struct parser_priv_s {
parser_state_t state;
struct parser_priv {
ParserState state;
char *fontname;
char *fontdata;
int fontdata_size;
@ -52,7 +57,7 @@ struct parser_priv_s {
#define ASS_STYLES_ALLOC 20
#define ASS_EVENTS_ALLOC 200
void ass_free_track(ass_track_t *track)
void ass_free_track(ASS_Track *track)
{
int i;
@ -77,12 +82,14 @@ void ass_free_track(ass_track_t *track)
ass_free_event(track, i);
free(track->events);
}
free(track->name);
free(track);
}
/// \brief Allocate a new style struct
/// \param track track
/// \return style id
int ass_alloc_style(ass_track_t *track)
int ass_alloc_style(ASS_Track *track)
{
int sid;
@ -91,20 +98,20 @@ int ass_alloc_style(ass_track_t *track)
if (track->n_styles == track->max_styles) {
track->max_styles += ASS_STYLES_ALLOC;
track->styles =
(ass_style_t *) realloc(track->styles,
sizeof(ass_style_t) *
track->max_styles);
(ASS_Style *) realloc(track->styles,
sizeof(ASS_Style) *
track->max_styles);
}
sid = track->n_styles++;
memset(track->styles + sid, 0, sizeof(ass_style_t));
memset(track->styles + sid, 0, sizeof(ASS_Style));
return sid;
}
/// \brief Allocate a new event struct
/// \param track track
/// \return event id
int ass_alloc_event(ass_track_t *track)
int ass_alloc_event(ASS_Track *track)
{
int eid;
@ -113,19 +120,19 @@ int ass_alloc_event(ass_track_t *track)
if (track->n_events == track->max_events) {
track->max_events += ASS_EVENTS_ALLOC;
track->events =
(ass_event_t *) realloc(track->events,
sizeof(ass_event_t) *
track->max_events);
(ASS_Event *) realloc(track->events,
sizeof(ASS_Event) *
track->max_events);
}
eid = track->n_events++;
memset(track->events + eid, 0, sizeof(ass_event_t));
memset(track->events + eid, 0, sizeof(ASS_Event));
return eid;
}
void ass_free_event(ass_track_t *track, int eid)
void ass_free_event(ASS_Track *track, int eid)
{
ass_event_t *event = track->events + eid;
ASS_Event *event = track->events + eid;
if (event->Name)
free(event->Name);
if (event->Effect)
@ -136,9 +143,9 @@ void ass_free_event(ass_track_t *track, int eid)
free(event->render_priv);
}
void ass_free_style(ass_track_t *track, int sid)
void ass_free_style(ASS_Track *track, int sid)
{
ass_style_t *style = track->styles + sid;
ASS_Style *style = track->styles + sid;
if (style->Name)
free(style->Name);
if (style->FontName)
@ -171,7 +178,7 @@ static void rskip_spaces(char **str, char *limit)
* Returnes 0 if no styles found => expects at least 1 style.
* Parsing code always adds "Default" style in the end.
*/
static int lookup_style(ass_track_t *track, char *name)
static int lookup_style(ASS_Track *track, char *name)
{
int i;
if (*name == '*')
@ -188,14 +195,14 @@ static int lookup_style(ass_track_t *track, char *name)
return i; // use the first style
}
static uint32_t string2color(ass_library_t *library, char *p)
static uint32_t string2color(ASS_Library *library, char *p)
{
uint32_t tmp;
(void) strtocolor(library, &p, &tmp);
(void) strtocolor(library, &p, &tmp, 0);
return tmp;
}
static long long string2timecode(ass_library_t *library, char *p)
static long long string2timecode(ASS_Library *library, char *p)
{
unsigned h, m, s, ms;
long long tm;
@ -292,14 +299,14 @@ static char *next_token(char **str)
* \param str string to parse, zero-terminated
* \param n_ignored number of format options to skip at the beginning
*/
static int process_event_tail(ass_track_t *track, ass_event_t *event,
static int process_event_tail(ASS_Track *track, ASS_Event *event,
char *str, int n_ignored)
{
char *token;
char *tname;
char *p = str;
int i;
ass_event_t *target = event;
ASS_Event *target = event;
char *format = strdup(track->event_format);
char *q = format; // format scanning pointer
@ -355,10 +362,10 @@ static int process_event_tail(ass_track_t *track, ass_event_t *event,
* \param track track to apply overrides to
* The format for overrides is [StyleName.]Field=Value
*/
void ass_process_force_style(ass_track_t *track)
void ass_process_force_style(ASS_Track *track)
{
char **fs, *eq, *dt, *style, *tname, *token;
ass_style_t *target;
ASS_Style *target;
int sid;
char **list = track->library->style_overrides;
@ -434,7 +441,7 @@ void ass_process_force_style(ass_track_t *track)
* \param str string to parse, zero-terminated
* Allocates a new style struct.
*/
static int process_style(ass_track_t *track, char *str)
static int process_style(ASS_Track *track, char *str)
{
char *token;
@ -443,8 +450,8 @@ static int process_style(ass_track_t *track, char *str)
char *format;
char *q; // format scanning pointer
int sid;
ass_style_t *style;
ass_style_t *target;
ASS_Style *style;
ASS_Style *target;
if (!track->style_format) {
// no style format header
@ -472,7 +479,8 @@ static int process_style(ass_track_t *track, char *str)
style = track->styles + sid;
target = style;
// fill style with some default values
// fill style with some default values
style->ScaleX = 100.;
style->ScaleY = 100.;
@ -480,8 +488,6 @@ static int process_style(ass_track_t *track, char *str)
NEXT(q, tname);
NEXT(p, token);
// ALIAS(TertiaryColour,OutlineColour) // ignore TertiaryColour; it appears only in SSA, and is overridden by BackColour
if (0) { // cool ;)
STRVAL(Name)
if ((strcmp(target->Name, "Default") == 0)
@ -537,7 +543,7 @@ static int process_style(ass_track_t *track, char *str)
}
static int process_styles_line(ass_track_t *track, char *str)
static int process_styles_line(ASS_Track *track, char *str)
{
if (!strncmp(str, "Format:", 7)) {
char *p = str + 7;
@ -553,7 +559,7 @@ static int process_styles_line(ass_track_t *track, char *str)
return 0;
}
static int process_info_line(ass_track_t *track, char *str)
static int process_info_line(ASS_Track *track, char *str)
{
if (!strncmp(str, "PlayResX:", 9)) {
track->PlayResX = atoi(str + 9);
@ -569,7 +575,7 @@ static int process_info_line(ass_track_t *track, char *str)
return 0;
}
static void event_format_fallback(ass_track_t *track)
static void event_format_fallback(ASS_Track *track)
{
track->parser_priv->state = PST_EVENTS;
if (track->track_type == TRACK_TYPE_SSA)
@ -582,7 +588,7 @@ static void event_format_fallback(ass_track_t *track)
"No event format found, using fallback");
}
static int process_events_line(ass_track_t *track, char *str)
static int process_events_line(ASS_Track *track, char *str)
{
if (!strncmp(str, "Format:", 7)) {
char *p = str + 7;
@ -594,7 +600,7 @@ static int process_events_line(ass_track_t *track, char *str)
// They have slightly different format and are parsed in ass_process_chunk,
// called directly from demuxer
int eid;
ass_event_t *event;
ASS_Event *event;
str += 9;
skip_spaces(&str);
@ -634,7 +640,7 @@ static unsigned char *decode_chars(unsigned char c1, unsigned char c2,
return dst;
}
static int decode_font(ass_track_t *track)
static int decode_font(ASS_Track *track)
{
unsigned char *p;
unsigned char *q;
@ -682,7 +688,7 @@ static int decode_font(ass_track_t *track)
return 0;
}
static int process_fonts_line(ass_track_t *track, char *str)
static int process_fonts_line(ASS_Track *track, char *str)
{
int len;
@ -728,7 +734,7 @@ static int process_fonts_line(ass_track_t *track, char *str)
* \param track track
* \param str string to parse, zero-terminated
*/
static int process_line(ass_track_t *track, char *str)
static int process_line(ASS_Track *track, char *str)
{
if (!strncasecmp(str, "[Script Info]", 13)) {
track->parser_priv->state = PST_INFO;
@ -769,7 +775,7 @@ static int process_line(ass_track_t *track, char *str)
return 0;
}
static int process_text(ass_track_t *track, char *str)
static int process_text(ASS_Track *track, char *str)
{
char *p = str;
while (1) {
@ -802,7 +808,7 @@ static int process_text(ass_track_t *track, char *str)
* \param data string to parse
* \param size length of data
*/
void ass_process_data(ass_track_t *track, char *data, int size)
void ass_process_data(ASS_Track *track, char *data, int size)
{
char *str = malloc(size + 1);
@ -821,7 +827,7 @@ void ass_process_data(ass_track_t *track, char *data, int size)
* \param size length of data
CodecPrivate section contains [Stream Info] and [V4+ Styles] ([V4 Styles] for SSA) sections
*/
void ass_process_codec_private(ass_track_t *track, char *data, int size)
void ass_process_codec_private(ASS_Track *track, char *data, int size)
{
ass_process_data(track, data, size);
@ -833,7 +839,7 @@ void ass_process_codec_private(ass_track_t *track, char *data, int size)
ass_process_force_style(track);
}
static int check_duplicate_event(ass_track_t *track, int ReadOrder)
static int check_duplicate_event(ASS_Track *track, int ReadOrder)
{
int i;
for (i = 0; i < track->n_events - 1; ++i) // ignoring last event, it is the one we are comparing with
@ -850,14 +856,14 @@ static int check_duplicate_event(ass_track_t *track, int ReadOrder)
* \param timecode starting time of the event (milliseconds)
* \param duration duration of the event (milliseconds)
*/
void ass_process_chunk(ass_track_t *track, char *data, int size,
void ass_process_chunk(ASS_Track *track, char *data, int size,
long long timecode, long long duration)
{
char *str;
int eid;
char *p;
char *token;
ass_event_t *event;
ASS_Event *event;
if (!track->event_format) {
ass_msg(track->library, MSGL_WARN, "Event format header missing");
@ -906,7 +912,7 @@ void ass_process_chunk(ass_track_t *track, char *data, int size,
* \param size buffer size
* \return a pointer to recoded buffer, caller is responsible for freeing it
**/
static char *sub_recode(ass_library_t *library, char *data, size_t size,
static char *sub_recode(ASS_Library *library, char *data, size_t size,
char *codepage)
{
iconv_t icdsc;
@ -985,7 +991,7 @@ static char *sub_recode(ass_library_t *library, char *data, size_t size,
* \param bufsize out: file size
* \return pointer to file contents. Caller is responsible for its deallocation.
*/
static char *read_file(ass_library_t *library, char *fname, size_t *bufsize)
static char *read_file(ASS_Library *library, char *fname, size_t *bufsize)
{
int res;
long sz;
@ -1044,9 +1050,9 @@ static char *read_file(ass_library_t *library, char *fname, size_t *bufsize)
/*
* \param buf pointer to subtitle text in utf-8
*/
static ass_track_t *parse_memory(ass_library_t *library, char *buf)
static ASS_Track *parse_memory(ASS_Library *library, char *buf)
{
ass_track_t *track;
ASS_Track *track;
int i;
track = ass_new_track(library);
@ -1080,10 +1086,10 @@ static ass_track_t *parse_memory(ass_library_t *library, char *buf)
* \param codepage recode buffer contents from given codepage
* \return newly allocated track
*/
ass_track_t *ass_read_memory(ass_library_t *library, char *buf,
size_t bufsize, char *codepage)
ASS_Track *ass_read_memory(ASS_Library *library, char *buf,
size_t bufsize, char *codepage)
{
ass_track_t *track;
ASS_Track *track;
int need_free = 0;
if (!buf)
@ -1109,7 +1115,7 @@ ass_track_t *ass_read_memory(ass_library_t *library, char *buf,
return track;
}
static char *read_file_recode(ass_library_t *library, char *fname,
static char *read_file_recode(ASS_Library *library, char *fname,
char *codepage, size_t *size)
{
char *buf;
@ -1138,11 +1144,11 @@ static char *read_file_recode(ass_library_t *library, char *fname,
* \param codepage recode buffer contents from given codepage
* \return newly allocated track
*/
ass_track_t *ass_read_file(ass_library_t *library, char *fname,
char *codepage)
ASS_Track *ass_read_file(ASS_Library *library, char *fname,
char *codepage)
{
char *buf;
ass_track_t *track;
ASS_Track *track;
size_t bufsize;
buf = read_file_recode(library, fname, codepage, &bufsize);
@ -1165,10 +1171,10 @@ ass_track_t *ass_read_file(ass_library_t *library, char *fname,
/**
* \brief read styles from file into already initialized track
*/
int ass_read_styles(ass_track_t *track, char *fname, char *codepage)
int ass_read_styles(ASS_Track *track, char *fname, char *codepage)
{
char *buf;
parser_state_t old_state;
ParserState old_state;
size_t sz;
buf = read_file(track->library, fname, &sz);
@ -1193,7 +1199,7 @@ int ass_read_styles(ass_track_t *track, char *fname, char *codepage)
return 0;
}
long long ass_step_sub(ass_track_t *track, long long now, int movement)
long long ass_step_sub(ASS_Track *track, long long now, int movement)
{
int i;
@ -1225,11 +1231,11 @@ long long ass_step_sub(ass_track_t *track, long long now, int movement)
return ((long long) track->events[i].Start) - now;
}
ass_track_t *ass_new_track(ass_library_t *library)
ASS_Track *ass_new_track(ASS_Library *library)
{
ass_track_t *track = calloc(1, sizeof(ass_track_t));
ASS_Track *track = calloc(1, sizeof(ASS_Track));
track->library = library;
track->ScaledBorderAndShadow = 1;
track->parser_priv = calloc(1, sizeof(parser_priv_t));
track->parser_priv = calloc(1, sizeof(ASS_ParserPriv));
return track;
}

117
aegisub/libass/ass.h
View file

@ -25,41 +25,54 @@
#include <stdarg.h>
#include "ass_types.h"
#define LIBASS_VERSION 0x00907000
#define LIBASS_VERSION 0x00907010
/* Libass renderer object. Contents are private. */
typedef struct ass_renderer_s ass_renderer_t;
/* A linked list of images produced by ass renderer. */
typedef struct ass_image_s {
/*
* A linked list of images produced by an ass renderer.
*
* These images have to be rendered in-order for the correct screen
* composition. The libass renderer clips these bitmaps to the frame size.
* w/h can be zero, in this case the bitmap should not be rendered at all.
* The last bitmap row is not guaranteed to be padded up to stride size,
* e.g. in the worst case a bitmap has the size stride * (h - 1) + w.
*/
typedef struct ass_image {
int w, h; // Bitmap width/height
int stride; // Bitmap stride
unsigned char *bitmap; // 1bpp stride*h alpha buffer
// Note: the last row may not be padded to
// bitmap stride!
uint32_t color; // Bitmap color and alpha, RGBA
int dst_x, dst_y; // Bitmap placement inside the video frame
struct ass_image_s *next; // Next image, or NULL
} ass_image_t;
struct ass_image *next; // Next image, or NULL
} ASS_Image;
/* Hinting type. */
/*
* Hintint type. (see ass_set_hinting below)
*
* FreeType's native hinter is still buggy sometimes and it is recommended
* to use the light autohinter, ASS_HINTING_LIGHT, instead. For best
* compatibility with problematic fonts, disable hinting.
*/
typedef enum {
ASS_HINTING_NONE = 0,
ASS_HINTING_LIGHT,
ASS_HINTING_NORMAL,
ASS_HINTING_NATIVE
} ass_hinting_t;
} ASS_Hinting;
/**
* \brief Initialize the library.
* \return library handle or NULL if failed
*/
ass_library_t *ass_library_init(void);
ASS_Library *ass_library_init(void);
/**
* \brief Finalize the library
* \param priv library handle
*/
void ass_library_done(ass_library_t *);
void ass_library_done(ASS_Library *priv);
/**
* \brief Set private font directory.
@ -68,14 +81,14 @@ void ass_library_done(ass_library_t *);
* \param priv library handle
* \param fonts_dir private directory for font extraction
*/
void ass_set_fonts_dir(ass_library_t *priv, const char *fonts_dir);
void ass_set_fonts_dir(ASS_Library *priv, const char *fonts_dir);
/**
* \brief Whether fonts should be extracted from track data.
* \param priv library handle
* \param extract whether to extract fonts
*/
void ass_set_extract_fonts(ass_library_t *priv, int extract);
void ass_set_extract_fonts(ASS_Library *priv, int extract);
/**
* \brief Register style overrides with a library instance.
@ -86,13 +99,13 @@ void ass_set_extract_fonts(ass_library_t *priv, int extract);
* \param priv library handle
* \param list NULL-terminated list of strings
*/
void ass_set_style_overrides(ass_library_t *priv, char **list);
void ass_set_style_overrides(ASS_Library *priv, char **list);
/**
* \brief Explicitly process style overrides for a track.
* \param track track handle
*/
void ass_process_force_style(ass_track_t *track);
void ass_process_force_style(ASS_Track *track);
/**
* \brief Register a callback for debug/info messages.
@ -108,8 +121,8 @@ void ass_process_force_style(ass_track_t *track);
* \param msg_cb pointer to callback function
* \param data additional data, will be passed to callback
*/
void ass_set_message_cb(ass_library_t *priv,
void (*msg_cb)(int, char *, va_list *, void *),
void ass_set_message_cb(ASS_Library *priv, void (*msg_cb)
(int level, const char *fmt, va_list args, void *data),
void *data);
/**
@ -117,13 +130,13 @@ void ass_set_message_cb(ass_library_t *priv,
* \param priv library handle
* \return renderer handle or NULL if failed
*/
ass_renderer_t *ass_renderer_init(ass_library_t *);
ASS_Renderer *ass_renderer_init(ASS_Library *);
/**
* \brief Finalize the renderer.
* \param priv renderer handle
*/
void ass_renderer_done(ass_renderer_t *priv);
void ass_renderer_done(ASS_Renderer *priv);
/**
* \brief Set the frame size in pixels, including margins.
@ -131,7 +144,7 @@ void ass_renderer_done(ass_renderer_t *priv);
* \param w width
* \param h height
*/
void ass_set_frame_size(ass_renderer_t *priv, int w, int h);
void ass_set_frame_size(ASS_Renderer *priv, int w, int h);
/**
* \brief Set frame margins. These values may be negative if pan-and-scan
@ -142,43 +155,43 @@ void ass_set_frame_size(ass_renderer_t *priv, int w, int h);
* \param l left margin
* \param r right margin
*/
void ass_set_margins(ass_renderer_t *priv, int t, int b, int l, int r);
void ass_set_margins(ASS_Renderer *priv, int t, int b, int l, int r);
/**
* \brief Whether margins should be used for placing regular events.
* \param priv renderer handle
* \param use whether to use the margins
*/
void ass_set_use_margins(ass_renderer_t *priv, int use);
void ass_set_use_margins(ASS_Renderer *priv, int use);
/**
* \brief Set aspect ratio parameters.
* \param priv renderer handle
* \param ar physical aspect ratio
* \param par pixel ratio, e.g. width / height of the video
* \param dar display aspect ratio (DAR), prescaled for output PAR
* \param sar storage aspect ratio (SAR)
*/
void ass_set_aspect_ratio(ass_renderer_t *priv, double ar, double par);
void ass_set_aspect_ratio(ASS_Renderer *priv, double dar, double sar);
/**
* \brief Set a fixed font scaling factor.
* \param priv renderer handle
* \param font_scale scaling factor, default is 1.0
*/
void ass_set_font_scale(ass_renderer_t *priv, double font_scale);
void ass_set_font_scale(ASS_Renderer *priv, double font_scale);
/**
* \brief Set font hinting method.
* \param priv renderer handle
* \param ht hinting method
*/
void ass_set_hinting(ass_renderer_t *priv, ass_hinting_t ht);
void ass_set_hinting(ASS_Renderer *priv, ASS_Hinting ht);
/**
* \brief Set line spacing. Will not be scaled with frame size.
* \param priv renderer handle
* \param line_spacing line spacing in pixels
*/
void ass_set_line_spacing(ass_renderer_t *priv, double line_spacing);
void ass_set_line_spacing(ASS_Renderer *priv, double line_spacing);
/**
* \brief Set font lookup defaults.
@ -188,7 +201,7 @@ void ass_set_line_spacing(ass_renderer_t *priv, double line_spacing);
* \param update whether fontconfig cache should be built/updated now. Only
* relevant if fontconfig is used.
*/
void ass_set_fonts(ass_renderer_t *priv, const char *default_font,
void ass_set_fonts(ASS_Renderer *priv, const char *default_font,
const char *default_family, int fc, const char *config,
int update);
@ -199,7 +212,7 @@ void ass_set_fonts(ass_renderer_t *priv, const char *default_font,
* \param priv renderer handle
* \return success
*/
int ass_fonts_update(ass_renderer_t *priv);
int ass_fonts_update(ASS_Renderer *priv);
/**
* \brief Set hard cache limits. Do not set, or set to zero, for reasonable
@ -209,19 +222,19 @@ int ass_fonts_update(ass_renderer_t *priv);
* \param glyph_max maximum number of cached glyphs
* \param bitmap_max_size maximum bitmap cache size (in MB)
*/
void ass_set_cache_limits(ass_renderer_t *priv, int glyph_max,
void ass_set_cache_limits(ASS_Renderer *priv, int glyph_max,
int bitmap_max_size);
/**
* \brief Render a frame, producing a list of ass_image_t.
* \brief Render a frame, producing a list of ASS_Image.
* \param priv renderer handle
* \param track subtitle track
* \param now video timestamp in milliseconds
* \param detect_change will be set to 1 if a change occured compared
* to the last invocation
*/
ass_image_t *ass_render_frame(ass_renderer_t *priv, ass_track_t *track,
long long now, int *detect_change);
ASS_Image *ass_render_frame(ASS_Renderer *priv, ASS_Track *track,
long long now, int *detect_change);
/*
@ -234,27 +247,27 @@ ass_image_t *ass_render_frame(ass_renderer_t *priv, ass_track_t *track,
* \param library handle
* \return pointer to empty track
*/
ass_track_t *ass_new_track(ass_library_t *);
ASS_Track *ass_new_track(ASS_Library *);
/**
* \brief Deallocate track and all its child objects (styles and events).
* \param track track to deallocate
*/
void ass_free_track(ass_track_t *track);
void ass_free_track(ASS_Track *track);
/**
* \brief Allocate new style.
* \param track track
* \return newly allocated style id
*/
int ass_alloc_style(ass_track_t *track);
int ass_alloc_style(ASS_Track *track);
/**
* \brief Allocate new event.
* \param track track
* \return newly allocated event id
*/
int ass_alloc_event(ass_track_t *track);
int ass_alloc_event(ASS_Track *track);
/**
* \brief Delete a style.
@ -262,7 +275,7 @@ int ass_alloc_event(ass_track_t *track);
* \param sid style id
* Deallocates style data. Does not modify track->n_styles.
*/
void ass_free_style(ass_track_t *track, int sid);
void ass_free_style(ASS_Track *track, int sid);
/**
* \brief Delete an event.
@ -270,7 +283,7 @@ void ass_free_style(ass_track_t *track, int sid);
* \param eid event id
* Deallocates event data. Does not modify track->n_events.
*/
void ass_free_event(ass_track_t *track, int eid);
void ass_free_event(ASS_Track *track, int eid);
/**
* \brief Parse a chunk of subtitle stream data.
@ -278,7 +291,7 @@ void ass_free_event(ass_track_t *track, int eid);
* \param data string to parse
* \param size length of data
*/
void ass_process_data(ass_track_t *track, char *data, int size);
void ass_process_data(ASS_Track *track, char *data, int size);
/**
* \brief Parse Codec Private section of subtitle stream.
@ -286,7 +299,7 @@ void ass_process_data(ass_track_t *track, char *data, int size);
* \param data string to parse
* \param size length of data
*/
void ass_process_codec_private(ass_track_t *track, char *data, int size);
void ass_process_codec_private(ASS_Track *track, char *data, int size);
/**
* \brief Parse a chunk of subtitle stream data. In Matroska,
@ -297,7 +310,7 @@ void ass_process_codec_private(ass_track_t *track, char *data, int size);
* \param timecode starting time of the event (milliseconds)
* \param duration duration of the event (milliseconds)
*/
void ass_process_chunk(ass_track_t *track, char *data, int size,
void ass_process_chunk(ASS_Track *track, char *data, int size,
long long timecode, long long duration);
/**
@ -307,8 +320,8 @@ void ass_process_chunk(ass_track_t *track, char *data, int size,
* \param codepage encoding (iconv format)
* \return newly allocated track
*/
ass_track_t *ass_read_file(ass_library_t *library, char *fname,
char *codepage);
ASS_Track *ass_read_file(ASS_Library *library, char *fname,
char *codepage);
/**
* \brief Read subtitles from memory.
@ -318,15 +331,15 @@ ass_track_t *ass_read_file(ass_library_t *library, char *fname,
* \param codepage encoding (iconv format)
* \return newly allocated track
*/
ass_track_t *ass_read_memory(ass_library_t *library, char *buf,
size_t bufsize, char *codepage);
ASS_Track *ass_read_memory(ASS_Library *library, char *buf,
size_t bufsize, char *codepage);
/**
* \brief Read styles from file into already initialized track.
* \param fname file name
* \param codepage encoding (iconv format)
* \return 0 on success
*/
int ass_read_styles(ass_track_t *track, char *fname, char *codepage);
int ass_read_styles(ASS_Track *track, char *fname, char *codepage);
/**
* \brief Add a memory font.
@ -335,14 +348,14 @@ int ass_read_styles(ass_track_t *track, char *fname, char *codepage);
* \param data binary font data
* \param data_size data size
*/
void ass_add_font(ass_library_t *library, char *name, char *data,
void ass_add_font(ASS_Library *library, char *name, char *data,
int data_size);
/**
* \brief Remove all fonts stored in an ass_library object.
* \param library library handle
*/
void ass_clear_fonts(ass_library_t *library);
void ass_clear_fonts(ASS_Library *library);
/**
* \brief Calculates timeshift from now to the start of some other subtitle
@ -353,6 +366,6 @@ void ass_clear_fonts(ass_library_t *library);
* +2 means "the one after the next", -1 means "previous"
* \return timeshift in milliseconds
*/
long long ass_step_sub(ass_track_t *track, long long now, int movement);
long long ass_step_sub(ASS_Track *track, long long now, int movement);
#endif /* LIBASS_ASS_H */

48
aegisub/libass/ass_bitmap.c
View file

@ -28,7 +28,7 @@
#include "ass_utils.h"
#include "ass_bitmap.h"
struct ass_synth_priv_s {
struct ass_synth_priv {
int tmp_w, tmp_h;
unsigned short *tmp;
@ -44,7 +44,7 @@ struct ass_synth_priv_s {
static const unsigned int maxcolor = 255;
static const unsigned base = 256;
static int generate_tables(ass_synth_priv_t *priv, double radius)
static int generate_tables(ASS_SynthPriv *priv, double radius)
{
double A = log(1.0 / base) / (radius * radius * 2);
int mx, i;
@ -101,7 +101,7 @@ static int generate_tables(ass_synth_priv_t *priv, double radius)
return 0;
}
static void resize_tmp(ass_synth_priv_t *priv, int w, int h)
static void resize_tmp(ASS_SynthPriv *priv, int w, int h)
{
if (priv->tmp_w >= w && priv->tmp_h >= h)
return;
@ -118,14 +118,14 @@ static void resize_tmp(ass_synth_priv_t *priv, int w, int h)
priv->tmp = malloc((priv->tmp_w + 1) * priv->tmp_h * sizeof(short));
}
ass_synth_priv_t *ass_synth_init(double radius)
ASS_SynthPriv *ass_synth_init(double radius)
{
ass_synth_priv_t *priv = calloc(1, sizeof(ass_synth_priv_t));
ASS_SynthPriv *priv = calloc(1, sizeof(ASS_SynthPriv));
generate_tables(priv, radius);
return priv;
}
void ass_synth_done(ass_synth_priv_t *priv)
void ass_synth_done(ASS_SynthPriv *priv)
{
if (priv->tmp)
free(priv->tmp);
@ -136,10 +136,10 @@ void ass_synth_done(ass_synth_priv_t *priv)
free(priv);
}
static bitmap_t *alloc_bitmap(int w, int h)
static Bitmap *alloc_bitmap(int w, int h)
{
bitmap_t *bm;
bm = calloc(1, sizeof(bitmap_t));
Bitmap *bm;
bm = calloc(1, sizeof(Bitmap));
bm->buffer = malloc(w * h);
bm->w = w;
bm->h = h;
@ -147,7 +147,7 @@ static bitmap_t *alloc_bitmap(int w, int h)
return bm;
}
void ass_free_bitmap(bitmap_t *bm)
void ass_free_bitmap(Bitmap *bm)
{
if (bm) {
if (bm->buffer)
@ -156,16 +156,16 @@ void ass_free_bitmap(bitmap_t *bm)
}
}
static bitmap_t *copy_bitmap(const bitmap_t *src)
static Bitmap *copy_bitmap(const Bitmap *src)
{
bitmap_t *dst = alloc_bitmap(src->w, src->h);
Bitmap *dst = alloc_bitmap(src->w, src->h);
dst->left = src->left;
dst->top = src->top;
memcpy(dst->buffer, src->buffer, src->w * src->h);
return dst;
}
static int check_glyph_area(ass_library_t *library, FT_Glyph glyph)
static int check_glyph_area(ASS_Library *library, FT_Glyph glyph)
{
FT_BBox bbox;
long long dx, dy;
@ -180,12 +180,12 @@ static int check_glyph_area(ass_library_t *library, FT_Glyph glyph)
return 0;
}
static bitmap_t *glyph_to_bitmap_internal(ass_library_t *library,
static Bitmap *glyph_to_bitmap_internal(ASS_Library *library,
FT_Glyph glyph, int bord)
{
FT_BitmapGlyph bg;
FT_Bitmap *bit;
bitmap_t *bm;
Bitmap *bm;
int w, h;
unsigned char *src;
unsigned char *dst;
@ -235,7 +235,7 @@ static bitmap_t *glyph_to_bitmap_internal(ass_library_t *library,
* 1. Glyph bitmap is subtracted from outline bitmap. This way looks much better in some cases.
* 2. Shadow bitmap is created as a sum of glyph and outline bitmaps.
*/
static bitmap_t *fix_outline_and_shadow(bitmap_t *bm_g, bitmap_t *bm_o)
static Bitmap *fix_outline_and_shadow(Bitmap *bm_g, Bitmap *bm_o)
{
int x, y;
const int l = bm_o->left > bm_g->left ? bm_o->left : bm_g->left;
@ -247,7 +247,7 @@ static bitmap_t *fix_outline_and_shadow(bitmap_t *bm_g, bitmap_t *bm_o)
bm_o->top + bm_o->h <
bm_g->top + bm_g->h ? bm_o->top + bm_o->h : bm_g->top + bm_g->h;
bitmap_t *bm_s = copy_bitmap(bm_o);
Bitmap *bm_s = copy_bitmap(bm_o);
unsigned char *g =
bm_g->buffer + (t - bm_g->top) * bm_g->w + (l - bm_g->left);
@ -261,7 +261,7 @@ static bitmap_t *fix_outline_and_shadow(bitmap_t *bm_g, bitmap_t *bm_o)
unsigned char c_g, c_o;
c_g = g[x];
c_o = o[x];
o[x] = (c_o > (3 * c_g) / 5) ? c_o - (3 * c_g) / 5 : 0;
o[x] = (c_o > c_g) ? c_o - (c_g / 2) : 0;
s[x] = (c_o < 0xFF - c_g) ? c_o + c_g : 0xFF;
}
g += bm_g->w;
@ -472,10 +472,11 @@ static void be_blur(unsigned char *buf, int w, int h)
}
}
int glyph_to_bitmap(ass_library_t *library, ass_synth_priv_t *priv_blur,
int glyph_to_bitmap(ASS_Library *library, ASS_SynthPriv *priv_blur,
FT_Glyph glyph, FT_Glyph outline_glyph,
bitmap_t **bm_g, bitmap_t **bm_o, bitmap_t **bm_s,
int be, double blur_radius, FT_Vector shadow_offset)
Bitmap **bm_g, Bitmap **bm_o, Bitmap **bm_s,
int be, double blur_radius, FT_Vector shadow_offset,
int border_style)
{
blur_radius *= 2;
int bbord = be > 0 ? sqrt(2 * be) : 0;
@ -496,7 +497,6 @@ int glyph_to_bitmap(ass_library_t *library, ass_synth_priv_t *priv_blur,
if (outline_glyph) {
*bm_o = glyph_to_bitmap_internal(library, outline_glyph, bord);
if (!*bm_o) {
ass_free_bitmap(*bm_g);
return 1;
}
}
@ -528,7 +528,9 @@ int glyph_to_bitmap(ass_library_t *library, ass_synth_priv_t *priv_blur,
priv_blur->g_w);
}
if (*bm_o)
if (*bm_o && border_style == 3)
*bm_s = copy_bitmap(*bm_o);
else if (*bm_o)
*bm_s = fix_outline_and_shadow(*bm_g, *bm_o);
else
*bm_s = copy_bitmap(*bm_g);

19
aegisub/libass/ass_bitmap.h
View file

@ -26,16 +26,16 @@
#include "ass.h"
typedef struct ass_synth_priv_s ass_synth_priv_t;
typedef struct ass_synth_priv ASS_SynthPriv;
ass_synth_priv_t *ass_synth_init(double);
void ass_synth_done(ass_synth_priv_t *priv);
ASS_SynthPriv *ass_synth_init(double);
void ass_synth_done(ASS_SynthPriv *priv);
typedef struct bitmap_s {
typedef struct {
int left, top;
int w, h; // width, height
unsigned char *buffer; // w x h buffer
} bitmap_t;
} Bitmap;
/**
* \brief perform glyph rendering
@ -46,11 +46,12 @@ typedef struct bitmap_s {
* \param bm_g out: pointer to the bitmap of glyph shadow is returned here
* \param be 1 = produces blurred bitmaps, 0 = normal bitmaps
*/
int glyph_to_bitmap(ass_library_t *library, ass_synth_priv_t *priv_blur,
int glyph_to_bitmap(ASS_Library *library, ASS_SynthPriv *priv_blur,
FT_Glyph glyph, FT_Glyph outline_glyph,
bitmap_t **bm_g, bitmap_t **bm_o, bitmap_t **bm_s,
int be, double blur_radius, FT_Vector shadow_offset);
Bitmap **bm_g, Bitmap **bm_o, Bitmap **bm_s,
int be, double blur_radius, FT_Vector shadow_offset,
int border_style);
void ass_free_bitmap(bitmap_t *bm);
void ass_free_bitmap(Bitmap *bm);
#endif /* LIBASS_BITMAP_H */

126
aegisub/libass/ass_cache.c
View file

@ -51,13 +51,13 @@ static void hashmap_item_dtor(void *key, size_t key_size, void *value,
free(value);
}
hashmap_t *hashmap_init(ass_library_t *library, size_t key_size,
size_t value_size, int nbuckets,
hashmap_item_dtor_t item_dtor,
hashmap_key_compare_t key_compare,
hashmap_hash_t hash)
Hashmap *hashmap_init(ASS_Library *library, size_t key_size,
size_t value_size, int nbuckets,
HashmapItemDtor item_dtor,
HashmapKeyCompare key_compare,
HashmapHash hash)
{
hashmap_t *map = calloc(1, sizeof(hashmap_t));
Hashmap *map = calloc(1, sizeof(Hashmap));
map->library = library;
map->nbuckets = nbuckets;
map->key_size = key_size;
@ -69,7 +69,7 @@ hashmap_t *hashmap_init(ass_library_t *library, size_t key_size,
return map;
}
void hashmap_done(hashmap_t *map)
void hashmap_done(Hashmap *map)
{
int i;
// print stats
@ -81,9 +81,9 @@ void hashmap_done(hashmap_t *map)
map->miss_count, map->count);
for (i = 0; i < map->nbuckets; ++i) {
hashmap_item_t *item = map->root[i];
HashmapItem *item = map->root[i];
while (item) {
hashmap_item_t *next = item->next;
HashmapItem *next = item->next;
map->item_dtor(item->key, map->key_size, item->value,
map->value_size);
free(item);
@ -95,17 +95,17 @@ void hashmap_done(hashmap_t *map)
}
// does nothing if key already exists
void *hashmap_insert(hashmap_t *map, void *key, void *value)
void *hashmap_insert(Hashmap *map, void *key, void *value)
{
unsigned hash = map->hash(key, map->key_size);
hashmap_item_t **next = map->root + (hash % map->nbuckets);
HashmapItem **next = map->root + (hash % map->nbuckets);
while (*next) {
if (map->key_compare(key, (*next)->key, map->key_size))
return (*next)->value;
next = &((*next)->next);
assert(next);
}
(*next) = malloc(sizeof(hashmap_item_t));
(*next) = malloc(sizeof(HashmapItem));
(*next)->key = malloc(map->key_size);
(*next)->value = malloc(map->value_size);
memcpy((*next)->key, key, map->key_size);
@ -116,10 +116,10 @@ void *hashmap_insert(hashmap_t *map, void *key, void *value)
return (*next)->value;
}
void *hashmap_find(hashmap_t *map, void *key)
void *hashmap_find(Hashmap *map, void *key)
{
unsigned hash = map->hash(key, map->key_size);
hashmap_item_t *item = map->root[hash % map->nbuckets];
HashmapItem *item = map->root[hash % map->nbuckets];
while (item) {
if (map->key_compare(key, item->key, map->key_size)) {
map->hit_count++;
@ -136,7 +136,7 @@ void *hashmap_find(hashmap_t *map, void *key)
static unsigned font_desc_hash(void *buf, size_t len)
{
ass_font_desc_t *desc = buf;
ASS_FontDesc *desc = buf;
unsigned hval;
hval = fnv_32a_str(desc->family, FNV1_32A_INIT);
hval = fnv_32a_buf(&desc->bold, sizeof(desc->bold), hval);
@ -146,8 +146,8 @@ static unsigned font_desc_hash(void *buf, size_t len)
static int font_compare(void *key1, void *key2, size_t key_size)
{
ass_font_desc_t *a = key1;
ass_font_desc_t *b = key2;
ASS_FontDesc *a = key1;
ASS_FontDesc *b = key2;
if (strcmp(a->family, b->family) != 0)
return 0;
if (a->bold != b->bold)
@ -166,8 +166,8 @@ static void font_hash_dtor(void *key, size_t key_size, void *value,
free(key);
}
ass_font_t *ass_font_cache_find(hashmap_t *font_cache,
ass_font_desc_t *desc)
ASS_Font *ass_font_cache_find(Hashmap *font_cache,
ASS_FontDesc *desc)
{
return hashmap_find(font_cache, desc);
}
@ -176,22 +176,22 @@ ass_font_t *ass_font_cache_find(hashmap_t *font_cache,
* \brief Add a face struct to cache.
* \param font font struct
*/
void *ass_font_cache_add(hashmap_t *font_cache, ass_font_t *font)
void *ass_font_cache_add(Hashmap *font_cache, ASS_Font *font)
{
return hashmap_insert(font_cache, &(font->desc), font);
}
hashmap_t *ass_font_cache_init(ass_library_t *library)
Hashmap *ass_font_cache_init(ASS_Library *library)
{
hashmap_t *font_cache;
font_cache = hashmap_init(library, sizeof(ass_font_desc_t),
sizeof(ass_font_t),
Hashmap *font_cache;
font_cache = hashmap_init(library, sizeof(ASS_FontDesc),
sizeof(ASS_Font),
1000,
font_hash_dtor, font_compare, font_desc_hash);
return font_cache;
}
void ass_font_cache_done(hashmap_t *font_cache)
void ass_font_cache_done(Hashmap *font_cache)
{
hashmap_done(font_cache);
}
@ -209,7 +209,7 @@ void ass_font_cache_done(hashmap_t *font_cache)
static void bitmap_hash_dtor(void *key, size_t key_size, void *value,
size_t value_size)
{
bitmap_hash_val_t *v = value;
BitmapHashValue *v = value;
if (v->bm)
ass_free_bitmap(v->bm);
if (v->bm_o)
@ -220,13 +220,13 @@ static void bitmap_hash_dtor(void *key, size_t key_size, void *value,
free(value);
}
void *cache_add_bitmap(hashmap_t *bitmap_cache, bitmap_hash_key_t *key,
bitmap_hash_val_t *val)
void *cache_add_bitmap(Hashmap *bitmap_cache, BitmapHashKey *key,
BitmapHashValue *val)
{
// Note: this is only an approximation
if (val->bm_o)
bitmap_cache->cache_size += val->bm_o->w * val->bm_o->h * 3;
else
else if (val->bm)
bitmap_cache->cache_size += val->bm->w * val->bm->h * 3;
return hashmap_insert(bitmap_cache, key, val);
@ -237,32 +237,32 @@ void *cache_add_bitmap(hashmap_t *bitmap_cache, bitmap_hash_key_t *key,
* \param key hash key
* \return requested hash val or 0 if not found
*/
bitmap_hash_val_t *cache_find_bitmap(hashmap_t *bitmap_cache,
bitmap_hash_key_t *key)
BitmapHashValue *cache_find_bitmap(Hashmap *bitmap_cache,
BitmapHashKey *key)
{
return hashmap_find(bitmap_cache, key);
}
hashmap_t *ass_bitmap_cache_init(ass_library_t *library)
Hashmap *ass_bitmap_cache_init(ASS_Library *library)
{
hashmap_t *bitmap_cache;
Hashmap *bitmap_cache;
bitmap_cache = hashmap_init(library,
sizeof(bitmap_hash_key_t),
sizeof(bitmap_hash_val_t),
sizeof(BitmapHashKey),
sizeof(BitmapHashValue),
0xFFFF + 13,
bitmap_hash_dtor, bitmap_compare,
bitmap_hash);
return bitmap_cache;
}
void ass_bitmap_cache_done(hashmap_t *bitmap_cache)
void ass_bitmap_cache_done(Hashmap *bitmap_cache)
{
hashmap_done(bitmap_cache);
}
hashmap_t *ass_bitmap_cache_reset(hashmap_t *bitmap_cache)
Hashmap *ass_bitmap_cache_reset(Hashmap *bitmap_cache)
{
ass_library_t *lib = bitmap_cache->library;
ASS_Library *lib = bitmap_cache->library;
ass_bitmap_cache_done(bitmap_cache);
return ass_bitmap_cache_init(lib);
@ -274,7 +274,7 @@ hashmap_t *ass_bitmap_cache_reset(hashmap_t *bitmap_cache)
static void glyph_hash_dtor(void *key, size_t key_size, void *value,
size_t value_size)
{
glyph_hash_val_t *v = value;
GlyphHashValue *v = value;
if (v->glyph)
FT_Done_Glyph(v->glyph);
if (v->outline_glyph)
@ -283,8 +283,8 @@ static void glyph_hash_dtor(void *key, size_t key_size, void *value,
free(value);
}
void *cache_add_glyph(hashmap_t *glyph_cache, glyph_hash_key_t *key,
glyph_hash_val_t *val)
void *cache_add_glyph(Hashmap *glyph_cache, GlyphHashKey *key,
GlyphHashValue *val)
{
return hashmap_insert(glyph_cache, key, val);
}
@ -294,30 +294,30 @@ void *cache_add_glyph(hashmap_t *glyph_cache, glyph_hash_key_t *key,
* \param key hash key
* \return requested hash val or 0 if not found
*/
glyph_hash_val_t *cache_find_glyph(hashmap_t *glyph_cache,
glyph_hash_key_t *key)
GlyphHashValue *cache_find_glyph(Hashmap *glyph_cache,
GlyphHashKey *key)
{
return hashmap_find(glyph_cache, key);
}
hashmap_t *ass_glyph_cache_init(ass_library_t *library)
Hashmap *ass_glyph_cache_init(ASS_Library *library)
{
hashmap_t *glyph_cache;
glyph_cache = hashmap_init(library, sizeof(glyph_hash_key_t),
sizeof(glyph_hash_val_t),
Hashmap *glyph_cache;
glyph_cache = hashmap_init(library, sizeof(GlyphHashKey),
sizeof(GlyphHashValue),
0xFFFF + 13,
glyph_hash_dtor, glyph_compare, glyph_hash);
return glyph_cache;
}
void ass_glyph_cache_done(hashmap_t *glyph_cache)
void ass_glyph_cache_done(Hashmap *glyph_cache)
{
hashmap_done(glyph_cache);
}
hashmap_t *ass_glyph_cache_reset(hashmap_t *glyph_cache)
Hashmap *ass_glyph_cache_reset(Hashmap *glyph_cache)
{
ass_library_t *lib = glyph_cache->library;
ASS_Library *lib = glyph_cache->library;
ass_glyph_cache_done(glyph_cache);
return ass_glyph_cache_init(lib);
@ -330,16 +330,16 @@ hashmap_t *ass_glyph_cache_reset(hashmap_t *glyph_cache)
static void composite_hash_dtor(void *key, size_t key_size, void *value,
size_t value_size)
{
composite_hash_val_t *v = value;
CompositeHashValue *v = value;
free(v->a);
free(v->b);
free(key);
free(value);
}
void *cache_add_composite(hashmap_t *composite_cache,
composite_hash_key_t *key,
composite_hash_val_t *val)
void *cache_add_composite(Hashmap *composite_cache,
CompositeHashKey *key,
CompositeHashValue *val)
{
return hashmap_insert(composite_cache, key, val);
}
@ -349,31 +349,31 @@ void *cache_add_composite(hashmap_t *composite_cache,
* \param key hash key
* \return requested hash val or 0 if not found
*/
composite_hash_val_t *cache_find_composite(hashmap_t *composite_cache,
composite_hash_key_t *key)
CompositeHashValue *cache_find_composite(Hashmap *composite_cache,
CompositeHashKey *key)
{
return hashmap_find(composite_cache, key);
}
hashmap_t *ass_composite_cache_init(ass_library_t *library)
Hashmap *ass_composite_cache_init(ASS_Library *library)
{
hashmap_t *composite_cache;
composite_cache = hashmap_init(library, sizeof(composite_hash_key_t),
sizeof(composite_hash_val_t),
Hashmap *composite_cache;
composite_cache = hashmap_init(library, sizeof(CompositeHashKey),
sizeof(CompositeHashValue),
0xFFFF + 13,
composite_hash_dtor, composite_compare,
composite_hash);
return composite_cache;
}
void ass_composite_cache_done(hashmap_t *composite_cache)
void ass_composite_cache_done(Hashmap *composite_cache)
{
hashmap_done(composite_cache);
}
hashmap_t *ass_composite_cache_reset(hashmap_t *composite_cache)
Hashmap *ass_composite_cache_reset(Hashmap *composite_cache)
{
ass_library_t *lib = composite_cache->library;
ASS_Library *lib = composite_cache->library;
ass_composite_cache_done(composite_cache);
return ass_composite_cache_init(lib);

114
aegisub/libass/ass_cache.h
View file

@ -25,95 +25,95 @@
#include "ass_font.h"
#include "ass_bitmap.h"
typedef void (*hashmap_item_dtor_t) (void *key, size_t key_size,
void *value, size_t value_size);
typedef int (*hashmap_key_compare_t) (void *key1, void *key2,
size_t key_size);
typedef unsigned (*hashmap_hash_t) (void *key, size_t key_size);
typedef void (*HashmapItemDtor) (void *key, size_t key_size,
void *value, size_t value_size);
typedef int (*HashmapKeyCompare) (void *key1, void *key2,
size_t key_size);
typedef unsigned (*HashmapHash) (void *key, size_t key_size);
typedef struct hashmap_item_s {
typedef struct hashmap_item {
void *key;
void *value;
struct hashmap_item_s *next;
} hashmap_item_t;
typedef hashmap_item_t *hashmap_item_p;
struct hashmap_item *next;
} HashmapItem;
typedef HashmapItem *hashmap_item_p;
typedef struct hashmap_s {
typedef struct {
int nbuckets;
size_t key_size, value_size;
hashmap_item_p *root;
hashmap_item_dtor_t item_dtor; // a destructor for hashmap key/value pairs
hashmap_key_compare_t key_compare;
hashmap_hash_t hash;
HashmapItemDtor item_dtor; // a destructor for hashmap key/value pairs
HashmapKeyCompare key_compare;
HashmapHash hash;
size_t cache_size;
// stats
int hit_count;
int miss_count;
int count;
ass_library_t *library;
} hashmap_t;
ASS_Library *library;
} Hashmap;
hashmap_t *hashmap_init(ass_library_t *library, size_t key_size,
size_t value_size, int nbuckets,
hashmap_item_dtor_t item_dtor,
hashmap_key_compare_t key_compare,
hashmap_hash_t hash);
void hashmap_done(hashmap_t *map);
void *hashmap_insert(hashmap_t *map, void *key, void *value);
void *hashmap_find(hashmap_t *map, void *key);
Hashmap *hashmap_init(ASS_Library *library, size_t key_size,
size_t value_size, int nbuckets,
HashmapItemDtor item_dtor,
HashmapKeyCompare key_compare,
HashmapHash hash);
void hashmap_done(Hashmap *map);
void *hashmap_insert(Hashmap *map, void *key, void *value);
void *hashmap_find(Hashmap *map, void *key);
hashmap_t *ass_font_cache_init(ass_library_t *library);
ass_font_t *ass_font_cache_find(hashmap_t *, ass_font_desc_t *desc);
void *ass_font_cache_add(hashmap_t *, ass_font_t *font);
void ass_font_cache_done(hashmap_t *);
Hashmap *ass_font_cache_init(ASS_Library *library);
ASS_Font *ass_font_cache_find(Hashmap *, ASS_FontDesc *desc);
void *ass_font_cache_add(Hashmap *, ASS_Font *font);
void ass_font_cache_done(Hashmap *);
// Create definitions for bitmap_hash_key and glyph_hash_key
#define CREATE_STRUCT_DEFINITIONS
#include "ass_cache_template.h"
typedef struct bitmap_hash_val_s {
bitmap_t *bm; // the actual bitmaps
bitmap_t *bm_o;
bitmap_t *bm_s;
} bitmap_hash_val_t;
typedef struct {
Bitmap *bm; // the actual bitmaps
Bitmap *bm_o;
Bitmap *bm_s;
} BitmapHashValue;
hashmap_t *ass_bitmap_cache_init(ass_library_t *library);
void *cache_add_bitmap(hashmap_t *, bitmap_hash_key_t *key,
bitmap_hash_val_t *val);
bitmap_hash_val_t *cache_find_bitmap(hashmap_t *bitmap_cache,
bitmap_hash_key_t *key);
hashmap_t *ass_bitmap_cache_reset(hashmap_t *bitmap_cache);
void ass_bitmap_cache_done(hashmap_t *bitmap_cache);
Hashmap *ass_bitmap_cache_init(ASS_Library *library);
void *cache_add_bitmap(Hashmap *, BitmapHashKey *key,
BitmapHashValue *val);
BitmapHashValue *cache_find_bitmap(Hashmap *bitmap_cache,
BitmapHashKey *key);
Hashmap *ass_bitmap_cache_reset(Hashmap *bitmap_cache);
void ass_bitmap_cache_done(Hashmap *bitmap_cache);
typedef struct composite_hash_val_s {
typedef struct {
unsigned char *a;
unsigned char *b;
} composite_hash_val_t;
} CompositeHashValue;
hashmap_t *ass_composite_cache_init(ass_library_t *library);
void *cache_add_composite(hashmap_t *, composite_hash_key_t *key,
composite_hash_val_t *val);
composite_hash_val_t *cache_find_composite(hashmap_t *composite_cache,
composite_hash_key_t *key);
hashmap_t *ass_composite_cache_reset(hashmap_t *composite_cache);
void ass_composite_cache_done(hashmap_t *composite_cache);
Hashmap *ass_composite_cache_init(ASS_Library *library);
void *cache_add_composite(Hashmap *, CompositeHashKey *key,
CompositeHashValue *val);
CompositeHashValue *cache_find_composite(Hashmap *composite_cache,
CompositeHashKey *key);
Hashmap *ass_composite_cache_reset(Hashmap *composite_cache);
void ass_composite_cache_done(Hashmap *composite_cache);
typedef struct glyph_hash_val_s {
typedef struct {
FT_Glyph glyph;
FT_Glyph outline_glyph;
FT_BBox bbox_scaled; // bbox after scaling, but before rotation
FT_Vector advance; // 26.6, advance distance to the next bitmap in line
int asc, desc; // ascender/descender of a drawing
} glyph_hash_val_t;
} GlyphHashValue;
hashmap_t *ass_glyph_cache_init(ass_library_t *library);
void *cache_add_glyph(hashmap_t *, glyph_hash_key_t *key,
glyph_hash_val_t *val);
glyph_hash_val_t *cache_find_glyph(hashmap_t *glyph_cache,
glyph_hash_key_t *key);
hashmap_t *ass_glyph_cache_reset(hashmap_t *glyph_cache);
void ass_glyph_cache_done(hashmap_t *glyph_cache);
Hashmap *ass_glyph_cache_init(ASS_Library *library);
void *cache_add_glyph(Hashmap *, GlyphHashKey *key,
GlyphHashValue *val);
GlyphHashValue *cache_find_glyph(Hashmap *glyph_cache,
GlyphHashKey *key);
Hashmap *ass_glyph_cache_reset(Hashmap *glyph_cache);
void ass_glyph_cache_done(Hashmap *glyph_cache);
#endif /* LIBASS_CACHE_H */

28
aegisub/libass/ass_cache_template.h
View file

@ -7,7 +7,7 @@
#define FTVECTOR(member) \
FT_Vector member;
#define BITMAPHASHKEY(member) \
bitmap_hash_key_t member;
BitmapHashKey member;
#define END(typedefnamename) \
} typedefnamename;
@ -54,9 +54,9 @@
// describes a bitmap; bitmaps with equivalents structs are considered identical
START(bitmap, bipmap_hash_key_s)
START(bitmap, bitmap_hash_key)
GENERIC(char, bitmap) // bool : true = bitmap, false = outline
GENERIC(ass_font_t *, font)
GENERIC(ASS_Font *, font)
GENERIC(double, size) // font size
GENERIC(uint32_t, ch) // character code
FTVECTOR(outline) // border width, 16.16 fixed point value
@ -79,25 +79,27 @@ START(bitmap, bipmap_hash_key_s)
FTVECTOR(advance) // subpixel shift vector
FTVECTOR(shadow_offset) // shadow subpixel shift
GENERIC(unsigned, drawing_hash) // hashcode of a drawing
END(bitmap_hash_key_t)
GENERIC(unsigned, flags) // glyph decoration
GENERIC(unsigned, border_style)
END(BitmapHashKey)
// describes an outline glyph
START(glyph, glyph_hash_key_s)
GENERIC(ass_font_t *, font)
START(glyph, glyph_hash_key)
GENERIC(ASS_Font *, font)
GENERIC(double, size) // font size
GENERIC(uint32_t, ch) // character code
GENERIC(int, bold)
GENERIC(int, italic)
GENERIC(unsigned, scale_x) // 16.16
GENERIC(unsigned, scale_y) // 16.16
FTVECTOR(advance) // subpixel shift vector
FTVECTOR(outline) // border width, 16.16
GENERIC(unsigned, drawing_hash) // hashcode of a drawing
GENERIC(unsigned, flags) // glyph decoration flags
END(glyph_hash_key_t)
GENERIC(unsigned, border_style)
END(GlyphHashKey)
// Cache for composited bitmaps
START(composite, composite_hash_key_s)
START(composite, composite_hash_key)
GENERIC(int, aw)
GENERIC(int, ah)
GENERIC(int, bw)
@ -106,9 +108,11 @@ START(composite, composite_hash_key_s)
GENERIC(int, ay)
GENERIC(int, bx)
GENERIC(int, by)
BITMAPHASHKEY(a)
BITMAPHASHKEY(b)
END(composite_hash_key_t)
GENERIC(int, as)
GENERIC(int, bs)
GENERIC(unsigned char *, a)
GENERIC(unsigned char *, b)
END(CompositeHashKey)
#undef START

60
aegisub/libass/ass_drawing.c
View file

@ -33,8 +33,8 @@
/*
* \brief Get and prepare a FreeType glyph
*/
static void drawing_make_glyph(ass_drawing_t *drawing, void *fontconfig_priv,
ass_font_t *font, ass_hinting_t hint)
static void drawing_make_glyph(ASS_Drawing *drawing, void *fontconfig_priv,
ASS_Font *font, ASS_Hinting hint)
{
FT_OutlineGlyph glyph;
@ -55,7 +55,7 @@ static void drawing_make_glyph(ass_drawing_t *drawing, void *fontconfig_priv,
/*
* \brief Add a single point to a contour.
*/
static inline void drawing_add_point(ass_drawing_t *drawing,
static inline void drawing_add_point(ASS_Drawing *drawing,
FT_Vector *point)
{
FT_Outline *ol = &drawing->glyph->outline;
@ -76,7 +76,7 @@ static inline void drawing_add_point(ass_drawing_t *drawing,
/*
* \brief Close a contour and check glyph size overflow.
*/
static inline void drawing_close_shape(ass_drawing_t *drawing)
static inline void drawing_close_shape(ASS_Drawing *drawing)
{
FT_Outline *ol = &drawing->glyph->outline;
@ -86,14 +86,16 @@ static inline void drawing_close_shape(ass_drawing_t *drawing)
drawing->max_contours);
}
ol->contours[ol->n_contours] = ol->n_points - 1;
ol->n_contours++;
if (ol->n_points) {
ol->contours[ol->n_contours] = ol->n_points - 1;
ol->n_contours++;
}
}
/*
* \brief Prepare drawing for parsing. This just sets a few parameters.
*/
static void drawing_prepare(ass_drawing_t *drawing)
static void drawing_prepare(ASS_Drawing *drawing)
{
// Scaling parameters
drawing->point_scale_x = drawing->scale_x *
@ -106,7 +108,7 @@ static void drawing_prepare(ass_drawing_t *drawing)
* \brief Finish a drawing. This only sets the horizontal advance according
* to the glyph's bbox at the moment.
*/
static void drawing_finish(ass_drawing_t *drawing, int raw_mode)
static void drawing_finish(ASS_Drawing *drawing, int raw_mode)
{
int i, offset;
FT_BBox bbox;
@ -150,7 +152,7 @@ static void drawing_finish(ass_drawing_t *drawing, int raw_mode)
/*
* \brief Check whether a number of items on the list is available
*/
static int token_check_values(ass_drawing_token_t *token, int i, int type)
static int token_check_values(ASS_DrawingToken *token, int i, int type)
{
int j;
for (j = 0; j < i; j++) {
@ -162,16 +164,16 @@ static int token_check_values(ass_drawing_token_t *token, int i, int type)
}
/*
* \brief Tokenize a drawing string into a list of ass_drawing_token_t
* \brief Tokenize a drawing string into a list of ASS_DrawingToken
* This also expands points for closing b-splines
*/
static ass_drawing_token_t *drawing_tokenize(char *str)
static ASS_DrawingToken *drawing_tokenize(char *str)
{
char *p = str;
int i, val, type = -1, is_set = 0;
FT_Vector point = {0, 0};
ass_drawing_token_t *root = NULL, *tail = NULL, *spline_start = NULL;
ASS_DrawingToken *root = NULL, *tail = NULL, *spline_start = NULL;
while (*p) {
if (*p == 'c' && spline_start) {
@ -179,7 +181,7 @@ static ass_drawing_token_t *drawing_tokenize(char *str)
// back to the end
if (token_check_values(spline_start->next, 2, TOKEN_B_SPLINE)) {
for (i = 0; i < 3; i++) {
tail->next = calloc(1, sizeof(ass_drawing_token_t));
tail->next = calloc(1, sizeof(ASS_DrawingToken));
tail->next->prev = tail;
tail = tail->next;
tail->type = TOKEN_B_SPLINE;
@ -214,11 +216,11 @@ static ass_drawing_token_t *drawing_tokenize(char *str)
if (type != -1 && is_set == 2) {
if (root) {
tail->next = calloc(1, sizeof(ass_drawing_token_t));
tail->next = calloc(1, sizeof(ASS_DrawingToken));
tail->next->prev = tail;
tail = tail->next;
} else
root = tail = calloc(1, sizeof(ass_drawing_token_t));
root = tail = calloc(1, sizeof(ASS_DrawingToken));
tail->type = type;
tail->point = point;
is_set = 0;
@ -230,7 +232,7 @@ static ass_drawing_token_t *drawing_tokenize(char *str)
#if 0
// Check tokens
ass_drawing_token_t *t = root;
ASS_DrawingToken *t = root;
while(t) {
printf("token %d point (%d, %d)\n", t->type, t->point.x, t->point.y);
t = t->next;
@ -243,10 +245,10 @@ static ass_drawing_token_t *drawing_tokenize(char *str)
/*
* \brief Free a list of tokens
*/
static void drawing_free_tokens(ass_drawing_token_t *token)
static void drawing_free_tokens(ASS_DrawingToken *token)
{
while (token) {
ass_drawing_token_t *at = token;
ASS_DrawingToken *at = token;
token = token->next;
free(at);
}
@ -256,7 +258,7 @@ static void drawing_free_tokens(ass_drawing_token_t *token)
* \brief Translate and scale a point coordinate according to baseline
* offset and scale.
*/
static inline void translate_point(ass_drawing_t *drawing, FT_Vector *point)
static inline void translate_point(ASS_Drawing *drawing, FT_Vector *point)
{
point->x = drawing->point_scale_x * point->x;
point->y = drawing->point_scale_y * -point->y;
@ -267,8 +269,8 @@ static inline void translate_point(ass_drawing_t *drawing, FT_Vector *point)
* This curve evaluator is also used in VSFilter (RTS.cpp); it's a simple
* implementation of the De Casteljau algorithm.
*/
static void drawing_evaluate_curve(ass_drawing_t *drawing,
ass_drawing_token_t *token, char spline,
static void drawing_evaluate_curve(ASS_Drawing *drawing,
ASS_DrawingToken *token, char spline,
int started)
{
double cx3, cx2, cx1, cx0, cy3, cy2, cy1, cy0;
@ -358,10 +360,10 @@ static void drawing_evaluate_curve(ass_drawing_t *drawing,
/*
* \brief Create and initialize a new drawing and return it
*/
ass_drawing_t *ass_drawing_new(void *fontconfig_priv, ass_font_t *font,
ass_hinting_t hint, FT_Library lib)
ASS_Drawing *ass_drawing_new(void *fontconfig_priv, ASS_Font *font,
ASS_Hinting hint, FT_Library lib)
{
ass_drawing_t* drawing;
ASS_Drawing* drawing;
drawing = calloc(1, sizeof(*drawing));
drawing->text = calloc(1, DRAWING_INITIAL_SIZE);
@ -382,7 +384,7 @@ ass_drawing_t *ass_drawing_new(void *fontconfig_priv, ass_font_t *font,
/*
* \brief Free a drawing
*/
void ass_drawing_free(ass_drawing_t* drawing)
void ass_drawing_free(ASS_Drawing* drawing)
{
FT_Done_Glyph((FT_Glyph) drawing->glyph);
free(drawing->text);
@ -392,7 +394,7 @@ void ass_drawing_free(ass_drawing_t* drawing)
/*
* \brief Add one ASCII character to the drawing text buffer
*/
void ass_drawing_add_char(ass_drawing_t* drawing, char symbol)
void ass_drawing_add_char(ASS_Drawing* drawing, char symbol)
{
drawing->text[drawing->i++] = symbol;
drawing->text[drawing->i] = 0;
@ -407,7 +409,7 @@ void ass_drawing_add_char(ass_drawing_t* drawing, char symbol)
* \brief Create a hashcode for the drawing
* XXX: To avoid collisions a better hash algorithm might be useful.
*/
void ass_drawing_hash(ass_drawing_t* drawing)
void ass_drawing_hash(ASS_Drawing* drawing)
{
drawing->hash = fnv_32a_str(drawing->text, FNV1_32A_INIT);
}
@ -415,10 +417,10 @@ void ass_drawing_hash(ass_drawing_t* drawing)
/*
* \brief Convert token list to outline. Calls the line and curve evaluators.
*/
FT_OutlineGlyph *ass_drawing_parse(ass_drawing_t *drawing, int raw_mode)
FT_OutlineGlyph *ass_drawing_parse(ASS_Drawing *drawing, int raw_mode)
{
int started = 0;
ass_drawing_token_t *token;
ASS_DrawingToken *token;
FT_Vector pen = {0, 0};
drawing->tokens = drawing_tokenize(drawing->text);

34
aegisub/libass/ass_drawing.h
View file

@ -26,7 +26,7 @@
#define DRAWING_INITIAL_SIZE 256
enum ass_token_type {
typedef enum {
TOKEN_MOVE,
TOKEN_MOVE_NC,
TOKEN_LINE,
@ -35,16 +35,16 @@ enum ass_token_type {
TOKEN_B_SPLINE,
TOKEN_EXTEND_SPLINE,
TOKEN_CLOSE
};
} ASS_TokenType;
typedef struct ass_drawing_token_s {
enum ass_token_type type;
typedef struct ass_drawing_token {
ASS_TokenType type;
FT_Vector point;
struct ass_drawing_token_s *next;
struct ass_drawing_token_s *prev;
} ass_drawing_token_t;
struct ass_drawing_token *next;
struct ass_drawing_token *prev;
} ASS_DrawingToken;
typedef struct ass_drawing_s {
typedef struct {
char *text; // drawing string
int i; // text index
int scale; // scale (1-64) for subpixel accuracy
@ -58,20 +58,20 @@ typedef struct ass_drawing_s {
// private
FT_Library ftlibrary; // FT library instance, needed for font ops
ass_library_t *library;
ASS_Library *library;
int size; // current buffer size
ass_drawing_token_t *tokens; // tokenized drawing
ASS_DrawingToken *tokens; // tokenized drawing
int max_points; // current maximum size
int max_contours;
double point_scale_x;
double point_scale_y;
} ass_drawing_t;
} ASS_Drawing;
ass_drawing_t *ass_drawing_new(void *fontconfig_priv, ass_font_t *font,
ass_hinting_t hint, FT_Library lib);
void ass_drawing_free(ass_drawing_t* drawing);
void ass_drawing_add_char(ass_drawing_t* drawing, char symbol);
void ass_drawing_hash(ass_drawing_t* drawing);
FT_OutlineGlyph *ass_drawing_parse(ass_drawing_t *drawing, int raw_mode);
ASS_Drawing *ass_drawing_new(void *fontconfig_priv, ASS_Font *font,
ASS_Hinting hint, FT_Library lib);
void ass_drawing_free(ASS_Drawing* drawing);
void ass_drawing_add_char(ASS_Drawing* drawing, char symbol);
void ass_drawing_hash(ASS_Drawing* drawing);
FT_OutlineGlyph *ass_drawing_parse(ASS_Drawing *drawing, int raw_mode);
#endif /* LIBASS_DRAWING_H */

131
aegisub/libass/ass_font.c
View file

@ -26,6 +26,7 @@
#include FT_SYNTHESIS_H
#include FT_GLYPH_H
#include FT_TRUETYPE_TABLES_H
#include FT_OUTLINE_H
#include "ass.h"
#include "ass_library.h"
@ -39,15 +40,15 @@
* Select Microfost Unicode CharMap, if the font has one.
* Otherwise, let FreeType decide.
*/
static void charmap_magic(ass_library_t *library, FT_Face face)
static void charmap_magic(ASS_Library *library, FT_Face face)
{
int i;
for (i = 0; i < face->num_charmaps; ++i) {
FT_CharMap cmap = face->charmaps[i];
unsigned pid = cmap->platform_id;
unsigned eid = cmap->encoding_id;
if (pid == 3 /*microsoft */
&& (eid == 1 /*unicode bmp */
if (pid == 3 /*microsoft */
&& (eid == 1 /*unicode bmp */
|| eid == 10 /*full unicode */ )) {
FT_Set_Charmap(face, cmap);
return;
@ -66,7 +67,7 @@ static void charmap_magic(ass_library_t *library, FT_Face face)
}
}
static void update_transform(ass_font_t *font)
static void update_transform(ASS_Font *font)
{
int i;
FT_Matrix m;
@ -80,7 +81,7 @@ static void update_transform(ass_font_t *font)
/**
* \brief find a memory font by name
*/
static int find_font(ass_library_t *library, char *name)
static int find_font(ASS_Library *library, char *name)
{
int i;
for (i = 0; i < library->num_fontdata; ++i)
@ -111,10 +112,10 @@ static void buggy_font_workaround(FT_Face face)
}
/**
* \brief Select a face with the given charcode and add it to ass_font_t
* \brief Select a face with the given charcode and add it to ASS_Font
* \return index of the new face in font->faces, -1 if failed
*/
static int add_face(void *fc_priv, ass_font_t *font, uint32_t ch)
static int add_face(void *fc_priv, ASS_Font *font, uint32_t ch)
{
char *path;
int index;
@ -166,17 +167,17 @@ static int add_face(void *fc_priv, ass_font_t *font, uint32_t ch)
}
/**
* \brief Create a new ass_font_t according to "desc" argument
* \brief Create a new ASS_Font according to "desc" argument
*/
ass_font_t *ass_font_new(void *font_cache, ass_library_t *library,
FT_Library ftlibrary, void *fc_priv,
ass_font_desc_t *desc)
ASS_Font *ass_font_new(void *font_cache, ASS_Library *library,
FT_Library ftlibrary, void *fc_priv,
ASS_FontDesc *desc)
{
int error;
ass_font_t *fontp;
ass_font_t font;
ASS_Font *fontp;
ASS_Font font;
fontp = ass_font_cache_find((hashmap_t *) font_cache, desc);
fontp = ass_font_cache_find((Hashmap *) font_cache, desc);
if (fontp)
return fontp;
@ -197,19 +198,21 @@ ass_font_t *ass_font_new(void *font_cache, ass_library_t *library,
free(font.desc.family);
return 0;
} else
return ass_font_cache_add((hashmap_t *) font_cache, &font);
return ass_font_cache_add((Hashmap *) font_cache, &font);
}
/**
* \brief Set font transformation matrix and shift vector
**/
void ass_font_set_transform(ass_font_t *font, double scale_x,
void ass_font_set_transform(ASS_Font *font, double scale_x,
double scale_y, FT_Vector *v)
{
font->scale_x = scale_x;
font->scale_y = scale_y;
font->v.x = v->x;
font->v.y = v->y;
if (v) {
font->v.x = v->x;
font->v.y = v->y;
}
update_transform(font);
}
@ -246,7 +249,7 @@ static void face_set_size(FT_Face face, double size)
/**
* \brief Set font size
**/
void ass_font_set_size(ass_font_t *font, double size)
void ass_font_set_size(ASS_Font *font, double size)
{
int i;
if (font->size != size) {
@ -261,16 +264,22 @@ void ass_font_set_size(ass_font_t *font, double size)
* \param ch character code
* The values are extracted from the font face that provides glyphs for the given character
**/
void ass_font_get_asc_desc(ass_font_t *font, uint32_t ch, int *asc,
void ass_font_get_asc_desc(ASS_Font *font, uint32_t ch, int *asc,
int *desc)
{
int i;
for (i = 0; i < font->n_faces; ++i) {
FT_Face face = font->faces[i];
TT_OS2 *os2 = FT_Get_Sfnt_Table(face, ft_sfnt_os2);
if (FT_Get_Char_Index(face, ch)) {
int y_scale = face->size->metrics.y_scale;
*asc = FT_MulFix(face->ascender, y_scale);
*desc = FT_MulFix(-face->descender, y_scale);
if (os2) {
*asc = FT_MulFix(os2->usWinAscent, y_scale);
*desc = FT_MulFix(os2->usWinDescent, y_scale);
} else {
*asc = FT_MulFix(face->ascender, y_scale);
*desc = FT_MulFix(-face->descender, y_scale);
}
return;
}
}
@ -285,13 +294,16 @@ void ass_font_get_asc_desc(ass_font_t *font, uint32_t ch, int *asc,
* being accurate.
*
*/
static int ass_strike_outline_glyph(FT_Face face, ass_font_t *font,
static int ass_strike_outline_glyph(FT_Face face, ASS_Font *font,
FT_Glyph glyph, int under, int through)
{
TT_OS2 *os2 = FT_Get_Sfnt_Table(face, ft_sfnt_os2);
TT_Postscript *ps = FT_Get_Sfnt_Table(face, ft_sfnt_post);
FT_Outline *ol = &((FT_OutlineGlyph) glyph)->outline;
int bear, advance, y_scale, i;
int bear, advance, y_scale, i, dir;
if (!under && !through)
return 0;
// Grow outline
i = (under ? 4 : 0) + (through ? 4 : 0);
@ -309,15 +321,18 @@ static int ass_strike_outline_glyph(FT_Face face, ass_font_t *font,
advance = d16_to_d6(glyph->advance.x) + 32;
y_scale = face->size->metrics.y_scale;
// Reverse drawing direction for non-truetype fonts
dir = FT_Outline_Get_Orientation(ol);
// Add points to the outline
if (under) {
if (under && ps) {
int pos, size;
pos = FT_MulFix(ps->underlinePosition, y_scale * font->scale_y);
size = FT_MulFix(ps->underlineThickness,
y_scale * font->scale_y / 2);
if (pos > 0 || size <= 0)
return 0;
return 1;
FT_Vector points[4] = {
{.x = bear, .y = pos + size},
@ -326,20 +341,28 @@ static int ass_strike_outline_glyph(FT_Face face, ass_font_t *font,
{.x = bear, .y = pos - size},
};
for (i = 0; i < 4; i++) {
ol->points[ol->n_points] = points[i];
ol->tags[ol->n_points++] = 1;
if (dir == FT_ORIENTATION_TRUETYPE) {
for (i = 0; i < 4; i++) {
ol->points[ol->n_points] = points[i];
ol->tags[ol->n_points++] = 1;
}
} else {
for (i = 3; i >= 0; i--) {
ol->points[ol->n_points] = points[i];
ol->tags[ol->n_points++] = 1;
}
}
ol->contours[ol->n_contours++] = ol->n_points - 1;
}
if (through) {
if (through && os2) {
int pos, size;
pos = FT_MulFix(os2->yStrikeoutPosition, y_scale * font->scale_y);
size = FT_MulFix(os2->yStrikeoutSize, y_scale * font->scale_y / 2);
if (pos < 0 || size <= 0)
return 0;
return 1;
FT_Vector points[4] = {
{.x = bear, .y = pos + size},
@ -348,23 +371,46 @@ static int ass_strike_outline_glyph(FT_Face face, ass_font_t *font,
{.x = bear, .y = pos - size},
};
for (i = 0; i < 4; i++) {
ol->points[ol->n_points] = points[i];
ol->tags[ol->n_points++] = 1;
if (dir == FT_ORIENTATION_TRUETYPE) {
for (i = 0; i < 4; i++) {
ol->points[ol->n_points] = points[i];
ol->tags[ol->n_points++] = 1;
}
} else {
for (i = 3; i >= 0; i--) {
ol->points[ol->n_points] = points[i];
ol->tags[ol->n_points++] = 1;
}
}
ol->contours[ol->n_contours++] = ol->n_points - 1;
}
return 1;
return 0;
}
/**
* Slightly embold a glyph without touching its metrics
*/
static void ass_glyph_embolden(FT_GlyphSlot slot)
{
int str;
if (slot->format != FT_GLYPH_FORMAT_OUTLINE)
return;
str = FT_MulFix(slot->face->units_per_EM,
slot->face->size->metrics.y_scale) / 64;
FT_Outline_Embolden(&slot->outline, str);
}
/**
* \brief Get a glyph
* \param ch character code
**/
FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
uint32_t ch, ass_hinting_t hinting, int deco)
FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ASS_Font *font,
uint32_t ch, ASS_Hinting hinting, int deco)
{
int error;
int index = 0;
@ -435,6 +481,11 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
(font->desc.italic > 55)) {
FT_GlyphSlot_Oblique(face->glyph);
}
if (!(face->style_flags & FT_STYLE_FLAG_BOLD) &&
(font->desc.bold > 80)) {
ass_glyph_embolden(face->glyph);
}
#endif
error = FT_Get_Glyph(face->glyph, &glyph);
if (error) {
@ -452,7 +503,7 @@ FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
/**
* \brief Get kerning for the pair of glyphs.
**/
FT_Vector ass_font_get_kerning(ass_font_t *font, uint32_t c1, uint32_t c2)
FT_Vector ass_font_get_kerning(ASS_Font *font, uint32_t c1, uint32_t c2)
{
FT_Vector v = { 0, 0 };
int i;
@ -473,9 +524,9 @@ FT_Vector ass_font_get_kerning(ass_font_t *font, uint32_t c1, uint32_t c2)
}
/**
* \brief Deallocate ass_font_t
* \brief Deallocate ASS_Font
**/
void ass_font_free(ass_font_t *font)
void ass_font_free(ASS_Font *font)
{
int i;
for (i = 0; i < font->n_faces; ++i)

34
aegisub/libass/ass_font.h
View file

@ -31,36 +31,36 @@
#define DECO_UNDERLINE 1
#define DECO_STRIKETHROUGH 2
typedef struct ass_font_desc_s {
typedef struct {
char *family;
unsigned bold;
unsigned italic;
int treat_family_as_pattern;
} ass_font_desc_t;
} ASS_FontDesc;
typedef struct ass_font_s {
ass_font_desc_t desc;
ass_library_t *library;
typedef struct {
ASS_FontDesc desc;
ASS_Library *library;
FT_Library ftlibrary;
FT_Face faces[ASS_FONT_MAX_FACES];
int n_faces;
double scale_x, scale_y; // current transform
FT_Vector v; // current shift
double size;
} ass_font_t;
} ASS_Font;
// FIXME: passing the hashmap via a void pointer is very ugly.
ass_font_t *ass_font_new(void *font_cache, ass_library_t *library,
FT_Library ftlibrary, void *fc_priv,
ass_font_desc_t *desc);
void ass_font_set_transform(ass_font_t *font, double scale_x,
double scale_y, FT_Vector * v);
void ass_font_set_size(ass_font_t *font, double size);
void ass_font_get_asc_desc(ass_font_t *font, uint32_t ch, int *asc,
ASS_Font *ass_font_new(void *font_cache, ASS_Library *library,
FT_Library ftlibrary, void *fc_priv,
ASS_FontDesc *desc);
void ass_font_set_transform(ASS_Font *font, double scale_x,
double scale_y, FT_Vector *v);
void ass_font_set_size(ASS_Font *font, double size);
void ass_font_get_asc_desc(ASS_Font *font, uint32_t ch, int *asc,
int *desc);
FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ass_font_t *font,
uint32_t ch, ass_hinting_t hinting, int flags);
FT_Vector ass_font_get_kerning(ass_font_t *font, uint32_t c1, uint32_t c2);
void ass_font_free(ass_font_t *font);
FT_Glyph ass_font_get_glyph(void *fontconfig_priv, ASS_Font *font,
uint32_t ch, ASS_Hinting hinting, int flags);
FT_Vector ass_font_get_kerning(ASS_Font *font, uint32_t c1, uint32_t c2);
void ass_font_free(ASS_Font *font);
#endif /* LIBASS_FONT_H */

62
aegisub/libass/ass_fontconfig.c
View file

@ -40,7 +40,7 @@
#include <fontconfig/fcfreetype.h>
#endif
struct fc_instance_s {
struct fc_instance {
#ifdef CONFIG_FONTCONFIG
FcConfig *config;
#endif
@ -71,7 +71,7 @@ struct fc_instance_s {
* \param code: the character that should be present in the font, can be 0
* \return font file path
*/
static char *_select_font(ass_library_t *library, fc_instance_t *priv,
static char *_select_font(ASS_Library *library, FCInstance *priv,
const char *family, int treat_family_as_pattern,
unsigned bold, unsigned italic, int *index,
uint32_t code)
@ -242,7 +242,7 @@ static char *_select_font(ass_library_t *library, fc_instance_t *priv,
* \param code: the character that should be present in the font, can be 0
* \return font file path
*/
char *fontconfig_select(ass_library_t *library, fc_instance_t *priv,
char *fontconfig_select(ASS_Library *library, FCInstance *priv,
const char *family, int treat_family_as_pattern,
unsigned bold, unsigned italic, int *index,
uint32_t code)
@ -331,7 +331,7 @@ static char *validate_fname(char *name)
* With FontConfig >= 2.4.2, builds a font pattern in memory via FT_New_Memory_Face/FcFreeTypeQueryFace.
* With older FontConfig versions, save the font to ~/.mplayer/fonts.
*/
static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
static void process_fontdata(FCInstance *priv, ASS_Library *library,
FT_Library ftlibrary, int idx)
{
int rc;
@ -432,13 +432,13 @@ static void process_fontdata(fc_instance_t *priv, ass_library_t *library,
* \param update whether the fontconfig cache should be built/updated
* \return pointer to fontconfig private data
*/
fc_instance_t *fontconfig_init(ass_library_t *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update)
FCInstance *fontconfig_init(ASS_Library *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update)
{
int rc;
fc_instance_t *priv = calloc(1, sizeof(fc_instance_t));
FCInstance *priv = calloc(1, sizeof(FCInstance));
const char *dir = library->fonts_dir;
int i;
@ -448,17 +448,22 @@ fc_instance_t *fontconfig_init(ass_library_t *library,
goto exit;
}
if (!config)
config = (char *) FcConfigFilename(NULL);
priv->config = FcConfigCreate();
rc = FcConfigParseAndLoad(priv->config, (unsigned char *) config, FcTrue);
if (!rc) {
ass_msg(library, MSGL_WARN, "No usable fontconfig configuration "
"file found, using fallback.");
FcConfigDestroy(priv->config);
priv->config = FcInitLoadConfig();
rc++;
}
if (rc && update) {
FcConfigBuildFonts(priv->config);
}
if (!rc || !priv->config) {
ass_msg(library, MSGL_FATAL, "%s failed", "FcInitLoadConfigAndFonts");
ass_msg(library, MSGL_FATAL,
"No valid fontconfig configuration found!");
FcConfigDestroy(priv->config);
goto exit;
}
@ -516,48 +521,53 @@ exit:
return priv;
}
int fontconfig_update(fc_instance_t *priv)
int fontconfig_update(FCInstance *priv)
{
return FcConfigBuildFonts(priv->config);
}
#else /* CONFIG_FONTCONFIG */
char *fontconfig_select(fc_instance_t *priv, const char *family,
int treat_family_as_pattern, unsigned bold,
unsigned italic, int *index, uint32_t code)
char *fontconfig_select(ASS_Library *library, FCInstance *priv,
const char *family, int treat_family_as_pattern,
unsigned bold, unsigned italic, int *index,
uint32_t code)
{
*index = priv->index_default;
return priv->path_default;
}
fc_instance_t *fontconfig_init(ass_library_t *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update)
FCInstance *fontconfig_init(ASS_Library *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update)
{
fc_instance_t *priv;
FCInstance *priv;
ass_msg(library, MSGL_WARN,
"Fontconfig disabled, only default font will be used.");
priv = calloc(1, sizeof(fc_instance_t));
priv = calloc(1, sizeof(FCInstance));
priv->path_default = strdup(path);
priv->index_default = 0;
return priv;
}
int fontconfig_update(fc_instance_t *priv)
int fontconfig_update(FCInstance *priv)
{
// Do nothing
return 1;
}
#endif
void fontconfig_done(fc_instance_t *priv)
void fontconfig_done(FCInstance *priv)
{
// don't call FcFini() here, library can still be used by some code
#ifdef CONFIG_FONTCONFIG
if (priv && priv->config)
FcConfigDestroy(priv->config);
#endif
if (priv && priv->path_default)
free(priv->path_default);
if (priv && priv->family_default)

16
aegisub/libass/ass_fontconfig.h
View file

@ -31,17 +31,17 @@
#include <fontconfig/fontconfig.h>
#endif
typedef struct fc_instance_s fc_instance_t;
typedef struct fc_instance FCInstance;
fc_instance_t *fontconfig_init(ass_library_t *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update);
char *fontconfig_select(ass_library_t *library, fc_instance_t *priv,
FCInstance *fontconfig_init(ASS_Library *library,
FT_Library ftlibrary, const char *family,
const char *path, int fc, const char *config,
int update);
char *fontconfig_select(ASS_Library *library, FCInstance *priv,
const char *family, int treat_family_as_pattern,
unsigned bold, unsigned italic, int *index,
uint32_t code);
void fontconfig_done(fc_instance_t *priv);
int fontconfig_update(fc_instance_t *priv);
void fontconfig_done(FCInstance *priv);
int fontconfig_update(FCInstance *priv);
#endif /* LIBASS_FONTCONFIG_H */

25
aegisub/libass/ass_library.c
View file

@ -28,24 +28,24 @@
#include "ass_library.h"
#include "ass_utils.h"
static void ass_msg_handler(int level, char *fmt, va_list *va, void *data)
static void ass_msg_handler(int level, const char *fmt, va_list va, void *data)
{
if (level > MSGL_INFO)
return;
fprintf(stderr, "[ass] ");
vfprintf(stderr, fmt, *va);
vfprintf(stderr, fmt, va);
fprintf(stderr, "\n");
}
ass_library_t *ass_library_init(void)
ASS_Library *ass_library_init(void)
{
ass_library_t* lib = calloc(1, sizeof(ass_library_t));
ASS_Library* lib = calloc(1, sizeof(*lib));
lib->msg_callback = ass_msg_handler;
return lib;
}
void ass_library_done(ass_library_t *priv)
void ass_library_done(ASS_Library *priv)
{
if (priv) {
ass_set_fonts_dir(priv, NULL);
@ -55,7 +55,7 @@ void ass_library_done(ass_library_t *priv)
}
}
void ass_set_fonts_dir(ass_library_t *priv, const char *fonts_dir)
void ass_set_fonts_dir(ASS_Library *priv, const char *fonts_dir)
{
if (priv->fonts_dir)
free(priv->fonts_dir);
@ -63,12 +63,12 @@ void ass_set_fonts_dir(ass_library_t *priv, const char *fonts_dir)
priv->fonts_dir = fonts_dir ? strdup(fonts_dir) : 0;
}
void ass_set_extract_fonts(ass_library_t *priv, int extract)
void ass_set_extract_fonts(ASS_Library *priv, int extract)
{
priv->extract_fonts = !!extract;
}
void ass_set_style_overrides(ass_library_t *priv, char **list)
void ass_set_style_overrides(ASS_Library *priv, char **list)
{
char **p;
char **q;
@ -98,7 +98,7 @@ static void grow_array(void **array, int nelem, size_t elsize)
*array = realloc(*array, (nelem + 32) * elsize);
}
void ass_add_font(ass_library_t *priv, char *name, char *data, int size)
void ass_add_font(ASS_Library *priv, char *name, char *data, int size)
{
int idx = priv->num_fontdata;
if (!name || !data || !size)
@ -116,7 +116,7 @@ void ass_add_font(ass_library_t *priv, char *name, char *data, int size)
priv->num_fontdata++;
}
void ass_clear_fonts(ass_library_t *priv)
void ass_clear_fonts(ASS_Library *priv)
{
int i;
for (i = 0; i < priv->num_fontdata; ++i) {
@ -136,8 +136,8 @@ void ass_clear_fonts(ass_library_t *priv)
* \param msg_cb the callback function
* \param data additional data that will be passed to the callback
*/
void ass_set_message_cb(ass_library_t *priv,
void (*msg_cb)(int, char *, va_list *, void *),
void ass_set_message_cb(ASS_Library *priv,
void (*msg_cb)(int, const char *, va_list, void *),
void *data)
{
if (msg_cb) {
@ -145,4 +145,3 @@ void ass_set_message_cb(ass_library_t *priv,
priv->msg_callback_data = data;
}
}

10
aegisub/libass/ass_library.h
View file

@ -23,20 +23,20 @@
#include <stdarg.h>
typedef struct ass_fontdata_s {
typedef struct {
char *name;
char *data;
int size;
} ass_fontdata_t;
} ASS_Fontdata;
struct ass_library_s {
struct ass_library {
char *fonts_dir;
int extract_fonts;
char **style_overrides;
ass_fontdata_t *fontdata;
ASS_Fontdata *fontdata;
int num_fontdata;
void (*msg_callback)(int, char *, va_list *, void *);
void (*msg_callback)(int, const char *, va_list, void *);
void *msg_callback_data;
};

857
aegisub/libass/ass_parse.c Normal file
View file

@ -0,0 +1,857 @@
/*
* Copyright (C) 2009 Grigori Goronzy <greg@geekmind.org>
*
* This file is part of libass.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "ass_render.h"
#include "ass_parse.h"
#define MAX_BE 127
#define NBSP 0xa0 // unicode non-breaking space character
#define skip_to(x) while ((*p != (x)) && (*p != '}') && (*p != 0)) { ++p;}
#define skip(x) if (*p == (x)) ++p; else { return p; }
#define skipopt(x) if (*p == (x)) { ++p; }
/**
* \brief Check if starting part of (*p) matches sample.
* If true, shift p to the first symbol after the matching part.
*/
static inline int mystrcmp(char **p, const char *sample)
{
int len = strlen(sample);
if (strncmp(*p, sample, len) == 0) {
(*p) += len;
return 1;
} else
return 0;
}
static void change_font_size(ASS_Renderer *render_priv, double sz)
{
double size = sz * render_priv->font_scale;
if (size < 1)
size = 1;
else if (size > render_priv->height * 2)
size = render_priv->height * 2;
ass_font_set_size(render_priv->state.font, size);
render_priv->state.font_size = sz;
}
/**
* \brief Change current font, using setting from render_priv->state.
*/
void update_font(ASS_Renderer *render_priv)
{
unsigned val;
ASS_FontDesc desc;
desc.family = strdup(render_priv->state.family);
desc.treat_family_as_pattern =
render_priv->state.treat_family_as_pattern;
val = render_priv->state.bold;
// 0 = normal, 1 = bold, >1 = exact weight
if (val == 1 || val == -1)
val = 200; // bold
else if (val <= 0)
val = 80; // normal
desc.bold = val;
val = render_priv->state.italic;
if (val == 1 || val == -1)
val = 110; // italic
else if (val <= 0)
val = 0; // normal
desc.italic = val;
render_priv->state.font =
ass_font_new(render_priv->cache.font_cache, render_priv->library,
render_priv->ftlibrary, render_priv->fontconfig_priv,
&desc);
free(desc.family);
if (render_priv->state.font)
change_font_size(render_priv, render_priv->state.font_size);
}
/**
* \brief Change border width
* negative value resets border to style value
*/
void change_border(ASS_Renderer *render_priv, double border_x,
double border_y)
{
int bord;
if (!render_priv->state.font)
return;
if (border_x < 0 && border_y < 0) {
if (render_priv->state.style->BorderStyle == 1 ||
render_priv->state.style->BorderStyle == 3)
border_x = border_y = render_priv->state.style->Outline;
else
border_x = border_y = 1.;
}
render_priv->state.border_x = border_x;
render_priv->state.border_y = border_y;
bord = 64 * border_x * render_priv->border_scale;
if (bord > 0 && border_x == border_y) {
if (!render_priv->state.stroker) {
int error;
#if (FREETYPE_MAJOR > 2) || ((FREETYPE_MAJOR == 2) && (FREETYPE_MINOR > 1))
error =
FT_Stroker_New(render_priv->ftlibrary,
&render_priv->state.stroker);
#else // < 2.2
error =
FT_Stroker_New(render_priv->state.font->faces[0]->
memory, &render_priv->state.stroker);
#endif
if (error) {
ass_msg(render_priv->library, MSGL_V,
"failed to get stroker");
render_priv->state.stroker = 0;
}
}
if (render_priv->state.stroker)
FT_Stroker_Set(render_priv->state.stroker, bord,
FT_STROKER_LINECAP_ROUND,
FT_STROKER_LINEJOIN_ROUND, 0);
} else {
FT_Stroker_Done(render_priv->state.stroker);
render_priv->state.stroker = 0;
}
}
/**
* \brief Calculate a weighted average of two colors
* calculates c1*(1-a) + c2*a, but separately for each component except alpha
*/
static void change_color(uint32_t *var, uint32_t new, double pwr)
{
(*var) = ((uint32_t) (_r(*var) * (1 - pwr) + _r(new) * pwr) << 24) +
((uint32_t) (_g(*var) * (1 - pwr) + _g(new) * pwr) << 16) +
((uint32_t) (_b(*var) * (1 - pwr) + _b(new) * pwr) << 8) + _a(*var);
}
// like change_color, but for alpha component only
inline void change_alpha(uint32_t *var, uint32_t new, double pwr)
{
*var =
(_r(*var) << 24) + (_g(*var) << 16) + (_b(*var) << 8) +
(_a(*var) * (1 - pwr) + _a(new) * pwr);
}
/**
* \brief Multiply two alpha values
* \param a first value
* \param b second value
* \return result of multiplication
* Parameters and result are limited by 0xFF.
*/
inline uint32_t mult_alpha(uint32_t a, uint32_t b)
{
return 0xFF - (0xFF - a) * (0xFF - b) / 0xFF;
}
/**
* \brief Calculate alpha value by piecewise linear function
* Used for \fad, \fade implementation.
*/
static unsigned
interpolate_alpha(long long now, long long t1, long long t2, long long t3,
long long t4, unsigned a1, unsigned a2, unsigned a3)
{
unsigned a;
double cf;
if (now <= t1) {
a = a1;
} else if (now >= t4) {
a = a3;
} else if (now < t2) { // and > t1
cf = ((double) (now - t1)) / (t2 - t1);
a = a1 * (1 - cf) + a2 * cf;
} else if (now > t3) {
cf = ((double) (now - t3)) / (t4 - t3);
a = a2 * (1 - cf) + a3 * cf;
} else { // t2 <= now <= t3
a = a2;
}
return a;
}
/**
* Parse a vector clip into an outline, using the proper scaling
* parameters. Translate it to correct for screen borders, if needed.
*/
static char *parse_vector_clip(ASS_Renderer *render_priv, char *p)
{
int scale = 1;
int res = 0;
ASS_Drawing *drawing;
render_priv->state.clip_drawing = ass_drawing_new(
render_priv->fontconfig_priv,
render_priv->state.font,
render_priv->settings.hinting,
render_priv->ftlibrary);
drawing = render_priv->state.clip_drawing;
skipopt('(');
res = mystrtoi(&p, &scale);
skipopt(',')
if (!res)
scale = 1;
drawing->scale = scale;
drawing->scale_x = render_priv->font_scale_x * render_priv->font_scale;
drawing->scale_y = render_priv->font_scale;
while (*p != ')' && *p != '}' && p != 0)
ass_drawing_add_char(drawing, *p++);
skipopt(')');
ass_drawing_parse(drawing, 1);
// We need to translate the clip according to screen borders
if (render_priv->settings.left_margin != 0 ||
render_priv->settings.top_margin != 0) {
FT_Vector trans = {
.x = int_to_d6(render_priv->settings.left_margin),
.y = -int_to_d6(render_priv->settings.top_margin),
};
FT_Outline_Translate(&drawing->glyph->outline, trans.x, trans.y);
}
ass_msg(render_priv->library, MSGL_DBG2,
"Parsed vector clip: scale %d, scales (%f, %f) string [%s]\n",
scale, drawing->scale_x, drawing->scale_y, drawing->text);
return p;
}
/**
* \brief Parse style override tag.
* \param p string to parse
* \param pwr multiplier for some tag effects (comes from \t tags)
*/
static char *parse_tag(ASS_Renderer *render_priv, char *p, double pwr)
{
skip_to('\\');
skip('\\');
if ((*p == '}') || (*p == 0))
return p;
// New tags introduced in vsfilter 2.39
if (mystrcmp(&p, "xbord")) {
double val;
if (mystrtod(&p, &val))
val = render_priv->state.border_x * (1 - pwr) + val * pwr;
else
val = -1.;
change_border(render_priv, val, render_priv->state.border_y);
} else if (mystrcmp(&p, "ybord")) {
double val;
if (mystrtod(&p, &val))
val = render_priv->state.border_y * (1 - pwr) + val * pwr;
else
val = -1.;
change_border(render_priv, render_priv->state.border_x, val);
} else if (mystrcmp(&p, "xshad")) {
double val;
if (mystrtod(&p, &val))
val = render_priv->state.shadow_x * (1 - pwr) + val * pwr;
else
val = 0.;
render_priv->state.shadow_x = val;
} else if (mystrcmp(&p, "yshad")) {
double val;
if (mystrtod(&p, &val))
val = render_priv->state.shadow_y * (1 - pwr) + val * pwr;
else
val = 0.;
render_priv->state.shadow_y = val;
} else if (mystrcmp(&p, "fax")) {
double val;
if (mystrtod(&p, &val))
render_priv->state.fax =
val * pwr + render_priv->state.fax * (1 - pwr);
else
render_priv->state.fax = 0.;
} else if (mystrcmp(&p, "fay")) {
double val;
if (mystrtod(&p, &val))
render_priv->state.fay =
val * pwr + render_priv->state.fay * (1 - pwr);
else
render_priv->state.fay = 0.;
} else if (mystrcmp(&p, "iclip")) {
int x0, y0, x1, y1;
int res = 1;
char *start = p;
skipopt('(');
res &= mystrtoi(&p, &x0);
skipopt(',');
res &= mystrtoi(&p, &y0);
skipopt(',');
res &= mystrtoi(&p, &x1);
skipopt(',');
res &= mystrtoi(&p, &y1);
skipopt(')');
if (res) {
render_priv->state.clip_x0 =
render_priv->state.clip_x0 * (1 - pwr) + x0 * pwr;
render_priv->state.clip_x1 =
render_priv->state.clip_x1 * (1 - pwr) + x1 * pwr;
render_priv->state.clip_y0 =
render_priv->state.clip_y0 * (1 - pwr) + y0 * pwr;
render_priv->state.clip_y1 =
render_priv->state.clip_y1 * (1 - pwr) + y1 * pwr;
render_priv->state.clip_mode = 1;
} else if (!render_priv->state.clip_drawing) {
p = parse_vector_clip(render_priv, start);
render_priv->state.clip_drawing_mode = 1;
} else
render_priv->state.clip_mode = 0;
} else if (mystrcmp(&p, "blur")) {
double val;
if (mystrtod(&p, &val)) {
val = render_priv->state.blur * (1 - pwr) + val * pwr;
val = (val < 0) ? 0 : val;
val = (val > BLUR_MAX_RADIUS) ? BLUR_MAX_RADIUS : val;
render_priv->state.blur = val;
} else
render_priv->state.blur = 0.0;
// ASS standard tags
} else if (mystrcmp(&p, "fsc")) {
char tp = *p++;
double val;
if (tp == 'x') {
if (mystrtod(&p, &val)) {
val /= 100;
render_priv->state.scale_x =
render_priv->state.scale_x * (1 - pwr) + val * pwr;
} else
render_priv->state.scale_x =
render_priv->state.style->ScaleX;
} else if (tp == 'y') {
if (mystrtod(&p, &val)) {
val /= 100;
render_priv->state.scale_y =
render_priv->state.scale_y * (1 - pwr) + val * pwr;
} else
render_priv->state.scale_y =
render_priv->state.style->ScaleY;
}
} else if (mystrcmp(&p, "fsp")) {
double val;
if (mystrtod(&p, &val))
render_priv->state.hspacing =
render_priv->state.hspacing * (1 - pwr) + val * pwr;
else
render_priv->state.hspacing = render_priv->state.style->Spacing;
} else if (mystrcmp(&p, "fs")) {
double val;
if (mystrtod(&p, &val))
val = render_priv->state.font_size * (1 - pwr) + val * pwr;
else
val = render_priv->state.style->FontSize;
if (render_priv->state.font)
change_font_size(render_priv, val);
} else if (mystrcmp(&p, "bord")) {
double val;
if (mystrtod(&p, &val)) {
if (render_priv->state.border_x == render_priv->state.border_y)
val = render_priv->state.border_x * (1 - pwr) + val * pwr;
} else
val = -1.; // reset to default
change_border(render_priv, val, val);
} else if (mystrcmp(&p, "move")) {
double x1, x2, y1, y2;
long long t1, t2, delta_t, t;
double x, y;
double k;
skip('(');
mystrtod(&p, &x1);
skip(',');
mystrtod(&p, &y1);
skip(',');
mystrtod(&p, &x2);
skip(',');
mystrtod(&p, &y2);
if (*p == ',') {
skip(',');
mystrtoll(&p, &t1);
skip(',');
mystrtoll(&p, &t2);
ass_msg(render_priv->library, MSGL_DBG2,
"movement6: (%f, %f) -> (%f, %f), (%" PRId64 " .. %"
PRId64 ")\n", x1, y1, x2, y2, (int64_t) t1,
(int64_t) t2);
} else {
t1 = 0;
t2 = render_priv->state.event->Duration;
ass_msg(render_priv->library, MSGL_DBG2,
"movement: (%f, %f) -> (%f, %f)", x1, y1, x2, y2);
}
skip(')');
delta_t = t2 - t1;
t = render_priv->time - render_priv->state.event->Start;
if (t < t1)
k = 0.;
else if (t > t2)
k = 1.;
else
k = ((double) (t - t1)) / delta_t;
x = k * (x2 - x1) + x1;
y = k * (y2 - y1) + y1;
if (render_priv->state.evt_type != EVENT_POSITIONED) {
render_priv->state.pos_x = x;
render_priv->state.pos_y = y;
render_priv->state.detect_collisions = 0;
render_priv->state.evt_type = EVENT_POSITIONED;
}
} else if (mystrcmp(&p, "frx")) {
double val;
if (mystrtod(&p, &val)) {
val *= M_PI / 180;
render_priv->state.frx =
val * pwr + render_priv->state.frx * (1 - pwr);
} else
render_priv->state.frx = 0.;
} else if (mystrcmp(&p, "fry")) {
double val;
if (mystrtod(&p, &val)) {
val *= M_PI / 180;
render_priv->state.fry =
val * pwr + render_priv->state.fry * (1 - pwr);
} else
render_priv->state.fry = 0.;
} else if (mystrcmp(&p, "frz") || mystrcmp(&p, "fr")) {
double val;
if (mystrtod(&p, &val)) {
val *= M_PI / 180;
render_priv->state.frz =
val * pwr + render_priv->state.frz * (1 - pwr);
} else
render_priv->state.frz =
M_PI * render_priv->state.style->Angle / 180.;
} else if (mystrcmp(&p, "fn")) {
char *start = p;
char *family;
skip_to('\\');
if (p > start) {
family = malloc(p - start + 1);
strncpy(family, start, p - start);
family[p - start] = '\0';
} else
family = strdup(render_priv->state.style->FontName);
if (render_priv->state.family)
free(render_priv->state.family);
render_priv->state.family = family;
update_font(render_priv);
} else if (mystrcmp(&p, "alpha")) {
uint32_t val;
int i;
int hex = render_priv->track->track_type == TRACK_TYPE_ASS;
if (strtocolor(render_priv->library, &p, &val, hex)) {
unsigned char a = val >> 24;
for (i = 0; i < 4; ++i)
change_alpha(&render_priv->state.c[i], a, pwr);
} else {
change_alpha(&render_priv->state.c[0],
render_priv->state.style->PrimaryColour, pwr);
change_alpha(&render_priv->state.c[1],
render_priv->state.style->SecondaryColour, pwr);
change_alpha(&render_priv->state.c[2],
render_priv->state.style->OutlineColour, pwr);
change_alpha(&render_priv->state.c[3],
render_priv->state.style->BackColour, pwr);
}
// FIXME: simplify
} else if (mystrcmp(&p, "an")) {
int val;
if (mystrtoi(&p, &val) && val) {
int v = (val - 1) / 3; // 0, 1 or 2 for vertical alignment
ass_msg(render_priv->library, MSGL_DBG2, "an %d", val);
if (v != 0)
v = 3 - v;
val = ((val - 1) % 3) + 1; // horizontal alignment
val += v * 4;
ass_msg(render_priv->library, MSGL_DBG2, "align %d", val);
render_priv->state.alignment = val;
} else
render_priv->state.alignment =
render_priv->state.style->Alignment;
} else if (mystrcmp(&p, "a")) {
int val;
if (mystrtoi(&p, &val) && val)
// take care of a vsfilter quirk: handle illegal \a8 like \a5
render_priv->state.alignment = (val == 8) ? 5 : val;
else
render_priv->state.alignment =
render_priv->state.style->Alignment;
} else if (mystrcmp(&p, "pos")) {
double v1, v2;
skip('(');
mystrtod(&p, &v1);
skip(',');
mystrtod(&p, &v2);
skip(')');
ass_msg(render_priv->library, MSGL_DBG2, "pos(%f, %f)", v1, v2);
if (render_priv->state.evt_type == EVENT_POSITIONED) {
ass_msg(render_priv->library, MSGL_V, "Subtitle has a new \\pos "
"after \\move or \\pos, ignoring");
} else {
render_priv->state.evt_type = EVENT_POSITIONED;
render_priv->state.detect_collisions = 0;
render_priv->state.pos_x = v1;
render_priv->state.pos_y = v2;
}
} else if (mystrcmp(&p, "fad")) {
int a1, a2, a3;
long long t1, t2, t3, t4;
if (*p == 'e')
++p; // either \fad or \fade
skip('(');
mystrtoi(&p, &a1);
skip(',');
mystrtoi(&p, &a2);
if (*p == ')') {
// 2-argument version (\fad, according to specs)
// a1 and a2 are fade-in and fade-out durations
t1 = 0;
t4 = render_priv->state.event->Duration;
t2 = a1;
t3 = t4 - a2;
a1 = 0xFF;
a2 = 0;
a3 = 0xFF;
} else {
// 6-argument version (\fade)
// a1 and a2 (and a3) are opacity values
skip(',');
mystrtoi(&p, &a3);
skip(',');
mystrtoll(&p, &t1);
skip(',');
mystrtoll(&p, &t2);
skip(',');
mystrtoll(&p, &t3);
skip(',');
mystrtoll(&p, &t4);
}
skip(')');
render_priv->state.fade =
interpolate_alpha(render_priv->time -
render_priv->state.event->Start, t1, t2,
t3, t4, a1, a2, a3);
} else if (mystrcmp(&p, "org")) {
int v1, v2;
skip('(');
mystrtoi(&p, &v1);
skip(',');
mystrtoi(&p, &v2);
skip(')');
ass_msg(render_priv->library, MSGL_DBG2, "org(%d, %d)", v1, v2);
if (!render_priv->state.have_origin) {
render_priv->state.org_x = v1;
render_priv->state.org_y = v2;
render_priv->state.have_origin = 1;
render_priv->state.detect_collisions = 0;
}
} else if (mystrcmp(&p, "t")) {
double v[3];
int v1, v2;
double v3;
int cnt;
long long t1, t2, t, delta_t;
double k;
skip('(');
for (cnt = 0; cnt < 3; ++cnt) {
if (*p == '\\')
break;
v[cnt] = strtod(p, &p);
skip(',');
}
if (cnt == 3) {
v1 = v[0];
v2 = (v[1] < v1) ? render_priv->state.event->Duration : v[1];
v3 = v[2];
} else if (cnt == 2) {
v1 = v[0];
v2 = (v[1] < v1) ? render_priv->state.event->Duration : v[1];
v3 = 1.;
} else if (cnt == 1) {
v1 = 0;
v2 = render_priv->state.event->Duration;
v3 = v[0];
} else { // cnt == 0
v1 = 0;
v2 = render_priv->state.event->Duration;
v3 = 1.;
}
render_priv->state.detect_collisions = 0;
t1 = v1;
t2 = v2;
delta_t = v2 - v1;
if (v3 < 0.)
v3 = 0.;
t = render_priv->time - render_priv->state.event->Start; // FIXME: move to render_context
if (t <= t1)
k = 0.;
else if (t >= t2)
k = 1.;
else {
assert(delta_t != 0.);
k = pow(((double) (t - t1)) / delta_t, v3);
}
while (*p == '\\')
p = parse_tag(render_priv, p, k); // maybe k*pwr ? no, specs forbid nested \t's
skip_to(')'); // in case there is some unknown tag or a comment
skip(')');
} else if (mystrcmp(&p, "clip")) {
char *start = p;
int x0, y0, x1, y1;
int res = 1;
skipopt('(');
res &= mystrtoi(&p, &x0);
skipopt(',');
res &= mystrtoi(&p, &y0);
skipopt(',');
res &= mystrtoi(&p, &x1);
skipopt(',');
res &= mystrtoi(&p, &y1);
skipopt(')');
if (res) {
render_priv->state.clip_x0 =
render_priv->state.clip_x0 * (1 - pwr) + x0 * pwr;
render_priv->state.clip_x1 =
render_priv->state.clip_x1 * (1 - pwr) + x1 * pwr;
render_priv->state.clip_y0 =
render_priv->state.clip_y0 * (1 - pwr) + y0 * pwr;
render_priv->state.clip_y1 =
render_priv->state.clip_y1 * (1 - pwr) + y1 * pwr;
// Might be a vector clip
} else if (!render_priv->state.clip_drawing) {
p = parse_vector_clip(render_priv, start);
render_priv->state.clip_drawing_mode = 0;
} else {
render_priv->state.clip_x0 = 0;
render_priv->state.clip_y0 = 0;
render_priv->state.clip_x1 = render_priv->track->PlayResX;
render_priv->state.clip_y1 = render_priv->track->PlayResY;
}
} else if (mystrcmp(&p, "c")) {
uint32_t val;
int hex = render_priv->track->track_type == TRACK_TYPE_ASS;
if (!strtocolor(render_priv->library, &p, &val, hex))
val = render_priv->state.style->PrimaryColour;
ass_msg(render_priv->library, MSGL_DBG2, "color: %X", val);
change_color(&render_priv->state.c[0], val, pwr);
} else if ((*p >= '1') && (*p <= '4') && (++p)
&& (mystrcmp(&p, "c") || mystrcmp(&p, "a"))) {
char n = *(p - 2);
int cidx = n - '1';
char cmd = *(p - 1);
uint32_t val;
int hex = render_priv->track->track_type == TRACK_TYPE_ASS;
assert((n >= '1') && (n <= '4'));
if (!strtocolor(render_priv->library, &p, &val, hex))
switch (n) {
case '1':
val = render_priv->state.style->PrimaryColour;
break;
case '2':
val = render_priv->state.style->SecondaryColour;
break;
case '3':
val = render_priv->state.style->OutlineColour;
break;
case '4':
val = render_priv->state.style->BackColour;
break;
default:
val = 0;
break; // impossible due to assert; avoid compilation warning
}
switch (cmd) {
case 'c':
change_color(render_priv->state.c + cidx, val, pwr);
break;
case 'a':
change_alpha(render_priv->state.c + cidx, val >> 24, pwr);
break;
default:
ass_msg(render_priv->library, MSGL_WARN, "Bad command: %c%c",
n, cmd);
break;
}
ass_msg(render_priv->library, MSGL_DBG2, "single c/a at %f: %c%c = %X",
pwr, n, cmd, render_priv->state.c[cidx]);
} else if (mystrcmp(&p, "r")) {
reset_render_context(render_priv);
} else if (mystrcmp(&p, "be")) {
int val;
if (mystrtoi(&p, &val)) {
// Clamp to a safe upper limit, since high values need excessive CPU
val = (val < 0) ? 0 : val;
val = (val > MAX_BE) ? MAX_BE : val;
render_priv->state.be = val;
} else
render_priv->state.be = 0;
} else if (mystrcmp(&p, "b")) {
int b;
if (mystrtoi(&p, &b)) {
if (pwr >= .5)
render_priv->state.bold = b;
} else
render_priv->state.bold = render_priv->state.style->Bold;
update_font(render_priv);
} else if (mystrcmp(&p, "i")) {
int i;
if (mystrtoi(&p, &i)) {
if (pwr >= .5)
render_priv->state.italic = i;
} else
render_priv->state.italic = render_priv->state.style->Italic;
update_font(render_priv);
} else if (mystrcmp(&p, "kf") || mystrcmp(&p, "K")) {
int val = 0;
mystrtoi(&p, &val);
render_priv->state.effect_type = EF_KARAOKE_KF;
if (render_priv->state.effect_timing)
render_priv->state.effect_skip_timing +=
render_priv->state.effect_timing;
render_priv->state.effect_timing = val * 10;
} else if (mystrcmp(&p, "ko")) {
int val = 0;
mystrtoi(&p, &val);
render_priv->state.effect_type = EF_KARAOKE_KO;
if (render_priv->state.effect_timing)
render_priv->state.effect_skip_timing +=
render_priv->state.effect_timing;
render_priv->state.effect_timing = val * 10;
} else if (mystrcmp(&p, "k")) {
int val = 0;
mystrtoi(&p, &val);
render_priv->state.effect_type = EF_KARAOKE;
if (render_priv->state.effect_timing)
render_priv->state.effect_skip_timing +=
render_priv->state.effect_timing;
render_priv->state.effect_timing = val * 10;
} else if (mystrcmp(&p, "shad")) {
double val;
if (mystrtod(&p, &val)) {
if (render_priv->state.shadow_x == render_priv->state.shadow_y)
val = render_priv->state.shadow_x * (1 - pwr) + val * pwr;
} else
val = 0.;
render_priv->state.shadow_x = render_priv->state.shadow_y = val;
} else if (mystrcmp(&p, "s")) {
int val;
if (mystrtoi(&p, &val) && val)
render_priv->state.flags |= DECO_STRIKETHROUGH;
else
render_priv->state.flags &= ~DECO_STRIKETHROUGH;
} else if (mystrcmp(&p, "u")) {
int val;
if (mystrtoi(&p, &val) && val)
render_priv->state.flags |= DECO_UNDERLINE;
else
render_priv->state.flags &= ~DECO_UNDERLINE;
} else if (mystrcmp(&p, "pbo")) {
double val = 0;
if (mystrtod(&p, &val))
render_priv->state.drawing->pbo = val;
} else if (mystrcmp(&p, "p")) {
int val;
if (!mystrtoi(&p, &val))
val = 0;
if (val)
render_priv->state.drawing->scale = val;
render_priv->state.drawing_mode = !!val;
} else if (mystrcmp(&p, "q")) {
int val;
if (!mystrtoi(&p, &val))
val = render_priv->track->WrapStyle;
render_priv->state.wrap_style = val;
}
return p;
}
/**
* \brief Get next ucs4 char from string, parsing and executing style overrides
* \param str string pointer
* \return ucs4 code of the next char
* On return str points to the unparsed part of the string
*/
unsigned get_next_char(ASS_Renderer *render_priv, char **str)
{
char *p = *str;
unsigned chr;
if (*p == '{') { // '\0' goes here
p++;
while (1) {
p = parse_tag(render_priv, p, 1.);
if (*p == '}') { // end of tag
p++;
if (*p == '{') {
p++;
continue;
} else
break;
} else if (*p != '\\')
ass_msg(render_priv->library, MSGL_V,
"Unable to parse: '%s'", p);
if (*p == 0)
break;
}
}
if (*p == '\t') {
++p;
*str = p;
return ' ';
}
if (*p == '\\') {
if ((p[1] == 'N') || ((p[1] == 'n') &&
(render_priv->state.wrap_style == 2))) {
p += 2;
*str = p;
return '\n';
} else if (p[1] == 'n') {
p += 2;
*str = p;
return ' ';
} else if (p[1] == 'h') {
p += 2;
*str = p;
return NBSP;
}
}
chr = ass_utf8_get_char((char **) &p);
*str = p;
return chr;
}

37
aegisub/libass/ass_parse.h Normal file
View file

@ -0,0 +1,37 @@
/*
* Copyright (C) 2009 Grigori Goronzy <greg@geekmind.org>
*
* This file is part of libass.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef LIBASS_PARSE_H
#define LIBASS_PARSE_H
#define BLUR_MAX_RADIUS 100.0
#define _r(c) ((c) >> 24)
#define _g(c) (((c) >> 16) & 0xFF)
#define _b(c) (((c) >> 8) & 0xFF)
#define _a(c) ((c) & 0xFF)
void update_font(ASS_Renderer *render_priv);
void change_border(ASS_Renderer *render_priv, double border_x,
double border_y);
unsigned get_next_char(ASS_Renderer *render_priv, char **str);
inline void change_alpha(uint32_t *var, uint32_t new, double pwr);
inline uint32_t mult_alpha(uint32_t a, uint32_t b);
#endif /* LIBASS_PARSE_H */

1719
aegisub/libass/ass_render.c
View file

File diff suppressed because it is too large Load diff

262
aegisub/libass/ass_render.h Normal file
View file

@ -0,0 +1,262 @@
/*
* Copyright (C) 2006 Evgeniy Stepanov <eugeni.stepanov@gmail.com>
* Copyright (C) 2009 Grigori Goronzy <greg@geekmind.org>
*
* This file is part of libass.
*
* libass is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* libass is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with libass; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef LIBASS_RENDER_H
#define LIBASS_RENDER_H
#include <inttypes.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_STROKER_H
#include FT_GLYPH_H
#include FT_SYNTHESIS_H
#include "ass.h"
#include "ass_font.h"
#include "ass_bitmap.h"
#include "ass_cache.h"
#include "ass_utils.h"
#include "ass_fontconfig.h"
#include "ass_library.h"
#include "ass_drawing.h"
typedef struct {
double xMin;
double xMax;
double yMin;
double yMax;
} DBBox;
typedef struct {
double x;
double y;
} DVector;
typedef struct free_list {
void *object;
struct free_list *next;
} FreeList;
typedef struct {
int frame_width;
int frame_height;
double font_size_coeff; // font size multiplier
double line_spacing; // additional line spacing (in frame pixels)
int top_margin; // height of top margin. Everything except toptitles is shifted down by top_margin.
int bottom_margin; // height of bottom margin. (frame_height - top_margin - bottom_margin) is original video height.
int left_margin;
int right_margin;
int use_margins; // 0 - place all subtitles inside original frame
// 1 - use margins for placing toptitles and subtitles
double aspect; // frame aspect ratio, d_width / d_height.
double storage_aspect; // pixel ratio of the source image
ASS_Hinting hinting;
char *default_font;
char *default_family;
} ASS_Settings;
// a rendered event
typedef struct {
ASS_Image *imgs;
int top, height, left, width;
int detect_collisions;
int shift_direction;
ASS_Event *event;
} EventImages;
typedef enum {
EF_NONE = 0,
EF_KARAOKE,
EF_KARAOKE_KF,
EF_KARAOKE_KO
} Effect;
// describes a glyph
// GlyphInfo and TextInfo are used for text centering and word-wrapping operations
typedef struct {
unsigned symbol;
unsigned skip; // skip glyph when layouting text
FT_Glyph glyph;
FT_Glyph outline_glyph;
Bitmap *bm; // glyph bitmap
Bitmap *bm_o; // outline bitmap
Bitmap *bm_s; // shadow bitmap
FT_BBox bbox;
FT_Vector pos;
char linebreak; // the first (leading) glyph of some line ?
uint32_t c[4]; // colors
FT_Vector advance; // 26.6
Effect effect_type;
int effect_timing; // time duration of current karaoke word
// after process_karaoke_effects: distance in pixels from the glyph origin.
// part of the glyph to the left of it is displayed in a different color.
int effect_skip_timing; // delay after the end of last karaoke word
int asc, desc; // font max ascender and descender
int be; // blur edges
double blur; // gaussian blur
double shadow_x;
double shadow_y;
double frx, fry, frz; // rotation
double fax, fay; // text shearing
BitmapHashKey hash_key;
} GlyphInfo;
typedef struct {
double asc, desc;
} LineInfo;
typedef struct {
GlyphInfo *glyphs;
int length;
LineInfo *lines;
int n_lines;
double height;
int max_glyphs;
int max_lines;
} TextInfo;
// Renderer state.
// Values like current font face, color, screen position, clipping and so on are stored here.
typedef struct {
ASS_Event *event;
ASS_Style *style;
ASS_Font *font;
char *font_path;
double font_size;
int flags; // decoration flags (underline/strike-through)
FT_Stroker stroker;
int alignment; // alignment overrides go here; if zero, style value will be used
double frx, fry, frz;
double fax, fay; // text shearing
enum {
EVENT_NORMAL, // "normal" top-, sub- or mid- title
EVENT_POSITIONED, // happens after pos(,), margins are ignored
EVENT_HSCROLL, // "Banner" transition effect, text_width is unlimited
EVENT_VSCROLL // "Scroll up", "Scroll down" transition effects
} evt_type;
double pos_x, pos_y; // position
double org_x, org_y; // origin
char have_origin; // origin is explicitly defined; if 0, get_base_point() is used
double scale_x, scale_y;
double hspacing; // distance between letters, in pixels
double border_x; // outline width
double border_y;
uint32_t c[4]; // colors(Primary, Secondary, so on) in RGBA
int clip_x0, clip_y0, clip_x1, clip_y1;
char clip_mode; // 1 = iclip
char detect_collisions;
uint32_t fade; // alpha from \fad
char be; // blur edges
double blur; // gaussian blur
double shadow_x;
double shadow_y;
int drawing_mode; // not implemented; when != 0 text is discarded, except for style override tags
ASS_Drawing *drawing; // current drawing
ASS_Drawing *clip_drawing; // clip vector
int clip_drawing_mode; // 0 = regular clip, 1 = inverse clip
Effect effect_type;
int effect_timing;
int effect_skip_timing;
enum {
SCROLL_LR, // left-to-right
SCROLL_RL,
SCROLL_TB, // top-to-bottom
SCROLL_BT
} scroll_direction; // for EVENT_HSCROLL, EVENT_VSCROLL
int scroll_shift;
// face properties
char *family;
unsigned bold;
unsigned italic;
int treat_family_as_pattern;
int wrap_style;
} RenderContext;
typedef struct {
Hashmap *font_cache;
Hashmap *glyph_cache;
Hashmap *bitmap_cache;
Hashmap *composite_cache;
size_t glyph_max;
size_t bitmap_max_size;
} CacheStore;
struct ass_renderer {
ASS_Library *library;
FT_Library ftlibrary;
FCInstance *fontconfig_priv;
ASS_Settings settings;
int render_id;
ASS_SynthPriv *synth_priv;
ASS_Image *images_root; // rendering result is stored here
ASS_Image *prev_images_root;
EventImages *eimg; // temporary buffer for sorting rendered events
int eimg_size; // allocated buffer size
// frame-global data
int width, height; // screen dimensions
int orig_height; // frame height ( = screen height - margins )
int orig_width; // frame width ( = screen width - margins )
int orig_height_nocrop; // frame height ( = screen height - margins + cropheight)
int orig_width_nocrop; // frame width ( = screen width - margins + cropwidth)
ASS_Track *track;
long long time; // frame's timestamp, ms
double font_scale;
double font_scale_x; // x scale applied to all glyphs to preserve text aspect ratio
double border_scale;
RenderContext state;
TextInfo text_info;
CacheStore cache;
FreeList *free_head;
FreeList *free_tail;
};
typedef struct render_priv {
int top, height, left, width;
int render_id;
} RenderPriv;
typedef struct {
int x0;
int y0;
int x1;
int y1;
} Rect;
typedef struct {
int a, b; // top and height
int ha, hb; // left and width
} Segment;
void reset_render_context(ASS_Renderer *render_priv);
#endif /* LIBASS_RENDER_H */

38
aegisub/libass/ass_types.h
View file

@ -30,8 +30,14 @@
#define HALIGN_CENTER 2
#define HALIGN_RIGHT 3
/* Opaque objects internally used by libass. Contents are private. */
typedef struct ass_renderer ASS_Renderer;
typedef struct render_priv ASS_RenderPriv;
typedef struct parser_priv ASS_ParserPriv;
typedef struct ass_library ASS_Library;
/* ASS Style: line */
typedef struct ass_style_s {
typedef struct ass_style {
char *Name;
char *FontName;
double FontSize;
@ -56,15 +62,13 @@ typedef struct ass_style_s {
int MarginV;
int Encoding;
int treat_fontname_as_pattern;
} ass_style_t;
typedef struct render_priv_s render_priv_t;
} ASS_Style;
/*
* ass_event_t corresponds to a single Dialogue line;
* ASS_Event corresponds to a single Dialogue line;
* text is stored as-is, style overrides will be parsed later.
*/
typedef struct ass_event_s {
typedef struct ass_event {
long long Start; // ms
long long Duration; // ms
@ -78,24 +82,21 @@ typedef struct ass_event_s {
char *Effect;
char *Text;
render_priv_t *render_priv;
} ass_event_t;
typedef struct parser_priv_s parser_priv_t;
typedef struct ass_library_s ass_library_t;
ASS_RenderPriv *render_priv;
} ASS_Event;
/*
* ass track represent either an external script or a matroska subtitle stream
* (no real difference between them); it can be used in rendering after the
* headers are parsed (i.e. events format line read).
*/
typedef struct ass_track_s {
typedef struct ass_track {
int n_styles; // amount used
int max_styles; // amount allocated
int n_events;
int max_events;
ass_style_t *styles; // array of styles, max_styles length, n_styles used
ass_event_t *events; // the same as styles
ASS_Style *styles; // array of styles, max_styles length, n_styles used
ASS_Event *events; // the same as styles
char *style_format; // style format line (everything after "Format: ")
char *event_format; // event format line
@ -111,14 +112,13 @@ typedef struct ass_track_s {
int PlayResY;
double Timer;
int WrapStyle;
char ScaledBorderAndShadow;
int ScaledBorderAndShadow;
int default_style; // index of default style
char *name; // file name in case of external subs, 0 for streams
ass_library_t *library;
parser_priv_t *parser_priv;
} ass_track_t;
ASS_Library *library;
ASS_ParserPriv *parser_priv;
} ASS_Track;
#endif /* LIBASS_TYPES_H */

11
aegisub/libass/ass_utils.c
View file

@ -74,11 +74,12 @@ int mystrtod(char **p, double *res)
return 0;
}
int strtocolor(ass_library_t *library, char **q, uint32_t *res)
int strtocolor(ASS_Library *library, char **q, uint32_t *res, int hex)
{
uint32_t color = 0;
int result;
char *p = *q;
int base = hex ? 16 : 10;
if (*p == '&')
++p;
@ -89,7 +90,7 @@ int strtocolor(ass_library_t *library, char **q, uint32_t *res)
++p;
result = mystrtou32(&p, 16, &color);
} else {
result = mystrtou32(&p, 0, &color);
result = mystrtou32(&p, base, &color);
}
{
@ -122,11 +123,11 @@ char parse_bool(char *str)
return 0;
}
void ass_msg(ass_library_t *priv, int lvl, char *fmt, ...)
void ass_msg(ASS_Library *priv, int lvl, char *fmt, ...)
{
va_list va;
va_start(va, fmt);
priv->msg_callback(lvl, fmt, &va, priv->msg_callback_data);
priv->msg_callback(lvl, fmt, va, priv->msg_callback_data);
va_end(va);
}
@ -161,7 +162,7 @@ unsigned ass_utf8_get_char(char **str)
}
#ifdef CONFIG_ENCA
void *ass_guess_buffer_cp(ass_library_t *library, unsigned char *buffer,
void *ass_guess_buffer_cp(ASS_Library *library, unsigned char *buffer,
int buflen, char *preferred_language,
char *fallback)
{

7
aegisub/libass/ass_utils.h
View file

@ -43,17 +43,18 @@
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
#define FFMINMAX(c,a,b) FFMIN(FFMAX(c, a), b)
int mystrtoi(char **p, int *res);
int mystrtoll(char **p, long long *res);
int mystrtou32(char **p, int base, uint32_t *res);
int mystrtod(char **p, double *res);
int strtocolor(ass_library_t *library, char **q, uint32_t *res);
int strtocolor(ASS_Library *library, char **q, uint32_t *res, int hex);
char parse_bool(char *str);
unsigned ass_utf8_get_char(char **str);
void ass_msg(ass_library_t *priv, int lvl, char *fmt, ...);
void ass_msg(ASS_Library *priv, int lvl, char *fmt, ...);
#ifdef CONFIG_ENCA
void *ass_guess_buffer_cp(ass_library_t *library, unsigned char *buffer,
void *ass_guess_buffer_cp(ASS_Library *library, unsigned char *buffer,
int buflen, char *preferred_language,
char *fallback);
#endif

26
aegisub/src/subtitles_provider_libass.cpp
View file

@ -56,7 +56,7 @@ extern "C" {
#endif
/// @brief Constructor
/// @brief Constructor
///
LibassSubtitlesProvider::LibassSubtitlesProvider() {
// Initialize library
@ -64,12 +64,12 @@ LibassSubtitlesProvider::LibassSubtitlesProvider() {
if (first) {
ass_library = ass_library_init();
if (!ass_library) throw _T("ass_library_init failed");
wxString fonts_dir = StandardPaths::DecodePath(_T("?user/libass_fonts/"));
if (!wxDirExists(fonts_dir))
// It's only one level below the user dir, and we assume the user dir already exists at this point.
wxMkdir(fonts_dir);
ass_set_fonts_dir(ass_library, fonts_dir.mb_str(wxConvFile));
ass_set_extract_fonts(ass_library, 0);
ass_set_style_overrides(ass_library, NULL);
@ -98,15 +98,15 @@ LibassSubtitlesProvider::LibassSubtitlesProvider() {
/// @brief Destructor
/// @brief Destructor
///
LibassSubtitlesProvider::~LibassSubtitlesProvider() {
}
/// @brief Load subtitles
/// @param subs
/// @brief Load subtitles
/// @param subs
///
void LibassSubtitlesProvider::LoadSubtitles(AssFile *subs) {
// Prepare subtitles
@ -135,17 +135,17 @@ void LibassSubtitlesProvider::LoadSubtitles(AssFile *subs) {
#define _a(c) ((c)&0xFF)
/// @brief Draw subtitles
/// @param frame
/// @param time
/// @return
/// @brief Draw subtitles
/// @param frame
/// @param time
/// @return
///
void LibassSubtitlesProvider::DrawSubtitles(AegiVideoFrame &frame,double time) {
// Set size
ass_set_frame_size(ass_renderer, frame.w, frame.h);
// Get frame
ass_image_t* img = ass_render_frame(ass_renderer, ass_track, int(time * 1000), NULL);
ASS_Image* img = ass_render_frame(ass_renderer, ass_track, int(time * 1000), NULL);
// libass actually returns several alpha-masked monochrome images.
// Here, we loop through their linked list, get the colour of the current, and blend into the frame.
@ -193,9 +193,7 @@ void LibassSubtitlesProvider::DrawSubtitles(AegiVideoFrame &frame,double time) {
/// DOCME
ass_library_t* LibassSubtitlesProvider::ass_library;
ASS_Library* LibassSubtitlesProvider::ass_library;
#endif // WITH_LIBASS

8
aegisub/src/subtitles_provider_libass.h
View file

@ -58,13 +58,13 @@ class LibassSubtitlesProvider : public SubtitlesProvider {
private:
/// DOCME
static ass_library_t* ass_library;
static ASS_Library* ass_library;
/// DOCME
ass_renderer_t* ass_renderer;
ASS_Renderer* ass_renderer;
/// DOCME
ass_track_t* ass_track;
ASS_Track* ass_track;
public:
LibassSubtitlesProvider();
@ -91,5 +91,3 @@ public:
};
#endif