int ttfFont__Open_aux(ttfFont *self, ttfInterpreter *tti, gx_ttfReader *r, gs_font_type42 *pfont, const gs_matrix * char_tm, const gs_log2_scale_point *log2_scale, bool design_grid) { gs_point char_size, subpix_origin; gs_matrix post_transform; /* * Ghostscript proceses a TTC index in gs/lib/gs_ttf.ps, * and *pfont already adjusted to it. * Therefore TTC headers never comes here. */ unsigned int nTTC = 0; bool dg; decompose_matrix(pfont, char_tm, log2_scale, design_grid, &char_size, &subpix_origin, &post_transform, &dg); switch(ttfFont__Open(tti, self, &r->super, nTTC, char_size.x, char_size.y, dg)) { case fNoError: return 0; case fMemoryError: return_error(gs_error_VMerror); case fUnimplemented: return_error(gs_error_unregistered); case fBadInstruction: WarnBadInstruction(pfont, -1); goto recover; case fPatented: WarnPatented(pfont, self, "The font"); recover: self->patented = true; return 0; default: { int code = r->super.Error(&r->super); if (code < 0) return code; return_error(gs_error_invalidfont); } } }
int gx_ttf_outline(ttfFont *ttf, gx_ttfReader *r, gs_font_type42 *pfont, int glyph_index, const gs_matrix *m, const gs_log2_scale_point *pscale, gx_path *path, bool design_grid) { gx_ttfExport e; ttfOutliner o; gs_point char_size, subpix_origin; gs_matrix post_transform; /* Ghostscript proceses a TTC index in gs/lib/gs_ttf.ps, */ /* so that TTC never comes here. */ FloatMatrix m1; bool dg; uint gftt = gs_currentgridfittt(pfont->dir); bool ttin = (gftt & 1); /* gs_currentgridfittt values (binary) : 00 - no grid fitting; 01 - Grid fit with TT interpreter; On failure warn and render unhinted. 10 - Interpret in the design grid and then autohint. 11 - Grid fit with TT interpreter; On failure render autohinted. */ bool auth = (gftt & 2); decompose_matrix(pfont, m, pscale, design_grid, &char_size, &subpix_origin, &post_transform, &dg); m1.a = post_transform.xx; m1.b = post_transform.xy; m1.c = post_transform.yx; m1.d = post_transform.yy; m1.tx = post_transform.tx; m1.ty = post_transform.ty; e.super.bPoints = false; e.super.bOutline = true; e.super.MoveTo = gx_ttfExport__MoveTo; e.super.LineTo = gx_ttfExport__LineTo; e.super.CurveTo = gx_ttfExport__CurveTo; e.super.Close = gx_ttfExport__Close; e.super.Point = gx_ttfExport__Point; e.super.SetWidth = gx_ttfExport__SetWidth; e.super.DebugPaint = gx_ttfExport__DebugPaint; e.error = 0; e.path = path; e.w.x = 0; e.w.y = 0; e.monotonize = auth; gx_ttfReader__Reset(r); ttfOutliner__init(&o, ttf, &r->super, &e.super, true, false, pfont->WMode != 0); switch(ttfOutliner__Outline(&o, glyph_index, subpix_origin.x, subpix_origin.y, &m1)) { case fBadInstruction: WarnBadInstruction(pfont, glyph_index); goto recover; case fPatented: /* The returned outline did not apply a bytecode (it is not grid-fitted). */ if (!auth) WarnPatented(pfont, ttf, "Some glyphs of the font"); recover : if (!design_grid && auth) return grid_fit(pfont->dir->san, path, pfont, pscale, &e, &o); /* Falls through. */ case fNoError: if (!design_grid && !ttin && auth) return grid_fit(pfont->dir->san, path, pfont, pscale, &e, &o); ttfOutliner__DrawGlyphOutline(&o); if (e.error) return e.error; return 0; case fMemoryError: return_error(gs_error_VMerror); case fUnimplemented: return_error(gs_error_unregistered); default: { int code = r->super.Error(&r->super); if (code < 0) return code; return_error(gs_error_invalidfont); } } }
/** * Main driver code for the parallel lab. Generates the matrix of the * specified size, initiates the decomposition and checking * routines. */ int main (int argc, char *argv[]) { int size = 0; double *a = NULL; double *lu = NULL; clock_t start, time1, time2; struct timeval start_timeval, end_timeval; double elapsed_secs, elapsed_total_secs, cpu_secs; /* Bail out if we don't have the correct number of parameters */ if (argc!=2) { printf("This program is used to decompose a (random) matrix A into its components L and U.\n"); printf("Usage: %s <matrix size>\n", argv[0]); return -1; } size = atoi(argv[1]); /* Adjust matrix size */ if (size < MIN_MATRIX_SIZE) { printf("Setting matrix size to minimum value %d.\n", MIN_MATRIX_SIZE); size = MIN_MATRIX_SIZE; } else if (size > MAX_MATRIX_SIZE) { printf("Setting matrix size to maximum value %d.\n", MAX_MATRIX_SIZE); size = MAX_MATRIX_SIZE; } /* Generate data. */ printf("LU matrix decomposition, starting warmup...\n"); printf(" - Generating a %i * %i matrix\n", size, size); a = (double*)malloc(sizeof(double)*size*size); lu = (double*)malloc(sizeof(double)*size*size); if (a==NULL || lu==NULL) { printf("Not enough memory!\n"); return -1; } fill_matrix(a, size); print_matrix(a, size); memcpy(lu, a, sizeof(double)*size*size); /* Start LU decomposition. */ printf("Decomposing the matrix into its components...\n"); gettimeofday(&start_timeval, NULL); start = clock(); decompose_matrix(lu, size); time1 = clock()-start; gettimeofday(&end_timeval, NULL); elapsed_total_secs = elapsed_secs = (double)timediff_ms(&start_timeval, &end_timeval)/1000.0; cpu_secs = (double)(time1)/CLOCKS_PER_SEC; /* Verify resulting decomposition. */ printf("Checking result...\n"); print_matrix(lu, size); gettimeofday(&start_timeval, NULL); start = clock(); if (check_matrix(lu, a, size)) printf("The computation seems correct\n"); else printf("The computation seems not correct\n"); time2 = clock()-start; gettimeofday(&end_timeval, NULL); /* Output stats. */ printf("\nDecomposition time: %.2fs CPU, %.2fs elapsed, %.1f%% speedup\n", cpu_secs, elapsed_secs, cpu_secs/elapsed_secs*100.0); elapsed_secs = (double)timediff_ms(&start_timeval, &end_timeval)/1000.0; elapsed_total_secs += elapsed_secs; cpu_secs = (double)(time2)/CLOCKS_PER_SEC; printf("Checking time: %.2fs CPU, %.2fs elapsed, %.1f%% speedup\n", cpu_secs, elapsed_secs, cpu_secs/elapsed_secs*100.0); cpu_secs = (double)(time1+time2)/CLOCKS_PER_SEC; printf("Overall time: %.2fs CPU, %.2fs elapsed, %.1f%% speedup\n", cpu_secs, elapsed_total_secs, cpu_secs/elapsed_total_secs*100.0); /* Free resources. */ free(lu); free(a); return 0; }