src/video/SDL_blit.c
author Sam Lantinga <slouken@libsdl.org>
Fri, 04 Jan 2019 22:01:14 -0800
changeset 12503 806492103856
parent 11872 e917e911dab6
permissions -rw-r--r--
Updated copyright for 2019
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "../SDL_internal.h"
    22 
    23 #include "SDL_video.h"
    24 #include "SDL_sysvideo.h"
    25 #include "SDL_blit.h"
    26 #include "SDL_blit_auto.h"
    27 #include "SDL_blit_copy.h"
    28 #include "SDL_blit_slow.h"
    29 #include "SDL_RLEaccel_c.h"
    30 #include "SDL_pixels_c.h"
    31 
    32 /* The general purpose software blit routine */
    33 static int SDLCALL
    34 SDL_SoftBlit(SDL_Surface * src, SDL_Rect * srcrect,
    35              SDL_Surface * dst, SDL_Rect * dstrect)
    36 {
    37     int okay;
    38     int src_locked;
    39     int dst_locked;
    40 
    41     /* Everything is okay at the beginning...  */
    42     okay = 1;
    43 
    44     /* Lock the destination if it's in hardware */
    45     dst_locked = 0;
    46     if (SDL_MUSTLOCK(dst)) {
    47         if (SDL_LockSurface(dst) < 0) {
    48             okay = 0;
    49         } else {
    50             dst_locked = 1;
    51         }
    52     }
    53     /* Lock the source if it's in hardware */
    54     src_locked = 0;
    55     if (SDL_MUSTLOCK(src)) {
    56         if (SDL_LockSurface(src) < 0) {
    57             okay = 0;
    58         } else {
    59             src_locked = 1;
    60         }
    61     }
    62 
    63     /* Set up source and destination buffer pointers, and BLIT! */
    64     if (okay && !SDL_RectEmpty(srcrect)) {
    65         SDL_BlitFunc RunBlit;
    66         SDL_BlitInfo *info = &src->map->info;
    67 
    68         /* Set up the blit information */
    69         info->src = (Uint8 *) src->pixels +
    70             (Uint16) srcrect->y * src->pitch +
    71             (Uint16) srcrect->x * info->src_fmt->BytesPerPixel;
    72         info->src_w = srcrect->w;
    73         info->src_h = srcrect->h;
    74         info->src_pitch = src->pitch;
    75         info->src_skip =
    76             info->src_pitch - info->src_w * info->src_fmt->BytesPerPixel;
    77         info->dst =
    78             (Uint8 *) dst->pixels + (Uint16) dstrect->y * dst->pitch +
    79             (Uint16) dstrect->x * info->dst_fmt->BytesPerPixel;
    80         info->dst_w = dstrect->w;
    81         info->dst_h = dstrect->h;
    82         info->dst_pitch = dst->pitch;
    83         info->dst_skip =
    84             info->dst_pitch - info->dst_w * info->dst_fmt->BytesPerPixel;
    85         RunBlit = (SDL_BlitFunc) src->map->data;
    86 
    87         /* Run the actual software blit */
    88         RunBlit(info);
    89     }
    90 
    91     /* We need to unlock the surfaces if they're locked */
    92     if (dst_locked) {
    93         SDL_UnlockSurface(dst);
    94     }
    95     if (src_locked) {
    96         SDL_UnlockSurface(src);
    97     }
    98     /* Blit is done! */
    99     return (okay ? 0 : -1);
   100 }
   101 
   102 #ifdef __MACOSX__
   103 #include <sys/sysctl.h>
   104 
   105 static SDL_bool
   106 SDL_UseAltivecPrefetch()
   107 {
   108     const char key[] = "hw.l3cachesize";
   109     u_int64_t result = 0;
   110     size_t typeSize = sizeof(result);
   111 
   112     if (sysctlbyname(key, &result, &typeSize, NULL, 0) == 0 && result > 0) {
   113         return SDL_TRUE;
   114     } else {
   115         return SDL_FALSE;
   116     }
   117 }
   118 #else
   119 static SDL_bool
   120 SDL_UseAltivecPrefetch()
   121 {
   122     /* Just guess G4 */
   123     return SDL_TRUE;
   124 }
   125 #endif /* __MACOSX__ */
   126 
   127 static SDL_BlitFunc
   128 SDL_ChooseBlitFunc(Uint32 src_format, Uint32 dst_format, int flags,
   129                    SDL_BlitFuncEntry * entries)
   130 {
   131     int i, flagcheck;
   132     static Uint32 features = 0xffffffff;
   133 
   134     /* Get the available CPU features */
   135     if (features == 0xffffffff) {
   136         const char *override = SDL_getenv("SDL_BLIT_CPU_FEATURES");
   137 
   138         features = SDL_CPU_ANY;
   139 
   140         /* Allow an override for testing .. */
   141         if (override) {
   142             SDL_sscanf(override, "%u", &features);
   143         } else {
   144             if (SDL_HasMMX()) {
   145                 features |= SDL_CPU_MMX;
   146             }
   147             if (SDL_Has3DNow()) {
   148                 features |= SDL_CPU_3DNOW;
   149             }
   150             if (SDL_HasSSE()) {
   151                 features |= SDL_CPU_SSE;
   152             }
   153             if (SDL_HasSSE2()) {
   154                 features |= SDL_CPU_SSE2;
   155             }
   156             if (SDL_HasAltiVec()) {
   157                 if (SDL_UseAltivecPrefetch()) {
   158                     features |= SDL_CPU_ALTIVEC_PREFETCH;
   159                 } else {
   160                     features |= SDL_CPU_ALTIVEC_NOPREFETCH;
   161                 }
   162             }
   163         }
   164     }
   165 
   166     for (i = 0; entries[i].func; ++i) {
   167         /* Check for matching pixel formats */
   168         if (src_format != entries[i].src_format) {
   169             continue;
   170         }
   171         if (dst_format != entries[i].dst_format) {
   172             continue;
   173         }
   174 
   175         /* Check modulation flags */
   176         flagcheck =
   177             (flags & (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA));
   178         if ((flagcheck & entries[i].flags) != flagcheck) {
   179             continue;
   180         }
   181 
   182         /* Check blend flags */
   183         flagcheck =
   184             (flags &
   185              (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD));
   186         if ((flagcheck & entries[i].flags) != flagcheck) {
   187             continue;
   188         }
   189 
   190         /* Check colorkey flag */
   191         flagcheck = (flags & SDL_COPY_COLORKEY);
   192         if ((flagcheck & entries[i].flags) != flagcheck) {
   193             continue;
   194         }
   195 
   196         /* Check scaling flags */
   197         flagcheck = (flags & SDL_COPY_NEAREST);
   198         if ((flagcheck & entries[i].flags) != flagcheck) {
   199             continue;
   200         }
   201 
   202         /* Check CPU features */
   203         flagcheck = entries[i].cpu;
   204         if ((flagcheck & features) != flagcheck) {
   205             continue;
   206         }
   207 
   208         /* We found the best one! */
   209         return entries[i].func;
   210     }
   211     return NULL;
   212 }
   213 
   214 /* Figure out which of many blit routines to set up on a surface */
   215 int
   216 SDL_CalculateBlit(SDL_Surface * surface)
   217 {
   218     SDL_BlitFunc blit = NULL;
   219     SDL_BlitMap *map = surface->map;
   220     SDL_Surface *dst = map->dst;
   221 
   222     /* We don't currently support blitting to < 8 bpp surfaces */
   223     if (dst->format->BitsPerPixel < 8) {
   224         SDL_InvalidateMap(map);
   225         return SDL_SetError("Blit combination not supported");
   226     }
   227 
   228     /* Clean everything out to start */
   229     if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
   230         SDL_UnRLESurface(surface, 1);
   231     }
   232     map->blit = SDL_SoftBlit;
   233     map->info.src_fmt = surface->format;
   234     map->info.src_pitch = surface->pitch;
   235     map->info.dst_fmt = dst->format;
   236     map->info.dst_pitch = dst->pitch;
   237 
   238     /* See if we can do RLE acceleration */
   239     if (map->info.flags & SDL_COPY_RLE_DESIRED) {
   240         if (SDL_RLESurface(surface) == 0) {
   241             return 0;
   242         }
   243     }
   244 
   245     /* Choose a standard blit function */
   246     if (map->identity && !(map->info.flags & ~SDL_COPY_RLE_DESIRED)) {
   247         blit = SDL_BlitCopy;
   248     } else if (surface->format->Rloss > 8 || dst->format->Rloss > 8) {
   249         /* Greater than 8 bits per channel not supported yet */
   250         SDL_InvalidateMap(map);
   251         return SDL_SetError("Blit combination not supported");
   252     } else if (surface->format->BitsPerPixel < 8 &&
   253                SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
   254         blit = SDL_CalculateBlit0(surface);
   255     } else if (surface->format->BytesPerPixel == 1 &&
   256                SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
   257         blit = SDL_CalculateBlit1(surface);
   258     } else if (map->info.flags & SDL_COPY_BLEND) {
   259         blit = SDL_CalculateBlitA(surface);
   260     } else {
   261         blit = SDL_CalculateBlitN(surface);
   262     }
   263     if (blit == NULL) {
   264         Uint32 src_format = surface->format->format;
   265         Uint32 dst_format = dst->format->format;
   266 
   267         blit =
   268             SDL_ChooseBlitFunc(src_format, dst_format, map->info.flags,
   269                                SDL_GeneratedBlitFuncTable);
   270     }
   271 #ifndef TEST_SLOW_BLIT
   272     if (blit == NULL)
   273 #endif
   274     {
   275         Uint32 src_format = surface->format->format;
   276         Uint32 dst_format = dst->format->format;
   277 
   278         if (!SDL_ISPIXELFORMAT_INDEXED(src_format) &&
   279             !SDL_ISPIXELFORMAT_FOURCC(src_format) &&
   280             !SDL_ISPIXELFORMAT_INDEXED(dst_format) &&
   281             !SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
   282             blit = SDL_Blit_Slow;
   283         }
   284     }
   285     map->data = blit;
   286 
   287     /* Make sure we have a blit function */
   288     if (blit == NULL) {
   289         SDL_InvalidateMap(map);
   290         return SDL_SetError("Blit combination not supported");
   291     }
   292 
   293     return 0;
   294 }
   295 
   296 /* vi: set ts=4 sw=4 expandtab: */