#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 {
- parser_state_t state;
+ ParserState state;
char *fontname;
char *fontdata;
int fontdata_size;
#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;
/// \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;
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;
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)
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)
* 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 == '*')
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);
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;
* \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
* \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;
* \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;
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
style = track->styles + sid;
target = style;
-// fill style with some default values
+
+ // fill style with some default values
style->ScaleX = 100.;
style->ScaleY = 100.;
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)
}
-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;
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);
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)
"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;
// 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);
return dst;
}
-static int decode_font(ass_track_t *track)
+static int decode_font(ASS_Track *track)
{
unsigned char *p;
unsigned char *q;
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;
* \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;
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) {
* \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);
* \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);
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
* \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");
* \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;
* \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;
/*
* \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);
* \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)
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;
* \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);
/**
* \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);
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;
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;
}
int dst_x, dst_y; // Bitmap placement inside the video frame
struct ass_image *next; // Next image, or NULL
-} ass_image_t;
+} ASS_Image;
/*
* Hintint type. (see ass_set_hinting below)
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 *priv);
+void ass_library_done(ASS_Library *priv);
/**
* \brief Set private font directory.
* \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.
* \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.
* \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)
+void ass_set_message_cb(ASS_Library *priv, void (*msg_cb)
(int level, const char *fmt, va_list args, void *data),
void *data);
* \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.
* \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
* \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 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 dar, double sar);
+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.
* \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);
* \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
* \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);
/*
* \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.
* \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.
* \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.
* \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.
* \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,
* \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);
/**
* \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.
* \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.
* \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
* +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 */
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;
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;
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);
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;
return bm;
}
-void ass_free_bitmap(bitmap_t *bm)
+void ass_free_bitmap(Bitmap *bm)
{
if (bm) {
if (bm->buffer)
}
}
-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;
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;
* 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;
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);
}
}
-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,
+ Bitmap **bm_g, Bitmap **bm_o, Bitmap **bm_s,
int be, double blur_radius, FT_Vector shadow_offset)
{
blur_radius *= 2;
#include "ass.h"
-typedef struct ass_synth_priv 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 {
int left, top;
int w, h; // width, height
unsigned char *buffer; // w x h buffer
-} bitmap_t;
+} Bitmap;
/**
* \brief perform glyph rendering
* \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,
+ Bitmap **bm_g, Bitmap **bm_o, Bitmap **bm_s,
int be, double blur_radius, FT_Vector shadow_offset);
-void ass_free_bitmap(bitmap_t *bm);
+void ass_free_bitmap(Bitmap *bm);
#endif /* LIBASS_BITMAP_H */
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;
return map;
}
-void hashmap_done(hashmap_t *map)
+void hashmap_done(Hashmap *map)
{
int i;
// print stats
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);
}
// 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);
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++;
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);
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)
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);
}
* \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);
}
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)
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)
* \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);
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)
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);
}
* \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);
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);
}
* \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);
#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 {
void *key;
void *value;
struct hashmap_item *next;
-} hashmap_item_t;
-typedef hashmap_item_t *hashmap_item_p;
+} HashmapItem;
+typedef HashmapItem *hashmap_item_p;
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;
-
-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_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 *);
+ ASS_Library *library;
+} Hashmap;
+
+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 *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_t *bm; // the actual bitmaps
- bitmap_t *bm_o;
- bitmap_t *bm_s;
-} bitmap_hash_val_t;
+ 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 {
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 {
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;
-
-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);
+} GlyphHashValue;
+
+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 */
#define FTVECTOR(member) \
FT_Vector member;
#define BITMAPHASHKEY(member) \
- bitmap_hash_key_t member;
+ BitmapHashKey member;
#define END(typedefnamename) \
} typedefnamename;
// describes a bitmap; bitmaps with equivalents structs are considered identical
START(bitmap, bipmap_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
FTVECTOR(advance) // subpixel shift vector
FTVECTOR(shadow_offset) // shadow subpixel shift
GENERIC(unsigned, drawing_hash) // hashcode of a drawing
-END(bitmap_hash_key_t)
+END(BitmapHashKey)
// describes an outline glyph
START(glyph, glyph_hash_key)
- GENERIC(ass_font_t *, font)
+ GENERIC(ASS_Font *, font)
GENERIC(double, size) // font size
GENERIC(uint32_t, ch) // character code
GENERIC(int, bold)
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)
+END(GlyphHashKey)
// Cache for composited bitmaps
START(composite, composite_hash_key)
GENERIC(int, by)
BITMAPHASHKEY(a)
BITMAPHASHKEY(b)
-END(composite_hash_key_t)
+END(CompositeHashKey)
#undef START
/*
* \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;
/*
* \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;
/*
* \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;
/*
* \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 *
* \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;
/*
* \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++) {
}
/*
- * \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) {
// 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;
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;
#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;
/*
* \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);
}
* \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;
* 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;
/*
* \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);
/*
* \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);
/*
* \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;
* \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);
}
/*
* \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);
TOKEN_B_SPLINE,
TOKEN_EXTEND_SPLINE,
TOKEN_CLOSE
-} ass_token_type_t;
+} ASS_TokenType;
typedef struct ass_drawing_token {
- ass_token_type_t type;
+ ASS_TokenType type;
FT_Vector point;
struct ass_drawing_token *next;
struct ass_drawing_token *prev;
-} ass_drawing_token_t;
+} ASS_DrawingToken;
typedef struct {
char *text; // drawing string
// 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 */
* 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) {
}
}
-static void update_transform(ass_font_t *font)
+static void update_transform(ASS_Font *font)
{
int i;
FT_Matrix m;
/**
* \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)
}
/**
- * \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;
}
/**
- * \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;
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;
/**
* \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) {
* \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;
* 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);
* \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;
/**
* \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;
}
/**
- * \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)
unsigned bold;
unsigned italic;
int treat_family_as_pattern;
-} ass_font_desc_t;
+} ASS_FontDesc;
typedef struct {
- ass_font_desc_t desc;
- ass_library_t *library;
+ 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,
+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_t *font, double size);
-void ass_font_get_asc_desc(ass_font_t *font, uint32_t ch, int *asc,
+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 */
* \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)
* \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)
* 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;
* \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;
return priv;
}
-int fontconfig_update(fc_instance_t *priv)
+int fontconfig_update(FCInstance *priv)
{
return FcConfigBuildFonts(priv->config);
}
#else /* CONFIG_FONTCONFIG */
-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)
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)
{
if (priv && priv->config)
FcConfigDestroy(priv->config);
#include <fontconfig/fontconfig.h>
#endif
-typedef struct fc_instance 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 */
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);
}
}
-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);
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;
*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)
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) {
* \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 ass_set_message_cb(ASS_Library *priv,
void (*msg_cb)(int, const char *, va_list, void *),
void *data)
{
char *name;
char *data;
int size;
-} ass_fontdata_t;
+} ASS_Fontdata;
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, const char *, va_list, void *);
void *msg_callback_data;
double xMax;
double yMin;
double yMax;
-} double_bbox_t;
+} DBBox;
typedef struct {
double x;
double y;
-} double_vector_t;
+} DVector;
typedef struct free_list {
void *object;
struct free_list *next;
-} free_list_t;
+} FreeList;
typedef struct {
int frame_width;
// 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_t hinting;
+ ASS_Hinting hinting;
char *default_font;
char *default_family;
-} ass_settings_t;
+} ASS_Settings;
// a rendered event
typedef struct {
- ass_image_t *imgs;
+ ASS_Image *imgs;
int top, height;
int detect_collisions;
int shift_direction;
- ass_event_t *event;
-} event_images_t;
+ ASS_Event *event;
+} EventImages;
typedef enum { EF_NONE = 0, EF_KARAOKE, EF_KARAOKE_KF, EF_KARAOKE_KO
-} effect_t;
+} Effect;
// describes a glyph
-// glyph_info_t and text_info_t are used for text centering and word-wrapping operations
+// GlyphInfo and TextInfo are used for text centering and word-wrapping operations
typedef struct {
unsigned symbol;
FT_Glyph glyph;
FT_Glyph outline_glyph;
- bitmap_t *bm; // glyph bitmap
- bitmap_t *bm_o; // outline bitmap
- bitmap_t *bm_s; // shadow bitmap
+ 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_t effect_type;
+ 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 height;
int be; // blur edges
double blur; // gaussian blur
double shadow_x;
double frx, fry, frz; // rotation
double fax, fay; // text shearing
- bitmap_hash_key_t hash_key;
-} glyph_info_t;
+ BitmapHashKey hash_key;
+} GlyphInfo;
typedef struct {
double asc, desc;
-} line_info_t;
+} LineInfo;
typedef struct {
- glyph_info_t *glyphs;
+ GlyphInfo *glyphs;
int length;
- line_info_t *lines;
+ LineInfo *lines;
int n_lines;
double height;
int max_glyphs;
int max_lines;
-} text_info_t;
+} TextInfo;
// Renderer state.
// Values like current font face, color, screen position, clipping and so on are stored here.
typedef struct {
- ass_event_t *event;
- ass_style_t *style;
+ ASS_Event *event;
+ ASS_Style *style;
- ass_font_t *font;
+ ASS_Font *font;
char *font_path;
double font_size;
int flags; // decoration flags (underline/strike-through)
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
+ 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
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_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;
double shadow_x;
double shadow_y;
int drawing_mode; // not implemented; when != 0 text is discarded, except for style override tags
- ass_drawing_t *drawing; // current drawing
- ass_drawing_t *clip_drawing;// clip vector
+ ASS_Drawing *drawing; // current drawing
+ ASS_Drawing *clip_drawing; // clip vector
int clip_drawing_mode; // 0 = regular clip, 1 = inverse clip
- effect_t effect_type;
+ Effect effect_type;
int effect_timing;
int effect_skip_timing;
- enum { SCROLL_LR, // left-to-right
+ enum {
+ SCROLL_LR, // left-to-right
SCROLL_RL,
SCROLL_TB, // top-to-bottom
SCROLL_BT
unsigned italic;
int treat_family_as_pattern;
-} render_context_t;
+} RenderContext;
typedef struct {
- hashmap_t *font_cache;
- hashmap_t *glyph_cache;
- hashmap_t *bitmap_cache;
- hashmap_t *composite_cache;
+ Hashmap *font_cache;
+ Hashmap *glyph_cache;
+ Hashmap *bitmap_cache;
+ Hashmap *composite_cache;
size_t glyph_max;
size_t bitmap_max_size;
-} cache_store_t;
+} CacheStore;
struct ass_renderer {
- ass_library_t *library;
+ ASS_Library *library;
FT_Library ftlibrary;
- fc_instance_t *fontconfig_priv;
- ass_settings_t settings;
+ FCInstance *fontconfig_priv;
+ ASS_Settings settings;
int render_id;
- ass_synth_priv_t *synth_priv;
+ ASS_SynthPriv *synth_priv;
- ass_image_t *images_root; // rendering result is stored here
- ass_image_t *prev_images_root;
+ ASS_Image *images_root; // rendering result is stored here
+ ASS_Image *prev_images_root;
- event_images_t *eimg; // temporary buffer for sorting rendered events
+ EventImages *eimg; // temporary buffer for sorting rendered events
int eimg_size; // allocated buffer size
// frame-global data
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_t *track;
+ 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;
- render_context_t state;
- text_info_t text_info;
- cache_store_t cache;
+ RenderContext state;
+ TextInfo text_info;
+ CacheStore cache;
- free_list_t *free_head;
- free_list_t *free_tail;
+ FreeList *free_head;
+ FreeList *free_tail;
};
struct render_priv {
int render_id;
};
-static void ass_lazy_track_init(ass_renderer_t *render_priv)
+typedef struct {
+ int x0;
+ int y0;
+ int x1;
+ int y1;
+} Rect;
+
+typedef struct {
+ int a, b; // top and height
+} Segment;
+
+/* End of type definitions */
+
+static void ass_lazy_track_init(ASS_Renderer *render_priv)
{
- ass_track_t *track = render_priv->track;
+ ASS_Track *track = render_priv->track;
if (track->PlayResX && track->PlayResY)
return;
}
}
-ass_renderer_t *ass_renderer_init(ass_library_t *library)
+ASS_Renderer *ass_renderer_init(ASS_Library *library)
{
int error;
FT_Library ft;
- ass_renderer_t *priv = 0;
+ ASS_Renderer *priv = 0;
int vmajor, vminor, vpatch;
error = FT_Init_FreeType(&ft);
ass_msg(library, MSGL_V, "FreeType headers version: %d.%d.%d",
FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH);
- priv = calloc(1, sizeof(ass_renderer_t));
+ priv = calloc(1, sizeof(ASS_Renderer));
if (!priv) {
FT_Done_FreeType(ft);
goto ass_init_exit;
priv->text_info.max_glyphs = MAX_GLYPHS_INITIAL;
priv->text_info.max_lines = MAX_LINES_INITIAL;
priv->text_info.glyphs =
- calloc(MAX_GLYPHS_INITIAL, sizeof(glyph_info_t));
- priv->text_info.lines = calloc(MAX_LINES_INITIAL, sizeof(line_info_t));
+ calloc(MAX_GLYPHS_INITIAL, sizeof(GlyphInfo));
+ priv->text_info.lines = calloc(MAX_LINES_INITIAL, sizeof(LineInfo));
ass_init_exit:
if (priv)
return priv;
}
-void ass_set_cache_limits(ass_renderer_t *render_priv, int glyph_max,
+void ass_set_cache_limits(ASS_Renderer *render_priv, int glyph_max,
int bitmap_max)
{
render_priv->cache.glyph_max = glyph_max ? glyph_max : GLYPH_CACHE_MAX;
BITMAP_CACHE_MAX_SIZE;
}
-static void free_list_clear(ass_renderer_t *render_priv)
+static void free_list_clear(ASS_Renderer *render_priv)
{
if (render_priv->free_head) {
- free_list_t *item = render_priv->free_head;
+ FreeList *item = render_priv->free_head;
while(item) {
- free_list_t *oi = item;
+ FreeList *oi = item;
free(item->object);
item = item->next;
free(oi);
}
}
-static void ass_free_images(ass_image_t *img);
+static void ass_free_images(ASS_Image *img);
-void ass_renderer_done(ass_renderer_t *render_priv)
+void ass_renderer_done(ASS_Renderer *render_priv)
{
ass_font_cache_done(render_priv->cache.font_cache);
ass_bitmap_cache_done(render_priv->cache.bitmap_cache);
}
/**
- * \brief Create a new ass_image_t
- * Parameters are the same as ass_image_t fields.
+ * \brief Create a new ASS_Image
+ * Parameters are the same as ASS_Image fields.
*/
-static ass_image_t *my_draw_bitmap(unsigned char *bitmap, int bitmap_w,
+static ASS_Image *my_draw_bitmap(unsigned char *bitmap, int bitmap_w,
int bitmap_h, int stride, int dst_x,
int dst_y, uint32_t color)
{
- ass_image_t *img = calloc(1, sizeof(ass_image_t));
+ ASS_Image *img = calloc(1, sizeof(ASS_Image));
img->w = bitmap_w;
img->h = bitmap_h;
return img;
}
-static double x2scr_pos(ass_renderer_t *render_priv, double x);
-static double y2scr_pos(ass_renderer_t *render_priv, double y);
-
-typedef struct {
- int x0;
- int y0;
- int x1;
- int y1;
-} rect_t;
+static double x2scr_pos(ASS_Renderer *render_priv, double x);
+static double y2scr_pos(ASS_Renderer *render_priv, double y);
/*
- * \brief Convert bitmap glyphs into ass_image_t list with inverse clipping
+ * \brief Convert bitmap glyphs into ASS_Image list with inverse clipping
*
* Inverse clipping with the following strategy:
* - find rectangle from (x0, y0) to (cx0, y1)
* In an additional pass, the rectangles need to be split up left/right for
* karaoke effects. This can result in a lot of bitmaps (6 to be exact).
*/
-static ass_image_t **render_glyph_i(ass_renderer_t *render_priv,
- bitmap_t *bm, int dst_x, int dst_y,
+static ASS_Image **render_glyph_i(ASS_Renderer *render_priv,
+ Bitmap *bm, int dst_x, int dst_y,
uint32_t color, uint32_t color2, int brk,
- ass_image_t **tail)
+ ASS_Image **tail)
{
int i, j, x0, y0, x1, y1, cx0, cy0, cx1, cy1, sx, sy, zx, zy;
- rect_t r[4];
- ass_image_t *img;
+ Rect r[4];
+ ASS_Image *img;
dst_x += bm->left;
dst_y += bm->top;
}
/**
- * \brief convert bitmap glyph into ass_image_t struct(s)
+ * \brief convert bitmap glyph into ASS_Image struct(s)
* \param bit freetype bitmap glyph, FT_PIXEL_MODE_GRAY
* \param dst_x bitmap x coordinate in video frame
* \param dst_y bitmap y coordinate in video frame
* \return pointer to the new list tail
* Performs clipping. Uses my_draw_bitmap for actual bitmap convertion.
*/
-static ass_image_t **render_glyph(ass_renderer_t *render_priv,
- bitmap_t *bm, int dst_x, int dst_y,
+static ASS_Image **render_glyph(ASS_Renderer *render_priv,
+ Bitmap *bm, int dst_x, int dst_y,
uint32_t color, uint32_t color2, int brk,
- ass_image_t **tail)
+ ASS_Image **tail)
{
// Inverse clipping in use?
if (render_priv->state.clip_mode)
int b_x0, b_y0, b_x1, b_y1; // visible part of the bitmap
int clip_x0, clip_y0, clip_x1, clip_y1;
int tmp;
- ass_image_t *img;
+ ASS_Image *img;
dst_x += bm->left;
dst_y += bm->top;
}
/**
- * \brief Replace the bitmap buffer in ass_image_t with a copy
- * \param img ass_image_t to operate on
+ * \brief Replace the bitmap buffer in ASS_Image with a copy
+ * \param img ASS_Image to operate on
* \return pointer to old bitmap buffer
*/
-static unsigned char *clone_bitmap_buffer(ass_image_t *img)
+static unsigned char *clone_bitmap_buffer(ASS_Image *img)
{
unsigned char *old_bitmap = img->bitmap;
int size = img->stride * (img->h - 1) + img->w;
* luminance adding up where they overlap (which looks ugly)
*/
static void
-render_overlap(ass_renderer_t *render_priv, ass_image_t **last_tail,
- ass_image_t **tail, bitmap_hash_key_t *last_hash,
- bitmap_hash_key_t *hash)
+render_overlap(ASS_Renderer *render_priv, ASS_Image **last_tail,
+ ASS_Image **tail, BitmapHashKey *last_hash,
+ BitmapHashKey *hash)
{
int left, top, bottom, right;
int old_left, old_top, w, h, cur_left, cur_top;
int x, y, opos, cpos;
char m;
- composite_hash_key_t hk;
- composite_hash_val_t *hv;
- composite_hash_val_t chv;
+ CompositeHashKey hk;
+ CompositeHashValue *hv;
+ CompositeHashValue chv;
int ax = (*last_tail)->dst_x;
int ay = (*last_tail)->dst_y;
int aw = (*last_tail)->w;
cache_add_composite(render_priv->cache.composite_cache, &hk, &chv);
}
-static void free_list_add(ass_renderer_t *render_priv, void *object)
+static void free_list_add(ASS_Renderer *render_priv, void *object)
{
if (!render_priv->free_head) {
- render_priv->free_head = calloc(1, sizeof(free_list_t));
+ render_priv->free_head = calloc(1, sizeof(FreeList));
render_priv->free_head->object = object;
render_priv->free_tail = render_priv->free_head;
} else {
- free_list_t *l = calloc(1, sizeof(free_list_t));
+ FreeList *l = calloc(1, sizeof(FreeList));
l->object = object;
render_priv->free_tail->next = l;
render_priv->free_tail = render_priv->free_tail->next;
* applicable. The blended bitmaps are added to a free list which is freed
* at the start of a new frame.
*/
-static void blend_vector_clip(ass_renderer_t *render_priv,
- ass_image_t *head)
+static void blend_vector_clip(ASS_Renderer *render_priv,
+ ASS_Image *head)
{
FT_Glyph glyph;
FT_BitmapGlyph clip_bm;
- ass_image_t *cur;
- ass_drawing_t *drawing = render_priv->state.clip_drawing;
+ ASS_Image *cur;
+ ASS_Drawing *drawing = render_priv->state.clip_drawing;
int error;
if (!drawing)
}
/**
- * \brief Convert text_info_t struct to ass_image_t list
+ * \brief Convert TextInfo struct to ASS_Image list
* Splits glyphs in halves when needed (for \kf karaoke).
*/
-static ass_image_t *render_text(ass_renderer_t *render_priv, int dst_x,
+static ASS_Image *render_text(ASS_Renderer *render_priv, int dst_x,
int dst_y)
{
int pen_x, pen_y;
int i;
- bitmap_t *bm;
- ass_image_t *head;
- ass_image_t **tail = &head;
- ass_image_t **last_tail = 0;
- ass_image_t **here_tail = 0;
- bitmap_hash_key_t *last_hash = 0;
- text_info_t *text_info = &render_priv->text_info;
+ Bitmap *bm;
+ ASS_Image *head;
+ ASS_Image **tail = &head;
+ ASS_Image **last_tail = 0;
+ ASS_Image **here_tail = 0;
+ BitmapHashKey *last_hash = 0;
+ TextInfo *text_info = &render_priv->text_info;
for (i = 0; i < text_info->length; ++i) {
- glyph_info_t *info = text_info->glyphs + i;
+ GlyphInfo *info = text_info->glyphs + i;
if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm_s
|| (info->shadow_x == 0 && info->shadow_y == 0))
continue;
last_tail = 0;
for (i = 0; i < text_info->length; ++i) {
- glyph_info_t *info = text_info->glyphs + i;
+ GlyphInfo *info = text_info->glyphs + i;
if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm_o)
continue;
}
}
for (i = 0; i < text_info->length; ++i) {
- glyph_info_t *info = text_info->glyphs + i;
+ GlyphInfo *info = text_info->glyphs + i;
if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm)
continue;
/**
* \brief Mapping between script and screen coordinates
*/
-static double x2scr(ass_renderer_t *render_priv, double x)
+static double x2scr(ASS_Renderer *render_priv, double x)
{
return x * render_priv->orig_width_nocrop /
render_priv->track->PlayResX +
FFMAX(render_priv->settings.left_margin, 0);
}
-static double x2scr_pos(ass_renderer_t *render_priv, double x)
+static double x2scr_pos(ASS_Renderer *render_priv, double x)
{
return x * render_priv->orig_width / render_priv->track->PlayResX +
render_priv->settings.left_margin;
/**
* \brief Mapping between script and screen coordinates
*/
-static double y2scr(ass_renderer_t *render_priv, double y)
+static double y2scr(ASS_Renderer *render_priv, double y)
{
return y * render_priv->orig_height_nocrop /
render_priv->track->PlayResY +
FFMAX(render_priv->settings.top_margin, 0);
}
-static double y2scr_pos(ass_renderer_t *render_priv, double y)
+static double y2scr_pos(ASS_Renderer *render_priv, double y)
{
return y * render_priv->orig_height / render_priv->track->PlayResY +
render_priv->settings.top_margin;
}
// the same for toptitles
-static double y2scr_top(ass_renderer_t *render_priv, double y)
+static double y2scr_top(ASS_Renderer *render_priv, double y)
{
if (render_priv->settings.use_margins)
return y * render_priv->orig_height_nocrop /
}
// the same for subtitles
-static double y2scr_sub(ass_renderer_t *render_priv, double y)
+static double y2scr_sub(ASS_Renderer *render_priv, double y)
{
if (render_priv->settings.use_margins)
return y * render_priv->orig_height_nocrop /
FFMAX(render_priv->settings.top_margin, 0);
}
-static void compute_string_bbox(text_info_t *info, double_bbox_t *bbox)
+static void compute_string_bbox(TextInfo *info, DBBox *bbox)
{
int i;
return 0;
}
-static void change_font_size(ass_renderer_t *render_priv, double sz)
+static void change_font_size(ASS_Renderer *render_priv, double sz)
{
double size = sz * render_priv->font_scale;
/**
* \brief Change current font, using setting from render_priv->state.
*/
-static void update_font(ass_renderer_t *render_priv)
+static void update_font(ASS_Renderer *render_priv)
{
unsigned val;
- ass_font_desc_t desc;
+ ASS_FontDesc desc;
desc.family = strdup(render_priv->state.family);
desc.treat_family_as_pattern =
render_priv->state.treat_family_as_pattern;
* \brief Change border width
* negative value resets border to style value
*/
-static void change_border(ass_renderer_t *render_priv, double border_x,
+static void change_border(ASS_Renderer *render_priv, double border_x,
double border_y)
{
int bord;
* 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_t *render_priv, char *p)
+static char *parse_vector_clip(ASS_Renderer *render_priv, char *p)
{
int scale = 1;
int res = 0;
- ass_drawing_t *drawing;
+ ASS_Drawing *drawing;
render_priv->state.clip_drawing = ass_drawing_new(
render_priv->fontconfig_priv,
render_priv->state.font,
return p;
}
-static void reset_render_context(ass_renderer_t *);
+static void reset_render_context(ASS_Renderer *);
/**
* \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_t *render_priv, char *p, double pwr)
+static char *parse_tag(ASS_Renderer *render_priv, char *p, double pwr)
{
skip_to('\\');
skip('\\');
* \return ucs4 code of the next char
* On return str points to the unparsed part of the string
*/
-static unsigned get_next_char(ass_renderer_t *render_priv, char **str)
+static unsigned get_next_char(ASS_Renderer *render_priv, char **str)
{
char *p = *str;
unsigned chr;
}
static void
-apply_transition_effects(ass_renderer_t *render_priv, ass_event_t *event)
+apply_transition_effects(ASS_Renderer *render_priv, ASS_Event *event)
{
int v[4];
int cnt;
* \brief partially reset render_context to style values
* Works like {\r}: resets some style overrides
*/
-static void reset_render_context(ass_renderer_t *render_priv)
+static void reset_render_context(ASS_Renderer *render_priv)
{
render_priv->state.c[0] = render_priv->state.style->PrimaryColour;
render_priv->state.c[1] = render_priv->state.style->SecondaryColour;
* \brief Start new event. Reset render_priv->state.
*/
static void
-init_render_context(ass_renderer_t *render_priv, ass_event_t *event)
+init_render_context(ASS_Renderer *render_priv, ASS_Event *event)
{
render_priv->state.event = event;
render_priv->state.style = render_priv->track->styles + event->Style;
apply_transition_effects(render_priv, event);
}
-static void free_render_context(ass_renderer_t *render_priv)
+static void free_render_context(ASS_Renderer *render_priv)
{
free(render_priv->state.family);
ass_drawing_free(render_priv->state.drawing);
* Stroke an outline glyph in x/y direction. Applies various fixups to get
* around limitations of the FreeType stroker.
*/
-static void stroke_outline_glyph(ass_renderer_t *render_priv,
+static void stroke_outline_glyph(ASS_Renderer *render_priv,
FT_OutlineGlyph *glyph, int sx, int sy)
{
if (sx <= 0 && sy <= 0)
* The glyphs are returned in info->glyph and info->outline_glyph
*/
static void
-get_outline_glyph(ass_renderer_t *render_priv, int symbol,
- glyph_info_t *info, ass_drawing_t *drawing)
+get_outline_glyph(ASS_Renderer *render_priv, int symbol,
+ GlyphInfo *info, ASS_Drawing *drawing)
{
- glyph_hash_val_t *val;
- glyph_hash_key_t key;
+ GlyphHashValue *val;
+ GlyphHashKey key;
memset(&key, 0, sizeof(key));
if (drawing->hash) {
key.outline.y = render_priv->state.border_y * 0xFFFF;
key.flags = render_priv->state.flags;
}
- memset(info, 0, sizeof(glyph_info_t));
+ memset(info, 0, sizeof(GlyphInfo));
val = cache_find_glyph(render_priv->cache.glyph_cache, &key);
if (val) {
drawing->desc = val->desc;
}
} else {
- glyph_hash_val_t v;
+ GlyphHashValue v;
if (drawing->hash) {
ass_drawing_parse(drawing, 0);
FT_Glyph_Copy((FT_Glyph) drawing->glyph, &info->glyph);
* They are returned in info->bm (glyph), info->bm_o (outline) and info->bm_s (shadow).
*/
static void
-get_bitmap_glyph(ass_renderer_t *render_priv, glyph_info_t *info)
+get_bitmap_glyph(ASS_Renderer *render_priv, GlyphInfo *info)
{
- bitmap_hash_val_t *val;
- bitmap_hash_key_t *key = &info->hash_key;
+ BitmapHashValue *val;
+ BitmapHashKey *key = &info->hash_key;
val = cache_find_bitmap(render_priv->cache.bitmap_cache, key);
info->bm_s = val->bm_s;
} else {
FT_Vector shift;
- bitmap_hash_val_t hash_val;
+ BitmapHashValue hash_val;
int error;
info->bm = info->bm_o = info->bm_s = 0;
if (info->glyph && info->symbol != '\n' && info->symbol != 0) {
* lines[].asc
* lines[].desc
*/
-static void measure_text(ass_renderer_t *render_priv)
+static void measure_text(ASS_Renderer *render_priv)
{
- text_info_t *text_info = &render_priv->text_info;
+ TextInfo *text_info = &render_priv->text_info;
int cur_line = 0;
double max_asc = 0., max_desc = 0.;
- glyph_info_t *last = NULL;
+ GlyphInfo *last = NULL;
int i;
int empty_line = 1;
text_info->height = 0.;
} else
empty_line = 0;
if (i < text_info->length) {
- glyph_info_t *cur = text_info->glyphs + i;
+ GlyphInfo *cur = text_info->glyphs + i;
if (d6_to_double(cur->asc) > max_asc)
max_asc = d6_to_double(cur->asc);
if (d6_to_double(cur->desc) > max_desc)
* The result may not be optimal, but usually is good enough.
*/
static void
-wrap_lines_smart(ass_renderer_t *render_priv, double max_text_width)
+wrap_lines_smart(ASS_Renderer *render_priv, double max_text_width)
{
int i;
- glyph_info_t *cur, *s1, *e1, *s2, *s3, *w;
+ GlyphInfo *cur, *s1, *e1, *s2, *s3, *w;
int last_space;
int break_type;
int exit;
double pen_shift_x;
double pen_shift_y;
int cur_line;
- text_info_t *text_info = &render_priv->text_info;
+ TextInfo *text_info = &render_priv->text_info;
last_space = -1;
text_info->n_lines = 1;
// Raise maximum number of lines
text_info->max_lines *= 2;
text_info->lines = realloc(text_info->lines,
- sizeof(line_info_t) *
+ sizeof(LineInfo) *
text_info->max_lines);
}
if (lead < text_info->length)
* 2. sets effect_timing for all glyphs to x coordinate of the border line between the left and right karaoke parts
* (left part is filled with PrimaryColour, right one - with SecondaryColour).
*/
-static void process_karaoke_effects(ass_renderer_t *render_priv)
+static void process_karaoke_effects(ASS_Renderer *render_priv)
{
- glyph_info_t *cur, *cur2;
- glyph_info_t *s1, *e1; // start and end of the current word
- glyph_info_t *s2; // start of the next word
+ GlyphInfo *cur, *cur2;
+ GlyphInfo *s1, *e1; // start and end of the current word
+ GlyphInfo *s2; // start of the next word
int i;
int timing; // current timing
int tm_start, tm_end; // timings at start and end of the current word
* \param alignment alignment
* \param bx, by out: base point coordinates
*/
-static void get_base_point(double_bbox_t *bbox, int alignment, double *bx, double *by)
+static void get_base_point(DBBox *bbox, int alignment, double *bx, double *by)
{
const int halign = alignment & 3;
const int valign = alignment & 12;
* \brief Main ass rendering function, glues everything together
* \param event event to render
* \param event_images struct containing resulting images, will also be initialized
- * Process event, appending resulting ass_image_t's to images_root.
+ * Process event, appending resulting ASS_Image's to images_root.
*/
static int
-ass_render_event(ass_renderer_t *render_priv, ass_event_t *event,
- event_images_t *event_images)
+ass_render_event(ASS_Renderer *render_priv, ASS_Event *event,
+ EventImages *event_images)
{
char *p;
FT_UInt previous;
FT_UInt num_glyphs;
FT_Vector pen;
unsigned code;
- double_bbox_t bbox;
+ DBBox bbox;
int i, j;
int MarginL, MarginR, MarginV;
int last_break;
int alignment, halign, valign;
double device_x = 0;
double device_y = 0;
- text_info_t *text_info = &render_priv->text_info;
- ass_drawing_t *drawing;
+ TextInfo *text_info = &render_priv->text_info;
+ ASS_Drawing *drawing;
if (event->Style >= render_priv->track->n_styles) {
ass_msg(render_priv->library, MSGL_WARN, "No style found");
text_info->max_glyphs *= 2;
text_info->glyphs =
realloc(text_info->glyphs,
- sizeof(glyph_info_t) * text_info->max_glyphs);
+ sizeof(GlyphInfo) * text_info->max_glyphs);
}
// Add kerning to pen
if ((i == text_info->length)
|| text_info->glyphs[i].linebreak) {
double width, shift = 0;
- glyph_info_t *first_glyph =
+ GlyphInfo *first_glyph =
text_info->glyphs + last_break + 1;
- glyph_info_t *last_glyph = text_info->glyphs + i - 1;
+ GlyphInfo *last_glyph = text_info->glyphs + i - 1;
while ((last_glyph > first_glyph)
&& ((last_glyph->symbol == '\n')
}
// calculate rotation parameters
{
- double_vector_t center;
+ DVector center;
if (render_priv->state.have_origin) {
center.x = x2scr(render_priv, render_priv->state.org_x);
}
for (i = 0; i < text_info->length; ++i) {
- glyph_info_t *info = text_info->glyphs + i;
+ GlyphInfo *info = text_info->glyphs + i;
if (info->hash_key.frx || info->hash_key.fry
|| info->hash_key.frz || info->hash_key.fax
// convert glyphs to bitmaps
for (i = 0; i < text_info->length; ++i) {
- glyph_info_t *g = text_info->glyphs + i;
+ GlyphInfo *g = text_info->glyphs + i;
g->hash_key.advance.x =
double_to_d6(device_x - (int) device_x +
d6_to_double(g->pos.x & SUBPIXEL_MASK)) & ~SUBPIXEL_ACCURACY;
* \brief deallocate image list
* \param img list pointer
*/
-static void ass_free_images(ass_image_t *img)
+static void ass_free_images(ASS_Image *img)
{
while (img) {
- ass_image_t *next = img->next;
+ ASS_Image *next = img->next;
free(img);
img = next;
}
}
-static void ass_reconfigure(ass_renderer_t *priv)
+static void ass_reconfigure(ASS_Renderer *priv)
{
priv->render_id++;
priv->cache.glyph_cache =
priv->prev_images_root = 0;
}
-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)
{
if (priv->settings.frame_width != w || priv->settings.frame_height != h) {
priv->settings.frame_width = w;
}
}
-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)
{
if (priv->settings.left_margin != l ||
priv->settings.right_margin != r ||
}
}
-void ass_set_use_margins(ass_renderer_t *priv, int use)
+void ass_set_use_margins(ASS_Renderer *priv, int use)
{
priv->settings.use_margins = use;
}
-void ass_set_aspect_ratio(ass_renderer_t *priv, double dar, double sar)
+void ass_set_aspect_ratio(ASS_Renderer *priv, double dar, double sar)
{
if (priv->settings.aspect != dar || priv->settings.storage_aspect != sar) {
priv->settings.aspect = dar;
}
}
-void ass_set_font_scale(ass_renderer_t *priv, double font_scale)
+void ass_set_font_scale(ASS_Renderer *priv, double font_scale)
{
if (priv->settings.font_size_coeff != font_scale) {
priv->settings.font_size_coeff = font_scale;
}
}
-void ass_set_hinting(ass_renderer_t *priv, ass_hinting_t ht)
+void ass_set_hinting(ASS_Renderer *priv, ASS_Hinting ht)
{
if (priv->settings.hinting != ht) {
priv->settings.hinting = ht;
}
}
-void ass_set_line_spacing(ass_renderer_t *priv, double line_spacing)
+void ass_set_line_spacing(ASS_Renderer *priv, double line_spacing)
{
priv->settings.line_spacing = line_spacing;
}
-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)
{
default_font, fc, config, update);
}
-int ass_fonts_update(ass_renderer_t *render_priv)
+int ass_fonts_update(ASS_Renderer *render_priv)
{
return fontconfig_update(render_priv->fontconfig_priv);
}
* \brief Start a new frame
*/
static int
-ass_start_frame(ass_renderer_t *render_priv, ass_track_t *track,
+ass_start_frame(ASS_Renderer *render_priv, ASS_Track *track,
long long now)
{
- ass_settings_t *settings_priv = &render_priv->settings;
- cache_store_t *cache = &render_priv->cache;
+ ASS_Settings *settings_priv = &render_priv->settings;
+ CacheStore *cache = &render_priv->cache;
if (!render_priv->settings.frame_width
&& !render_priv->settings.frame_height)
static int cmp_event_layer(const void *p1, const void *p2)
{
- ass_event_t *e1 = ((event_images_t *) p1)->event;
- ass_event_t *e2 = ((event_images_t *) p2)->event;
+ ASS_Event *e1 = ((EventImages *) p1)->event;
+ ASS_Event *e2 = ((EventImages *) p2)->event;
if (e1->Layer < e2->Layer)
return -1;
if (e1->Layer > e2->Layer)
return 0;
}
-static render_priv_t *get_render_priv(ass_renderer_t *render_priv,
- ass_event_t *event)
+static ASS_RenderPriv *get_render_priv(ASS_Renderer *render_priv,
+ ASS_Event *event)
{
if (!event->render_priv)
- event->render_priv = calloc(1, sizeof(render_priv_t));
+ event->render_priv = calloc(1, sizeof(ASS_RenderPriv));
// FIXME: check render_id
if (render_priv->render_id != event->render_priv->render_id) {
- memset(event->render_priv, 0, sizeof(render_priv_t));
+ memset(event->render_priv, 0, sizeof(ASS_RenderPriv));
event->render_priv->render_id = render_priv->render_id;
}
return event->render_priv;
}
-typedef struct {
- int a, b; // top and height
-} segment_t;
-
-static int overlap(segment_t *s1, segment_t *s2)
+static int overlap(Segment *s1, Segment *s2)
{
if (s1->a >= s2->b || s2->a >= s1->b)
return 0;
static int cmp_segment(const void *p1, const void *p2)
{
- return ((segment_t *) p1)->a - ((segment_t *) p2)->a;
+ return ((Segment *) p1)->a - ((Segment *) p2)->a;
}
static void
-shift_event(ass_renderer_t *render_priv, event_images_t *ei, int shift)
+shift_event(ASS_Renderer *render_priv, EventImages *ei, int shift)
{
- ass_image_t *cur = ei->imgs;
+ ASS_Image *cur = ei->imgs;
while (cur) {
cur->dst_y += shift;
// clip top and bottom
// dir: 1 - move down
// -1 - move up
-static int fit_segment(segment_t *s, segment_t *fixed, int *cnt, int dir)
+static int fit_segment(Segment *s, Segment *fixed, int *cnt, int dir)
{
int i;
int shift = 0;
fixed[*cnt].a = s->a + shift;
fixed[*cnt].b = s->b + shift;
(*cnt)++;
- qsort(fixed, *cnt, sizeof(segment_t), cmp_segment);
+ qsort(fixed, *cnt, sizeof(Segment), cmp_segment);
return shift;
}
static void
-fix_collisions(ass_renderer_t *render_priv, event_images_t *imgs, int cnt)
+fix_collisions(ASS_Renderer *render_priv, EventImages *imgs, int cnt)
{
- segment_t *used = malloc(cnt * sizeof(*used));
+ Segment *used = malloc(cnt * sizeof(*used));
int cnt_used = 0;
int i, j;
// fill used[] with fixed events
for (i = 0; i < cnt; ++i) {
- render_priv_t *priv;
+ ASS_RenderPriv *priv;
if (!imgs[i].detect_collisions)
continue;
priv = get_render_priv(render_priv, imgs[i].event);
if (priv->height > 0) { // it's a fixed event
- segment_t s;
+ Segment s;
s.a = priv->top;
s.b = priv->top + priv->height;
if (priv->height != imgs[i].height) { // no, it's not
}
}
}
- qsort(used, cnt_used, sizeof(segment_t), cmp_segment);
+ qsort(used, cnt_used, sizeof(Segment), cmp_segment);
// try to fit other events in free spaces
for (i = 0; i < cnt; ++i) {
- render_priv_t *priv;
+ ASS_RenderPriv *priv;
if (!imgs[i].detect_collisions)
continue;
priv = get_render_priv(render_priv, imgs[i].event);
if (priv->height == 0) { // not a fixed event
int shift;
- segment_t s;
+ Segment s;
s.a = imgs[i].top;
s.b = imgs[i].top + imgs[i].height;
shift =
* \param i2 second image
* \return 0 if identical, 1 if different positions, 2 if different content
*/
-static int ass_image_compare(ass_image_t *i1, ass_image_t *i2)
+static int ass_image_compare(ASS_Image *i1, ASS_Image *i2)
{
if (i1->w != i2->w)
return 2;
* \param priv library handle
* \return 0 if identical, 1 if different positions, 2 if different content
*/
-static int ass_detect_change(ass_renderer_t *priv)
+static int ass_detect_change(ASS_Renderer *priv)
{
- ass_image_t *img, *img2;
+ ASS_Image *img, *img2;
int diff;
img = priv->prev_images_root;
img2 = priv->images_root;
diff = 0;
while (img && diff < 2) {
- ass_image_t *next, *next2;
+ ASS_Image *next, *next2;
next = img->next;
if (img2) {
int d = ass_image_compare(img, img2);
* 0 if identical, 1 if different positions, 2 if different content.
* Can be NULL, in that case no detection is performed.
*/
-ass_image_t *ass_render_frame(ass_renderer_t *priv, ass_track_t *track,
+ASS_Image *ass_render_frame(ASS_Renderer *priv, ASS_Track *track,
long long now, int *detect_change)
{
int i, cnt, rc;
- event_images_t *last;
- ass_image_t **tail;
+ EventImages *last;
+ ASS_Image **tail;
// init frame
rc = ass_start_frame(priv, track, now);
// render events separately
cnt = 0;
for (i = 0; i < track->n_events; ++i) {
- ass_event_t *event = track->events + i;
+ ASS_Event *event = track->events + i;
if ((event->Start <= now)
&& (now < (event->Start + event->Duration))) {
if (cnt >= priv->eimg_size) {
priv->eimg_size += 100;
priv->eimg =
realloc(priv->eimg,
- priv->eimg_size * sizeof(event_images_t));
+ priv->eimg_size * sizeof(EventImages));
}
rc = ass_render_event(priv, event, priv->eimg + cnt);
if (!rc)
}
// sort by layer
- qsort(priv->eimg, cnt, sizeof(event_images_t), cmp_event_layer);
+ qsort(priv->eimg, cnt, sizeof(EventImages), cmp_event_layer);
// call fix_collisions for each group of events with the same layer
last = priv->eimg;
// concat lists
tail = &priv->images_root;
for (i = 0; i < cnt; ++i) {
- ass_image_t *cur = priv->eimg[i].imgs;
+ ASS_Image *cur = priv->eimg[i].imgs;
while (cur) {
*tail = cur;
tail = &cur->next;
#define HALIGN_RIGHT 3
/* Opaque objects internally used by libass. Contents are private. */
-typedef struct ass_renderer ass_renderer_t;
-typedef struct render_priv render_priv_t;
-typedef struct parser_priv parser_priv_t;
-typedef struct ass_library ass_library_t;
+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 {
int MarginV;
int Encoding;
int treat_fontname_as_pattern;
-} ass_style_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 {
char *Effect;
char *Text;
- render_priv_t *render_priv;
-} ass_event_t;
+ ASS_RenderPriv *render_priv;
+} ASS_Event;
/*
* ass track represent either an external script or a matroska subtitle stream
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
int WrapStyle;
char 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 */
return 0;
}
-int strtocolor(ass_library_t *library, char **q, uint32_t *res)
+int strtocolor(ASS_Library *library, char **q, uint32_t *res)
{
uint32_t color = 0;
int result;
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);
}
#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)
{
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);
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
unsigned char *buffer; // RGB24
} image_t;
-ass_library_t *ass_library;
-ass_renderer_t *ass_renderer;
+ASS_Library *ass_library;
+ASS_Renderer *ass_renderer;
void msg_callback(int level, const char *fmt, va_list va, void *data)
{
printf("\n");
}
-static void write_png(char *fname, image_t * img)
+static void write_png(char *fname, image_t *img)
{
FILE *fp;
png_structp png_ptr;
#define _b(c) (((c)>>8)&0xFF)
#define _a(c) ((c)&0xFF)
-static void blend_single(image_t * frame, ass_image_t * img)
+static void blend_single(image_t * frame, ASS_Image *img)
{
int x, y;
unsigned char opacity = 255 - _a(img->color);
}
}
-static void blend(image_t * frame, ass_image_t * img)
+static void blend(image_t * frame, ASS_Image *img)
{
int cnt = 0;
while (img) {
double tm = strtod(argv[3], 0);
init(frame_w, frame_h);
- ass_track_t *track = ass_read_file(ass_library, subfile, NULL);
+ ASS_Track *track = ass_read_file(ass_library, subfile, NULL);
if (!track) {
printf("track init failed!\n");
return 1;
}
- ass_image_t *img =
+ ASS_Image *img =
ass_render_frame(ass_renderer, track, (int) (tm * 1000), NULL);
image_t *frame = gen_image(frame_w, frame_h);
blend(frame, img);
projects / libass / commitdiff