Changeset 2629


Ignore:
Timestamp:
08/02/08 02:00:51 (5 years ago)
Author:
sam
Message:
  • pipi.c: reimplement pipi_new() without relying on the underlying codec library, so we can have several or none of them at some time.
  • sdl.c imlib.c: allow to save images that weren't created using the current codec.
Location:
libpipi/trunk/pipi
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • libpipi/trunk/pipi/codec.c

    r2607 r2629  
    3939} 
    4040 
    41 pipi_image_t *pipi_new(int width, int height) 
    42 { 
    43 #if USE_SDL 
    44     return pipi_new_sdl(width, height); 
    45 #elif USE_IMLIB2 
    46     return pipi_new_imlib2(width, height); 
    47 #elif USE_OPENCV 
    48     return pipi_new_opencv(width, height); 
    49 #endif 
    50 } 
    51  
    5241void pipi_free(pipi_image_t *img) 
    5342{ 
    54     unsigned int i; 
     43    int i; 
    5544 
    5645    for(i = 0; i < PIPI_PIXELS_MAX; i++) 
    … …  
    5948 
    6049#if USE_SDL 
    61     return pipi_free_sdl(img); 
     50    pipi_free_sdl(img); 
    6251#elif USE_IMLIB2 
    63     return pipi_free_imlib2(img); 
     52    pipi_free_imlib2(img); 
    6453#elif USE_OPENCV 
    65     return pipi_free_opencv(img); 
     54    pipi_free_opencv(img); 
    6655#endif 
     56 
     57    free(img); 
    6758} 
    6859 

  • libpipi/trunk/pipi/codec/imlib.c

    r2605 r2629  
    3737        return NULL; 
    3838 
    39     img = (pipi_image_t *)malloc(sizeof(pipi_image_t)); 
    40     memset(img, 0, sizeof(pipi_image_t)); 
    41  
    4239    imlib_context_set_image(priv); 
    43     img->w = imlib_image_get_width(); 
    44     img->h = imlib_image_get_height(); 
     40    img = pipi_new(imlib_image_get_width(), imlib_image_get_height()); 
    4541 
    4642    img->p[PIPI_PIXELS_RGBA32].pixels = imlib_image_get_data(); 
    47     img->p[PIPI_PIXELS_RGBA32].w = imlib_image_get_width(); 
    48     img->p[PIPI_PIXELS_RGBA32].h = imlib_image_get_height(); 
    49     img->p[PIPI_PIXELS_RGBA32].pitch = 4 * imlib_image_get_width(); 
    50     img->last_modified = PIPI_PIXELS_RGBA32; 
    51  
    52     img->codec_priv = (void *)priv; 
    53     img->codec_format = PIPI_PIXELS_RGBA32; 
    54  
    55     return img; 
    56 } 
    57  
    58 pipi_image_t *pipi_new_imlib2(int width, int height) 
    59 { 
    60     pipi_image_t *img; 
    61     Imlib_Image priv = imlib_create_image(width, height); 
    62  
    63     if(!priv) 
    64         return NULL; 
    65  
    66     img = (pipi_image_t *)malloc(sizeof(pipi_image_t)); 
    67     memset(img, 0, sizeof(pipi_image_t)); 
    68  
    69     imlib_context_set_image(priv); 
    70     img->w = imlib_image_get_width(); 
    71     img->h = imlib_image_get_height(); 
    72  
    73     img->p[PIPI_PIXELS_RGBA32].pixels = imlib_image_get_data(); 
    74     img->p[PIPI_PIXELS_RGBA32].w = imlib_image_get_width(); 
    75     img->p[PIPI_PIXELS_RGBA32].h = imlib_image_get_height(); 
    76     img->p[PIPI_PIXELS_RGBA32].pitch = 4 * imlib_image_get_width(); 
     43    img->p[PIPI_PIXELS_RGBA32].w = img->w; 
     44    img->p[PIPI_PIXELS_RGBA32].h = img->h; 
     45    img->p[PIPI_PIXELS_RGBA32].pitch = 4 * img->w; 
    7746    img->last_modified = PIPI_PIXELS_RGBA32; 
    7847 
    … …  
    8756    imlib_context_set_image(img->codec_priv); 
    8857    imlib_free_image(); 
    89  
    90     free(img); 
    9158} 
    9259 
    9360void pipi_save_imlib2(pipi_image_t *img, const char *name) 
    9461{ 
     62    if(!img->codec_priv) 
     63    { 
     64        Imlib_Image priv = imlib_create_image(img->w, img->h); 
     65        void *data; 
     66 
     67        imlib_context_set_image(priv); 
     68        data = imlib_image_get_data(); 
     69 
     70        /* FIXME: check pitch differences here */ 
     71        if(img->last_modified == PIPI_PIXELS_RGBA32) 
     72        { 
     73            memcpy(data, img->p[PIPI_PIXELS_RGBA32].pixels, 
     74                   4 * img->w * img->h); 
     75            free(img->p[PIPI_PIXELS_RGBA32].pixels); 
     76        } 
     77 
     78        img->p[PIPI_PIXELS_RGBA32].pixels = data; 
     79        img->p[PIPI_PIXELS_RGBA32].w = imlib_image_get_width(); 
     80        img->p[PIPI_PIXELS_RGBA32].h = imlib_image_get_height(); 
     81        img->p[PIPI_PIXELS_RGBA32].pitch = 4 * imlib_image_get_width(); 
     82 
     83        img->codec_priv = (void *)priv; 
     84        img->codec_format = PIPI_PIXELS_RGBA32; 
     85    } 
     86 
    9587    pipi_getpixels(img, img->codec_format); 
    9688    imlib_context_set_image(img->codec_priv); 

  • libpipi/trunk/pipi/codec/opencv.c

    r2605 r2629  
    3030#include "pipi_internals.h" 
    3131 
     32/* FIXME: this whole file is broken until we support BGR24 images */ 
     33 
    3234pipi_image_t *pipi_load_opencv(const char *name) 
    3335{ 
    … …  
    5961{ 
    6062    pipi_image_t *img; 
    61     IplImage *priv = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3); 
     63    IplImage *priv = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 4); 
    6264 
    6365    if(!priv) 

  • libpipi/trunk/pipi/codec/sdl.c

    r2605 r2629  
    2929#include "pipi_internals.h" 
    3030 
     31static SDL_Surface *create_32bpp_surface(int w, int h); 
     32 
    3133pipi_image_t *pipi_load_sdl(const char *name) 
    3234{ 
    … …  
    3941    if(priv->format->BytesPerPixel != 4) 
    4042    { 
    41         img = pipi_new(priv->w, priv->h); 
    42         SDL_BlitSurface(priv, NULL, img->codec_priv, NULL); 
     43        SDL_Surface *tmp = create_32bpp_surface(priv->w, priv->h); 
     44        SDL_BlitSurface(priv, NULL, tmp, NULL); 
    4345        SDL_FreeSurface(priv); 
    44         return img; 
     46        priv = tmp; 
    4547    } 
    4648 
    47     img = (pipi_image_t *)malloc(sizeof(pipi_image_t)); 
    48     memset(img, 0, sizeof(pipi_image_t)); 
    49  
    50     img->w = priv->w; 
    51     img->h = priv->h; 
    52  
    53     img->p[PIPI_PIXELS_RGBA32].pixels = priv->pixels; 
    54     img->p[PIPI_PIXELS_RGBA32].w = priv->w; 
    55     img->p[PIPI_PIXELS_RGBA32].h = priv->h; 
    56     img->p[PIPI_PIXELS_RGBA32].pitch = priv->pitch; 
    57     img->last_modified = PIPI_PIXELS_RGBA32; 
    58  
    59     img->codec_priv = (void *)priv; 
    60     img->codec_format = PIPI_PIXELS_RGBA32; 
    61  
    62     return img; 
    63 } 
    64  
    65 pipi_image_t *pipi_new_sdl(int width, int height) 
    66 { 
    67     pipi_image_t *img; 
    68     SDL_Surface *priv; 
    69     Uint32 rmask, gmask, bmask, amask; 
    70 #if SDL_BYTEORDER == SDL_BIG_ENDIAN 
    71     rmask = 0xff000000; 
    72     gmask = 0x00ff0000; 
    73     bmask = 0x0000ff00; 
    74     amask = 0x00000000; 
    75 #else 
    76     rmask = 0x000000ff; 
    77     gmask = 0x0000ff00; 
    78     bmask = 0x00ff0000; 
    79     amask = 0x00000000; 
    80 #endif 
    81     priv = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 
    82                                 rmask, gmask, bmask, amask); 
    83  
    84     if(!priv) 
    85         return NULL; 
    86  
    87     img = (pipi_image_t *)malloc(sizeof(pipi_image_t)); 
    88     memset(img, 0, sizeof(pipi_image_t)); 
    89  
    90     img->w = priv->w; 
    91     img->h = priv->h; 
     49    img = pipi_new(priv->w, priv->h); 
    9250 
    9351    img->p[PIPI_PIXELS_RGBA32].pixels = priv->pixels; 
    … …  
    10664{ 
    10765    SDL_FreeSurface(img->codec_priv); 
    108  
    109     free(img); 
    11066} 
    11167 
    11268void pipi_save_sdl(pipi_image_t *img, const char *name) 
    11369{ 
     70    if(!img->codec_priv) 
     71    { 
     72        SDL_Surface *priv = create_32bpp_surface(img->w, img->h); 
     73 
     74        /* FIXME: check pitch differences here */ 
     75        if(img->last_modified == PIPI_PIXELS_RGBA32) 
     76        { 
     77            memcpy(priv->pixels, img->p[PIPI_PIXELS_RGBA32].pixels, 
     78                   priv->pitch * priv->h); 
     79            free(img->p[PIPI_PIXELS_RGBA32].pixels); 
     80        } 
     81 
     82        img->p[PIPI_PIXELS_RGBA32].pixels = priv->pixels; 
     83        img->p[PIPI_PIXELS_RGBA32].w = priv->w; 
     84        img->p[PIPI_PIXELS_RGBA32].h = priv->h; 
     85        img->p[PIPI_PIXELS_RGBA32].pitch = priv->pitch; 
     86 
     87        img->codec_priv = (void *)priv; 
     88        img->codec_format = PIPI_PIXELS_RGBA32; 
     89    } 
     90 
    11491    pipi_getpixels(img, img->codec_format); 
    11592    SDL_SaveBMP(img->codec_priv, name); 
    11693} 
    11794 
     95/* 
     96 * The following functions are local. 
     97 */ 
     98 
     99static SDL_Surface *create_32bpp_surface(int w, int h) 
     100{ 
     101    Uint32 rmask, gmask, bmask, amask; 
     102#if SDL_BYTEORDER == SDL_BIG_ENDIAN 
     103    rmask = 0xff000000; 
     104    gmask = 0x00ff0000; 
     105    bmask = 0x0000ff00; 
     106    amask = 0x00000000; 
     107#else 
     108    rmask = 0x000000ff; 
     109    gmask = 0x0000ff00; 
     110    bmask = 0x00ff0000; 
     111    amask = 0x00000000; 
     112#endif 
     113 
     114    return SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, 
     115                                rmask, gmask, bmask, amask); 
     116} 
     117 

  • libpipi/trunk/pipi/pipi.c

    r2605 r2629  
    3939*/ 
    4040 
     41pipi_image_t *pipi_new(int w, int h) 
     42{ 
     43    pipi_image_t *img; 
     44 
     45    img = malloc(sizeof(pipi_image_t)); 
     46    memset(img, 0, sizeof(pipi_image_t)); 
     47 
     48    img->w = w; 
     49    img->h = h; 
     50    img->last_modified = PIPI_PIXELS_UNINITIALISED; 
     51 
     52    return img; 
     53} 
     54 

  • libpipi/trunk/pipi/pipi.h

    r2617 r2629  
    3030typedef enum 
    3131{ 
     32    PIPI_PIXELS_UNINITIALISED = -1, 
     33 
    3234    PIPI_PIXELS_RGBA32 = 0, 
    3335    PIPI_PIXELS_RGBA_F = 1, 
Note: See TracChangeset for help on using the changeset viewer.