bool GlyphString::reorderLine(int startOffset, int endOffset)
{
int length = endOffset - startOffset;
fribidi_reorder_line(0, mTypes + startOffset, length, 0, mParType,
mLevels + startOffset, 0, mMap + startOffset);
return true;
}
int
main (int argc, char **argv)
{
GIOChannel *channel;
GIOStatus status;
GError *error;
gchar *line = NULL;
gsize length, terminator_pos;
FriBidiStrIndex *expected_ltor = NULL;
FriBidiStrIndex expected_ltor_len = 0;
FriBidiStrIndex *ltor = NULL;
FriBidiStrIndex ltor_len = 0;
FriBidiCharType *types = NULL;
FriBidiStrIndex types_len = 0;
FriBidiLevel *expected_levels = NULL;
FriBidiLevel expected_levels_len = 0;
FriBidiLevel *levels = NULL;
FriBidiStrIndex levels_len = 0;
int base_dir_flags, base_dir_mode;
int numerrs = 0;
int numtests = 0;
int line_no = 0;
gboolean debug = FALSE;
const char *filename;
int next_arg;
if (argc < 2) {
g_printerr ("usage: %s [--debug] test-file-name\n", argv[0]);
exit (1);
}
next_arg = 1;
if (!strcmp (argv[next_arg], "--debug")) {
debug = TRUE;
next_arg++;
}
filename = argv[next_arg++];
error = NULL;
channel = g_io_channel_new_file (filename, "r", &error);
if (!channel) {
g_printerr ("%s\n", error->message);
exit (1);
}
while (TRUE) {
error = NULL;
g_free (line);
status = g_io_channel_read_line (channel, &line, &length, &terminator_pos, &error);
switch (status) {
case G_IO_STATUS_ERROR:
g_printerr ("%s\n", error->message);
exit (1);
case G_IO_STATUS_EOF:
goto done;
case G_IO_STATUS_AGAIN:
continue;
case G_IO_STATUS_NORMAL:
line[terminator_pos] = '\0';
break;
}
line_no++;
if (line[0] == '#' || line[0] == '\0')
continue;
if (line[0] == '@')
{
if (!strncmp (line, "@Reorder:", 9)) {
g_free (expected_ltor);
expected_ltor = parse_reorder_line (line, &expected_ltor_len);
continue;
}
if (!strncmp (line, "@Levels:", 8)) {
g_free (expected_levels);
expected_levels = parse_levels_line (line, &expected_levels_len);
continue;
}
continue;
}
/* Test line */
g_free (types);
types = parse_test_line (line, &types_len, &base_dir_flags);
g_free (levels);
levels = g_malloc (sizeof (FriBidiLevel) * types_len);
levels_len = types_len;
g_free (ltor);
ltor = g_malloc (sizeof (FriBidiStrIndex) * types_len);
/* Test it */
for (base_dir_mode = 0; base_dir_mode < 3; base_dir_mode++) {
FriBidiParType base_dir;
int i, j;
gboolean matches;
if ((base_dir_flags & (1<<base_dir_mode)) == 0)
continue;
numtests++;
switch (base_dir_mode) {
case 0: base_dir = FRIBIDI_PAR_ON; break;
case 1: base_dir = FRIBIDI_PAR_LTR; break;
case 2: base_dir = FRIBIDI_PAR_RTL; break;
}
fribidi_get_par_embedding_levels (types, types_len,
&base_dir,
levels);
for (i = 0; i < types_len; i++)
ltor[i] = i;
fribidi_reorder_line (0 /*FRIBIDI_FLAG_REORDER_NSM*/,
types, types_len,
0, base_dir,
levels,
NULL,
ltor);
j = 0;
for (i = 0; i < types_len; i++)
if (!FRIBIDI_IS_EXPLICIT_OR_BN (types[ltor[i]]))
ltor[j++] = ltor[i];
ltor_len = j;
/* Compare */
matches = TRUE;
if (levels_len != expected_levels_len)
matches = FALSE;
if (matches)
for (i = 0; i < levels_len; i++)
if (levels[i] != expected_levels[i] &&
expected_levels[i] != (FriBidiLevel) -1) {
matches = FALSE;
break;
}
if (ltor_len != expected_ltor_len)
matches = FALSE;
if (matches)
for (i = 0; i < ltor_len; i++)
if (ltor[i] != expected_ltor[i]) {
matches = FALSE;
break;
}
if (!matches)
{
numerrs++;
g_printerr ("failure on line %d\n", line_no);
g_printerr ("input is: %s\n", line);
g_printerr ("base dir: %s\n", base_dir_mode==0 ? "auto"
: base_dir_mode==1 ? "LTR" : "RTL");
g_printerr ("expected levels:");
for (i = 0; i < expected_levels_len; i++)
if (expected_levels[i] == (FriBidiLevel) -1)
g_printerr (" x");
else
g_printerr (" %d", expected_levels[i]);
g_printerr ("\n");
g_printerr ("returned levels:");
for (i = 0; i < levels_len; i++)
g_printerr (" %d", levels[i]);
g_printerr ("\n");
g_printerr ("expected order:");
for (i = 0; i < expected_ltor_len; i++)
g_printerr (" %d", expected_ltor[i]);
g_printerr ("\n");
g_printerr ("returned order:");
for (i = 0; i < ltor_len; i++)
g_printerr (" %d", ltor[i]);
g_printerr ("\n");
if (debug) {
FriBidiParType base_dir;
fribidi_set_debug (1);
switch (base_dir_mode) {
case 0: base_dir = FRIBIDI_PAR_ON; break;
case 1: base_dir = FRIBIDI_PAR_LTR; break;
case 2: base_dir = FRIBIDI_PAR_RTL; break;
}
fribidi_get_par_embedding_levels (types, types_len,
&base_dir,
levels);
fribidi_set_debug (0);
}
g_printerr ("\n");
}
}
}
done:
g_free (ltor);
g_free (levels);
g_free (expected_ltor);
g_free (types);
g_free (line);
g_io_channel_unref (channel);
if (error)
g_error_free (error);
if (numerrs)
g_printerr ("%d errors out of %d total tests\n", numerrs, numtests);
return numerrs;
}
static int shape_text(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
uint8_t *tmp;
int ret = AVERROR(ENOMEM);
static const FriBidiFlags flags = FRIBIDI_FLAGS_DEFAULT |
FRIBIDI_FLAGS_ARABIC;
FriBidiChar *unicodestr = NULL;
FriBidiStrIndex len;
FriBidiParType direction = FRIBIDI_PAR_LTR;
FriBidiStrIndex line_start = 0;
FriBidiStrIndex line_end = 0;
FriBidiLevel *embedding_levels = NULL;
FriBidiArabicProp *ar_props = NULL;
FriBidiCharType *bidi_types = NULL;
FriBidiStrIndex i,j;
len = strlen(s->text);
if (!(unicodestr = av_malloc_array(len, sizeof(*unicodestr)))) {
goto out;
}
len = fribidi_charset_to_unicode(FRIBIDI_CHAR_SET_UTF8,
s->text, len, unicodestr);
bidi_types = av_malloc_array(len, sizeof(*bidi_types));
if (!bidi_types) {
goto out;
}
fribidi_get_bidi_types(unicodestr, len, bidi_types);
embedding_levels = av_malloc_array(len, sizeof(*embedding_levels));
if (!embedding_levels) {
goto out;
}
if (!fribidi_get_par_embedding_levels(bidi_types, len, &direction,
embedding_levels)) {
goto out;
}
ar_props = av_malloc_array(len, sizeof(*ar_props));
if (!ar_props) {
goto out;
}
fribidi_get_joining_types(unicodestr, len, ar_props);
fribidi_join_arabic(bidi_types, len, embedding_levels, ar_props);
fribidi_shape(flags, embedding_levels, len, ar_props, unicodestr);
for (line_end = 0, line_start = 0; line_end < len; line_end++) {
if (is_newline(unicodestr[line_end]) || line_end == len - 1) {
if (!fribidi_reorder_line(flags, bidi_types,
line_end - line_start + 1, line_start,
direction, embedding_levels, unicodestr,
NULL)) {
goto out;
}
line_start = line_end + 1;
}
}
/* Remove zero-width fill chars put in by libfribidi */
for (i = 0, j = 0; i < len; i++)
if (unicodestr[i] != FRIBIDI_CHAR_FILL)
unicodestr[j++] = unicodestr[i];
len = j;
if (!(tmp = av_realloc(s->text, (len * 4 + 1) * sizeof(*s->text)))) {
/* Use len * 4, as a unicode character can be up to 4 bytes in UTF-8 */
goto out;
}
s->text = tmp;
len = fribidi_unicode_to_charset(FRIBIDI_CHAR_SET_UTF8,
unicodestr, len, s->text);
ret = 0;
out:
av_free(unicodestr);
av_free(embedding_levels);
av_free(ar_props);
av_free(bidi_types);
return ret;
}
static int LayoutLine( filter_t *p_filter,
paragraph_t *p_paragraph,
int i_start_offset, int i_end_offset,
line_desc_t **pp_line )
{
if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0
|| i_start_offset >= i_end_offset
|| i_start_offset < 0 || i_start_offset >= p_paragraph->i_size
|| i_end_offset <= 0 || i_end_offset > p_paragraph->i_size )
{
msg_Err( p_filter,
"LayoutLine() invalid parameters. "
"Paragraph size: %d. Runs count: %d. "
"Start offset: %d. End offset: %d",
p_paragraph->i_size, p_paragraph->i_runs_count,
i_start_offset, i_end_offset );
return VLC_EGENERIC;
}
line_desc_t *p_line = NewLine( i_end_offset - i_start_offset );
if( !p_line )
return VLC_ENOMEM;
filter_sys_t *p_sys = p_filter->p_sys;
int i_last_run = -1;
run_desc_t *p_run = 0;
text_style_t *p_style = 0;
FT_Face p_face = 0;
FT_Vector pen = { .x = 0, .y = 0 };
int i_line_index = 0;
int i_font_width = 0;
int i_ul_offset = 0;
int i_ul_thickness = 0;
#ifdef HAVE_FRIBIDI
fribidi_reorder_line( 0, p_paragraph->p_types + i_start_offset,
i_end_offset - i_start_offset,
0, p_paragraph->paragraph_type,
p_paragraph->p_levels + i_start_offset,
0, p_paragraph->pi_reordered_indices + i_start_offset );
#endif
for( int i = i_start_offset; i < i_end_offset; ++i, ++i_line_index )
{
int i_paragraph_index;
#ifdef HAVE_FRIBIDI
i_paragraph_index = p_paragraph->pi_reordered_indices[ i ];
#else
i_paragraph_index = i;
#endif
line_character_t *p_ch = p_line->p_character + i_line_index;
glyph_bitmaps_t *p_bitmaps =
p_paragraph->p_glyph_bitmaps + i_paragraph_index;
if( !p_bitmaps->p_glyph )
{
--i_line_index;
continue;
}
if( i_last_run != p_paragraph->pi_run_ids[ i_paragraph_index ] )
{
i_last_run = p_paragraph->pi_run_ids[ i_paragraph_index ];
p_run = p_paragraph->p_runs + i_last_run;
p_style = p_run->p_style;
p_face = p_run->p_face;
i_font_width = p_style->i_style_flags & STYLE_HALFWIDTH ?
p_style->i_font_size / 2 : p_style->i_font_size;
}
FT_Vector pen_new = {
.x = pen.x + p_paragraph->p_glyph_bitmaps[ i_paragraph_index ].i_x_offset,
.y = pen.y + p_paragraph->p_glyph_bitmaps[ i_paragraph_index ].i_y_offset
};
FT_Vector pen_shadow = {
.x = pen_new.x + p_sys->f_shadow_vector_x * ( i_font_width << 6 ),
.y = pen_new.y + p_sys->f_shadow_vector_y * ( p_style->i_font_size << 6 )
};
if( p_bitmaps->p_shadow )
{
if( FT_Glyph_To_Bitmap( &p_bitmaps->p_shadow, FT_RENDER_MODE_NORMAL,
&pen_shadow, 0 ) )
p_bitmaps->p_shadow = 0;
else
FT_Glyph_Get_CBox( p_bitmaps->p_shadow, ft_glyph_bbox_pixels,
&p_bitmaps->shadow_bbox );
}
if( p_bitmaps->p_glyph )
{
if( FT_Glyph_To_Bitmap( &p_bitmaps->p_glyph, FT_RENDER_MODE_NORMAL,
&pen_new, 1 ) )
{
FT_Done_Glyph( p_bitmaps->p_glyph );
if( p_bitmaps->p_outline )
FT_Done_Glyph( p_bitmaps->p_outline );
if( p_bitmaps->p_shadow )
FT_Done_Glyph( p_bitmaps->p_shadow );
--i_line_index;
continue;
}
else
FT_Glyph_Get_CBox( p_bitmaps->p_glyph, ft_glyph_bbox_pixels,
&p_bitmaps->glyph_bbox );
}
if( p_bitmaps->p_outline )
{
if( FT_Glyph_To_Bitmap( &p_bitmaps->p_outline, FT_RENDER_MODE_NORMAL,
&pen_new, 1 ) )
{
FT_Done_Glyph( p_bitmaps->p_outline );
p_bitmaps->p_outline = 0;
}
else
FT_Glyph_Get_CBox( p_bitmaps->p_outline, ft_glyph_bbox_pixels,
&p_bitmaps->outline_bbox );
}
FixGlyph( p_bitmaps->p_glyph, &p_bitmaps->glyph_bbox,
p_bitmaps->i_x_advance, p_bitmaps->i_y_advance,
&pen_new );
if( p_bitmaps->p_outline )
FixGlyph( p_bitmaps->p_outline, &p_bitmaps->outline_bbox,
p_bitmaps->i_x_advance, p_bitmaps->i_y_advance,
&pen_new );
if( p_bitmaps->p_shadow )
FixGlyph( p_bitmaps->p_shadow, &p_bitmaps->shadow_bbox,
p_bitmaps->i_x_advance, p_bitmaps->i_y_advance,
&pen_shadow );
int i_line_offset = 0;
int i_line_thickness = 0;
text_style_t *p_glyph_style = p_paragraph->pp_styles[ i_paragraph_index ];
if( p_glyph_style->i_style_flags & (STYLE_UNDERLINE | STYLE_STRIKEOUT) )
{
i_line_offset =
abs( FT_FLOOR( FT_MulFix( p_face->underline_position,
p_face->size->metrics.y_scale ) ) );
i_line_thickness =
abs( FT_CEIL( FT_MulFix( p_face->underline_thickness,
p_face->size->metrics.y_scale ) ) );
if( p_glyph_style->i_style_flags & STYLE_STRIKEOUT )
{
/* Move the baseline to make it strikethrough instead of
* underline. That means that strikethrough takes precedence
*/
i_line_offset -=
abs( FT_FLOOR( FT_MulFix( p_face->descender * 2,
p_face->size->metrics.y_scale ) ) );
}
else if( i_line_thickness > 0 )
{
p_bitmaps->glyph_bbox.yMin =
__MIN( p_bitmaps->glyph_bbox.yMin,
- i_line_offset - i_line_thickness );
/* The real underline thickness and position are
* updated once the whole line has been parsed */
i_ul_offset = __MAX( i_ul_offset, i_line_offset );
i_ul_thickness = __MAX( i_ul_thickness, i_line_thickness );
i_line_thickness = -1;
}
}
p_ch->p_glyph = ( FT_BitmapGlyph ) p_bitmaps->p_glyph;
p_ch->p_outline = ( FT_BitmapGlyph ) p_bitmaps->p_outline;
p_ch->p_shadow = ( FT_BitmapGlyph ) p_bitmaps->p_shadow;
bool b_karaoke = p_paragraph->pi_karaoke_bar[ i_paragraph_index ] != 0;
p_ch->i_color = b_karaoke ?
( uint32_t ) p_glyph_style->i_karaoke_background_color
| p_glyph_style->i_karaoke_background_alpha << 24
: ( uint32_t ) p_glyph_style->i_font_color
| p_glyph_style->i_font_alpha << 24;
p_ch->i_line_thickness = i_line_thickness;
p_ch->i_line_offset = i_line_offset;
BBoxEnlarge( &p_line->bbox, &p_bitmaps->glyph_bbox );
if( p_bitmaps->p_outline )
BBoxEnlarge( &p_line->bbox, &p_bitmaps->outline_bbox );
if( p_bitmaps->p_shadow )
BBoxEnlarge( &p_line->bbox, &p_bitmaps->shadow_bbox );
pen.x += p_bitmaps->i_x_advance;
pen.y += p_bitmaps->i_y_advance;
}
p_line->i_width = __MAX( 0, p_line->bbox.xMax - p_line->bbox.xMin );
p_line->i_height = __MAX( 0, p_line->bbox.yMax - p_line->bbox.yMin );
p_line->i_character_count = i_line_index;
if( i_ul_thickness > 0 )
{
for( int i = 0; i < p_line->i_character_count; i++ )
{
line_character_t *ch = &p_line->p_character[i];
if( ch->i_line_thickness < 0 )
{
ch->i_line_offset = i_ul_offset;
ch->i_line_thickness = i_ul_thickness;
}
}
}
*pp_line = p_line;
return VLC_SUCCESS;
}
static int LayoutParagraph( filter_t *p_filter, paragraph_t *p_paragraph,
int i_max_pixel_width, line_desc_t **pp_lines )
{
if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0 )
{
msg_Err( p_filter, "LayoutParagraph() invalid parameters. "
"Paragraph size: %d. Runs count %d",
p_paragraph->i_size, p_paragraph->i_runs_count );
return VLC_EGENERIC;
}
int i_line_start = 0;
FT_Pos i_width = 0;
FT_Pos i_max_width = i_max_pixel_width << 6;
FT_Pos i_preferred_width = 0;
FT_Pos i_total_width = 0;
FT_Pos i_last_space_width = 0;
int i_last_space = -1;
line_desc_t *p_first_line = 0;
line_desc_t **pp_line = &p_first_line;
for( int i = 0; i < p_paragraph->i_size; ++i )
{
#ifdef HAVE_FRIBIDI
p_paragraph->pi_reordered_indices[ i ] = i;
#endif
i_total_width += p_paragraph->p_glyph_bitmaps[ i ].i_x_advance;
}
int i_line_count = i_total_width / i_max_width + 1;
i_preferred_width = i_total_width / i_line_count;
for( int i = 0; i <= p_paragraph->i_size; ++i )
{
if( i == p_paragraph->i_size )
{
if( i_line_start < i )
if( LayoutLine( p_filter, p_paragraph,
i_line_start, i, pp_line ) )
goto error;
break;
}
if( p_paragraph->p_code_points[ i ] == ' '
#ifdef HAVE_FRIBIDI
|| p_paragraph->p_types[ i ] == FRIBIDI_TYPE_WS
#endif
)
{
if( i_line_start == i )
{
/*
* Free orphaned white space glyphs not belonging to any lines.
* At this point p_shadow points to either p_glyph or p_outline,
* so we should not free it explicitly.
*/
if( p_paragraph->p_glyph_bitmaps[ i ].p_glyph )
FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_glyph );
if( p_paragraph->p_glyph_bitmaps[ i ].p_outline )
FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_outline );
i_line_start = i + 1;
continue;
}
if( i_last_space == i - 1 )
{
p_paragraph->p_glyph_bitmaps[ i - 1 ].i_x_advance = 0;
i_last_space = i;
continue;
}
i_last_space = i;
i_last_space_width = i_width;
}
i_width += p_paragraph->p_glyph_bitmaps[ i ].i_x_advance;
if( i_last_space_width >= i_preferred_width
|| i_width >= i_max_width )
{
if( i_line_start == i )
{
msg_Err( p_filter,
"LayoutParagraph(): Width of single glyph exceeds maximum" );
goto error;
}
int i_end_offset;
if( i_last_space > i_line_start )
i_end_offset = i_last_space;
else
i_end_offset = i;
if( LayoutLine( p_filter, p_paragraph, i_line_start,
i_end_offset, pp_line ) )
goto error;
pp_line = &( *pp_line )->p_next;
i_line_start = i_end_offset;
i = i_line_start - 1;
i_width = 0;
i_last_space_width = 0;
}
}
*pp_lines = p_first_line;
return VLC_SUCCESS;
error:
for( int i = i_line_start; i < p_paragraph->i_size; ++i )
{
if( p_paragraph->p_glyph_bitmaps[ i ].p_glyph )
FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_glyph );
if( p_paragraph->p_glyph_bitmaps[ i ].p_outline )
FT_Done_Glyph( p_paragraph->p_glyph_bitmaps[ i ].p_outline );
}
if( p_first_line )
FreeLines( p_first_line );
return VLC_EGENERIC;
}
int LayoutText( filter_t *p_filter, line_desc_t **pp_lines,
FT_BBox *p_bbox, int *pi_max_face_height,
uni_char_t *psz_text, text_style_t **pp_styles,
uint32_t *pi_k_dates, int i_len )
{
line_desc_t *p_first_line = 0;
line_desc_t **pp_line = &p_first_line;
paragraph_t *p_paragraph = 0;
int i_paragraph_start = 0;
int i_max_height = 0;
for( int i = 0; i <= i_len; ++i )
{
if( i == i_len || psz_text[ i ] == '\n' )
{
if( i_paragraph_start == i )
{
i_paragraph_start = i + 1;
continue;
}
p_paragraph = NewParagraph( p_filter, i - i_paragraph_start,
psz_text + i_paragraph_start,
pp_styles + i_paragraph_start,
pi_k_dates ?
pi_k_dates + i_paragraph_start : 0,
20 );
if( !p_paragraph )
{
if( p_first_line ) FreeLines( p_first_line );
return VLC_ENOMEM;
}
#ifdef HAVE_FRIBIDI
if( AnalyzeParagraph( p_paragraph ) )
goto error;
#endif
if( ItemizeParagraph( p_filter, p_paragraph ) )
goto error;
#if defined HAVE_HARFBUZZ
if( ShapeParagraphHarfBuzz( p_filter, &p_paragraph ) )
goto error;
if( LoadGlyphs( p_filter, p_paragraph, true, false ) )
goto error;
#elif defined HAVE_FRIBIDI
if( ShapeParagraphFriBidi( p_filter, p_paragraph ) )
goto error;
if( LoadGlyphs( p_filter, p_paragraph, false, true ) )
goto error;
if( RemoveZeroWidthCharacters( p_paragraph ) )
goto error;
if( ZeroNsmAdvance( p_paragraph ) )
goto error;
#else
if( LoadGlyphs( p_filter, p_paragraph, false, true ) )
goto error;
#endif
/*
* Set max line width to allow for outline and shadow glyphs,
* and any extra width caused by visual reordering
*/
int i_max_width = ( int ) p_filter->fmt_out.video.i_visible_width
- 2 * p_filter->p_sys->style.i_font_size;
if( LayoutParagraph( p_filter, p_paragraph,
i_max_width, pp_line ) )
goto error;
FreeParagraph( p_paragraph );
p_paragraph = 0;
for( ; *pp_line; pp_line = &( *pp_line )->p_next )
i_max_height = __MAX( i_max_height, ( *pp_line )->i_height );
i_paragraph_start = i + 1;
}
}
int i_base_line = 0;
FT_BBox bbox = {
.xMin = INT_MAX,
.yMin = INT_MAX,
.xMax = INT_MIN,
.yMax = INT_MIN
};
for( line_desc_t *p_line = p_first_line; p_line; p_line = p_line->p_next )
{
p_line->i_base_line = i_base_line;
p_line->bbox.yMin -= i_base_line;
p_line->bbox.yMax -= i_base_line;
BBoxEnlarge( &bbox, &p_line->bbox );
i_base_line += i_max_height;
}
*pp_lines = p_first_line;
*p_bbox = bbox;
*pi_max_face_height = i_max_height;
return VLC_SUCCESS;
error:
if( p_first_line ) FreeLines( p_first_line );
if( p_paragraph ) FreeParagraph( p_paragraph );
return VLC_EGENERIC;
}
/**
* @internal
* Reorders ustr according to the bidi props.
*
* @param ustr the string to reorder. - Null is ok, will just populate the map.
* @param start the start of the line
* @param len the length of the line
* @param props the paragraph props to reorder according to
* @param _v_to_l The visual to logical map to populate - if NULL it won't populate it.
* @return #EINA_FALSE on success, #EINA_TRUE on error.
*/
Eina_Bool
evas_bidi_props_reorder_line(Eina_Unicode *eina_ustr, size_t start, size_t len, const Evas_BiDi_Paragraph_Props *props, EvasBiDiStrIndex **_v_to_l)
{
EvasBiDiStrIndex *v_to_l = NULL;
FriBidiChar *ustr = NULL, *base_ustr = NULL;
if (!props)
return EINA_FALSE;
if (eina_ustr)
{
/* The size of fribidichar is different than eina_unicode, convert */
#ifdef EVAS_FRIBIDI_EINA_UNICODE_UNEQUAL
base_ustr = ustr = calloc(len + 1, sizeof(FriBidiChar));
ustr = _evas_bidi_unicode_to_fribidichar(ustr, eina_ustr);
#else
ustr = (FriBidiChar *) eina_ustr;
#endif
}
if (_v_to_l) {
size_t i;
v_to_l = *_v_to_l = calloc(len, sizeof(EvasBiDiStrIndex));
if (!v_to_l)
{
goto error;
}
/* init the array for fribidi */
for (i = 0 ; i < len ; i++)
{
v_to_l[i] = i;
}
}
{
EvasBiDiLevel *emb_lvl;
emb_lvl = malloc((start + len) * sizeof(EvasBiDiLevel));
memcpy(emb_lvl, props->embedding_levels,
(start + len) * sizeof(EvasBiDiLevel));
/* We pass v_to_l - start, because fribidi assumes start is the offset
* from the start of v_to_l as well, not just the props. */
if (!fribidi_reorder_line (FRIBIDI_FLAGS_DEFAULT, props->char_types,
len, start, props->direction, emb_lvl, ustr, v_to_l - start))
{
free(emb_lvl);
goto error;
}
free(emb_lvl);
}
/* The size of fribidichar is different than eina_unicode, convert */
#ifdef EVAS_FRIBIDI_EINA_UNICODE_UNEQUAL
_evas_bidi_fribidichar_to_unicode(eina_ustr, base_ustr);
free(base_ustr);
#endif
return EINA_FALSE;
/* ERROR HANDLING */
error:
if (base_ustr) free(base_ustr);
_SAFE_FREE(v_to_l);
return EINA_TRUE;
}
int
main (int argc, char **argv)
{
GError *error;
int next_arg;
GIOChannel *channel;
GIOStatus status;
const char *filename;
gchar *line = NULL;
gsize length, terminator_pos;
int numerrs = 0;
int line_no = 0;
FriBidiChar *code_points = NULL;
int code_points_len = 0;
int expected_ltor_len = 0;
int base_dir_mode = 0, paragraph_dir;
FriBidiLevel *expected_levels = NULL;
int *expected_ltor = NULL;
int resolved_paragraph_embedding_level;
FriBidiLevel *levels = NULL;
FriBidiCharType *types = NULL;
FriBidiBracketType *bracket_types = NULL;
FriBidiStrIndex *ltor = NULL;
int ltor_len;
gboolean debug = FALSE;
if (argc < 2)
{
g_printerr ("usage: %s [--debug] test-file-name\n", argv[0]);
exit (1);
}
next_arg = 1;
while(next_arg < argc && argv[next_arg][0]=='-')
{
const char *arg = argv[next_arg++];
if (strcmp(arg, "--debug")==0)
{
debug=TRUE;
continue;
}
die("Unknown option %s!\n", arg);
}
filename = argv[next_arg++];
error = NULL;
channel = g_io_channel_new_file (filename, "r", &error);
if (!channel)
{
g_printerr ("%s\n", error->message);
exit (1);
}
fribidi_set_debug(debug);
while (TRUE)
{
error = NULL;
g_free (line);
status = g_io_channel_read_line (channel, &line, &length, &terminator_pos, &error);
switch (status)
{
case G_IO_STATUS_ERROR:
g_printerr ("%s\n", error->message);
exit (1);
case G_IO_STATUS_EOF:
goto done;
case G_IO_STATUS_AGAIN:
continue;
case G_IO_STATUS_NORMAL:
line[terminator_pos] = '\0';
break;
}
line_no++;
if (line[0] == '#' || line[0] == '\0')
continue;
parse_test_line (line,
line_no,
&code_points, /* Field 0 */
&code_points_len,
¶graph_dir, /* Field 1 */
&resolved_paragraph_embedding_level, /* Field 2 */
&expected_levels, /* Field 3 */
&expected_ltor, /* Field 4 */
&expected_ltor_len
);
/* Test it */
g_free(bracket_types);
bracket_types = g_malloc ( sizeof(FriBidiBracketType) * code_points_len);
g_free(types);
types = g_malloc ( sizeof(FriBidiCharType) * code_points_len);
g_free(levels);
levels = g_malloc (sizeof (FriBidiLevel) * code_points_len);
g_free (ltor);
ltor = g_malloc (sizeof (FriBidiStrIndex) * code_points_len);
{
FriBidiParType base_dir;
int i, j;
gboolean matches;
int types_len = code_points_len;
int levels_len = types_len;
FriBidiBracketType NoBracket = FRIBIDI_NO_BRACKET;
for (i=0; i<code_points_len; i++)
{
types[i] = fribidi_get_bidi_type(code_points[i]);
/* Note the optimization that a bracket is always
of type neutral */
if (types[i] == FRIBIDI_TYPE_ON)
bracket_types[i] = fribidi_get_bracket(code_points[i]);
else
bracket_types[i] = NoBracket;
}
if ((paragraph_dir & (1<<base_dir_mode)) == 0)
continue;
switch (paragraph_dir)
{
case 0: base_dir = FRIBIDI_PAR_LTR; break;
case 1: base_dir = FRIBIDI_PAR_RTL; break;
case 2: base_dir = FRIBIDI_PAR_ON; break;
}
if (fribidi_get_par_embedding_levels_ex (types,
bracket_types,
types_len,
&base_dir,
levels))
;
for (i = 0; i < types_len; i++)
ltor[i] = i;
if (fribidi_reorder_line (0 /*FRIBIDI_FLAG_REORDER_NSM*/,
types, types_len,
0, base_dir,
levels,
NULL,
ltor))
;
j = 0;
for (i = 0; i < types_len; i++)
if (!FRIBIDI_IS_EXPLICIT_OR_BN (types[ltor[i]]))
ltor[j++] = ltor[i];
ltor_len = j;
/* Compare */
matches = TRUE;
if (matches)
for (i = 0; i < code_points_len; i++)
if (levels[i] != expected_levels[i] &&
expected_levels[i] != (FriBidiLevel) -1) {
matches = FALSE;
break;
}
if (ltor_len != expected_ltor_len)
matches = FALSE;
if (matches)
for (i = 0; i < ltor_len; i++)
if (ltor[i] != expected_ltor[i]) {
matches = FALSE;
break;
}
if (!matches)
{
numerrs++;
g_printerr ("failure on line %d\n", line_no);
g_printerr ("input is: %s\n", line);
g_printerr ("base dir: %s\n", paragraph_dir==0 ? "LTR"
: paragraph_dir==1 ? "RTL" : "AUTO");
g_printerr ("expected levels:");
for (i = 0; i < code_points_len; i++)
if (expected_levels[i] == (FriBidiLevel) -1)
g_printerr (" x");
else
g_printerr (" %d", expected_levels[i]);
g_printerr ("\n");
g_printerr ("returned levels:");
for (i = 0; i < levels_len; i++)
g_printerr (" %d", levels[i]);
g_printerr ("\n");
g_printerr ("expected order:");
for (i = 0; i < expected_ltor_len; i++)
g_printerr (" %d", expected_ltor[i]);
g_printerr ("\n");
g_printerr ("returned order:");
for (i = 0; i < ltor_len; i++)
g_printerr (" %d", ltor[i]);
g_printerr ("\n");
if (debug)
{
FriBidiParType base_dir;
fribidi_set_debug (1);
switch (base_dir_mode)
{
case 0: base_dir = FRIBIDI_PAR_ON; break;
case 1: base_dir = FRIBIDI_PAR_LTR; break;
case 2: base_dir = FRIBIDI_PAR_RTL; break;
}
if (fribidi_get_par_embedding_levels_ex (types,
bracket_types,
types_len,
&base_dir,
levels))
;
fribidi_set_debug (0);
}
g_printerr ("\n");
}
}
}
done:
if (error)
g_error_free (error);
if (numerrs)
g_printerr ("%d errors\n", numerrs);
else
printf("No errors found! :-)\n");
return numerrs;
}