Attachment 3147 Details for Bug 4299 – My C++ test application to demonstrate the bug

My C++ test application to demonstrate the bug

CairoTest.cpp (text/plain), 8.49 KB, created by Alexey Shabalin on 2005-09-01 03:05:20 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Alexey Shabalin

Created: 2005-09-01 03:05:20 UTC

Size: 8.49 KB

patch

obsolete

>// Copyright (c) 1999-2005
>// Motorola, Inc., ALL RIGHTS RESERVED
>
>
>#include <assert.h>
>#include <string.h>
>#include <iostream>
>#include <stdexcept>
>#include <sstream>
>#include <fstream>
>
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <memory.h>
>
>using namespace std;
>
>#ifdef __GNUG__
>    #define COPY(value) strdup(value)
>    #include <unistd.h>
>    #include <pthread.h>
>    #include <stdio.h>
>    #include <stdlib.h>
>    #include <errno.h>
>    
>    // cairo
>    #include <png.h>
>    #include <cairo.h>
>    #include <svg-cairo.h>
>    // cairo
>
>    #include <linux/types.h>
>
>#else 
>    #define COPY(value) _strdup(value)
>    #include <process.h>
>#endif
>
>
>static bool isActive;
>
>struct NavMapImage {
>        char* data;/*!<pointer to the image data. */
>        long size; /*!<number of bytes of the image data. */
>};
>
>class CairoTest {
>
>public:
>	
>    CairoTest(int n) : nTds(n) {
>        isActive = false;
>        source.data = NULL;
>    };
>    ~CairoTest() {
>        if (source.data!=NULL) {
>            delete [] source.data;
>        }
>    }
>    bool loadFile(const char *file);
>    void Run();
>    void RunTests(int Id);
>
>private:
>    
>    int nTds;
>    char *inp_file;  
>    NavMapImage source;
>};
>
>///////////////////////////////////////////////////////
>
>#ifdef __GNUG__
>
># define CAIRO_MUTEX_DECLARE(name) static pthread_mutex_t name = PTHREAD_MUTEX_INITIALIZER
># define CAIRO_MUTEX_LOCK(name) pthread_mutex_lock (&name)
># define CAIRO_MUTEX_UNLOCK(name) pthread_mutex_unlock (&name)
>
>#define MIN(a, b)     (((a) < (b)) ? (a) : (b))
>// Number of bytes per pixel for image in Cairo
>#define CAIRO_BPP 4
>// Number of bytes per pixel for image in PNG
>#define PNG_BPP 4
>
>static void
>write_data_fn(png_struct* png_ptr, png_byte * data,unsigned int length) {
>
>    NavMapImage *img = (NavMapImage*) png_get_io_ptr(png_ptr);
>    memcpy((img->data)+(img->size), data, length);
>    img->size += length;
>    
>}
>
>// Really never called
>static void
>flush_data_fn(png_struct* png_ptr) {
>    // nothing to do
>}
>
>static void
>unpremultiply_data (png_structp png, png_row_infop row_info, png_bytep data){
>    int i;
>
>    for (i = 0; i < row_info->rowbytes; i += 4) {
>        unsigned char *b = &data[i];
>        unsigned int pixel;
>        unsigned char alpha;
>
>	    memcpy (&pixel, b, sizeof (unsigned int));
>	    alpha = (pixel & 0xff000000) >> 24;
>        if (alpha == 0) {
>	        b[0] = b[1] = b[2] = b[3] = 0;
>	    } else {
>            b[0] = (((pixel & 0x0000ff) >>  0) * 255 + alpha / 2) / alpha;
>            b[1] = (((pixel & 0x00ff00) >>  8) * 255 + alpha / 2) / alpha;
>            b[2] = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
>	        b[3] = alpha;
>	    }
>    }
>}
>
>
>void write_png(char * buffer, int width, int height, NavMapImage *target) {
>
>    int i;
>    png_struct *png;
>    png_info *info;
>    png_byte **rows;
>    png_color_16 white;
>    int stride = PNG_BPP * width;
>    
>    rows =(png_byte**) malloc (height * sizeof(png_byte*));
>
>    for (i = 0; i < height; i++) {
>	    rows[i] = (png_byte*) buffer + i * stride;
>    }
>
>    png = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
>    info = png_create_info_struct (png);
>
>    NavMapImage image;
>
>    image.size = 0;
>
>    // draft buffer size estimation (we don't know final size yet)
>    // suppose to be not more than 16 byte per pixel
>    
>    int iMaxSize = 16*width*height;
>    image.data = new char [iMaxSize];
>
>    // set custom I/O functions
>    png_set_write_fn(png,(png_voidp)  &image, write_data_fn, flush_data_fn);
>
>
>    png_set_IHDR (png, info,
>		  width, height, 8,
>		  PNG_COLOR_TYPE_RGB_ALPHA, 
>		  PNG_INTERLACE_NONE,
>		  PNG_COMPRESSION_TYPE_DEFAULT,
>		  PNG_FILTER_TYPE_DEFAULT);
>
>    white.red = 0xff;
>    white.blue = 0xff;
>    white.green = 0xff;
>    png_set_bKGD (png, info, &white);
>
>    png_set_write_user_transform_fn (png, unpremultiply_data);
>    png_set_bgr (png);
>    png_write_info (png, info);
>    png_write_image (png, rows);
>    png_write_end (png, info);
>    png_destroy_write_struct (&png, &info);
>
>    free (rows);
>    
>    // prevent buffer overflow
>    int size = ((image.size < iMaxSize) ? image.size : iMaxSize);
>
>    target->data = new char [size];
>    
>    memcpy(target->data, image.data, size);
>    
>    target->size = size;
>
>    delete [] image.data;
>}
>
>void svg2image(NavMapImage *src, NavMapImage *target, cairo_format_t format, 
>               void (*write_fn)(char * buffer, int width, int height, NavMapImage *target)
>               ){
>    unsigned int svg_width, svg_height;
>
>
>    //CAIRO_MUTEX_DECLARE(my_cairo_mutex);
>    
>    svg_cairo_status_t status;
>    cairo_t *cr;
>    svg_cairo_t *svgc;
>    cairo_surface_t *surface;
>
>    status = svg_cairo_create (&svgc);
>
>    if (status) {
>	    fprintf (stderr, "Failed to create svg_cairo_t. Exiting.\n");
>	    return;
>    }
>
>        status = svg_cairo_parse_buffer(svgc, src->data, src->size);
>        if (status)
>	        return;
>
>        svg_cairo_get_size (svgc, &svg_width, &svg_height);
>        int stride;
>
>        switch(format) {
>            case CAIRO_FORMAT_A1:
>                stride = svg_width / 8;
>                break;
>            case CAIRO_FORMAT_A8:
>                stride = svg_width;
>                break;
>            case CAIRO_FORMAT_RGB24:
>            case CAIRO_FORMAT_ARGB32:
>            default:
>                stride = CAIRO_BPP * svg_width;
>        }   
>
>        char * image_buf = (char *) malloc (stride * svg_height);
>
>        surface = cairo_image_surface_create_for_data ((unsigned char *) image_buf, format, svg_width, svg_height, stride);
>            cr = cairo_create (surface);
>  
>            /// XXX: This probably doesn't need to be here (eventually) 
>                cairo_set_source_rgb (cr, 1, 1, 1);
>
>               // CAIRO_MUTEX_LOCK(my_cairo_mutex);
>                    status = svg_cairo_render (svgc, cr);
>               // CAIRO_MUTEX_UNLOCK(my_cairo_mutex);
>
>            cairo_destroy (cr);
>        
>        cairo_surface_destroy(surface);
>
>    svg_cairo_destroy (svgc);
>   
>     // call function to write image to corresponding format
>    (*write_fn) (image_buf, svg_width, svg_height, target);
>
>    free (image_buf);
>}
>
>
>
>void svg2png(NavMapImage *src, NavMapImage *target) {
>
>    svg2image(src, target, CAIRO_FORMAT_ARGB32, write_png);
>
>}
>
>     
>#else
>// stub
>void svg2png(NavMapImage *src, NavMapImage *target) {
>
>}
>  
>#endif
>/////////////////////////////////////////////////////////
>
>
>void CairoTest::RunTests(int Id) {
>    NavMapImage target;
>    target.data = NULL;
>    char file[80];
>    sprintf(file, "%d.png", Id);
>    svg2png(&source, &target);
>
>////////////////////
>    /*
>    std::ofstream f;
>
>    cerr<<"***writing PNG file:"<<file<<"\n"; 
>    f.open(file,ios::out);
>    if(!f.is_open()){
>        cerr<<"***fail on openning file:"<<file<<"\n";
>        return;
>    }
>    
>    f.write(target.data, target.size);
>    
>    f.close();
>    */
>////////////////////
>    if(target.data !=NULL) delete [] target.data;
>
>    cerr << "Conversion completed in thread" << Id << endl;
>}
>
>#ifdef __GNUG__
>void* MyThreadProc(void* parameter) {
>    int Id =pthread_self();
>    cout <<"Started thread " <<Id<< endl;
>
>    CairoTest *test = (CairoTest*) parameter;
>
>    isActive = true;
>    
>    while(true)        
>        test->RunTests(Id);
>    isActive = false;
>    
>    cout <<"Finished thread " <<Id<< endl;
>    return NULL;
>}
>#endif
>
>void CairoTest::Run() {
>#ifdef __GNUG__
>    
>        pthread_t tid = 0;
>        // start several threads
>        for(int i=0; i<nTds; i++) {
>            pthread_create(&tid, NULL,MyThreadProc, this);
>        }
>        // wait until all threads completed
>        while (isActive) {
>            sleep(10 /*00*/);
>        }
>        
>#endif
>}
>int main( int argc, char *argv[ ] ) {
>
>	char * in_file;
>	if (argc<2) {
>		cerr << "No arguments was specified \n Format is: \n"
>			<< "ConReq.exe <SVG_file> [<Num_of_treads = 1> ]\n";
>			return -1;
>	}
>	else in_file = argv[1];
>    int nThreads = 1;
>    if(argc >2) {
>        nThreads = atoi(argv[2]);
>    }
>
>	CairoTest test(nThreads);
>    
>    if (test.loadFile(in_file)) {
>          test.Run();
>    }
>
>	
>	return 0;
>}
>
>bool CairoTest::loadFile(const char *file){
>
>    std::ifstream f;
>
>    struct stat st;
>
>    if(stat(file, &st)!=0) {
>        cerr<<"***fail on openning file:"<<file<<"\n";
>        return false;
>    }
>
>
>    cerr<<"***loading SVG file:"<<file<<"\n"; 
>    f.open(file,ios::in);
>    if(!f.is_open()){
>        cerr<<"***fail on openning file:"<<file<<"\n";
>        return false;
>    }
>
>
>    int size = st.st_size;
>        
>    source.size = size;
>    source.data = new char [size];
>    
>    f.read(source.data, size);
>    
>    f.close();
>   
>	return true;
>
>}

Actions: View

Attachments on bug 4299: 3146 | 3147 | 3148 | 3202 | 3243 | 3253 | 3254 | 3260 | 3261 | 3274 | 3275

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.