prerequisites.h

Go to the documentation of this file.

// html5_mixer
//
// Copyright (c) 2021 David Apollo (77db70f775fa0b590889c45371a70a1d23e99869d4565976a5207c11606fb6aa)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#ifndef PREREQUISITES_H_
#define PREREQUISITES_H_
 
// These checks don't work in *.c files.
 
#ifdef SDL_VERSION
#define HTML5_MIXER_HAVE_SDL
#endif
 
#ifdef MIX_VERSION
#define HTML5_MIXER_HAVE_MIX
#endif

// Shims for html5_mixer
 
#include <stdio.h>
#include <stdlib.h>
 
#ifndef HTML5_MIXER_HAVE_SDL
#define SDL_Error(code) fprintf(stdout, "SDL Error: %d\n", code)
#define SDL_SetError(...) {fprintf(stdout, __VA_ARGS__); fprintf(stdout, "\n");}
#define SDL_calloc calloc
#define SDL_malloc malloc
#define SDL_free free
#endif
 
#ifndef HTML5_MIXER_HAVE_MIX
#define Mix_SetError SDL_SetError
#endif

// SDL Prerequisites
// The header macros (_begin_code_h etc.) are never defined by SDL.h,
// but we keep them for IDE convenience -- allows code block folding.
 
#ifndef HTML5_MIXER_HAVE_SDL
 
#ifndef _begin_code_h
 
#ifndef DECLSPEC
# if defined(__WIN32__) || defined(__WINRT__)
#  ifdef __BORLANDC__
#   ifdef BUILD_SDL
#    define DECLSPEC
#   else
#    define DECLSPEC    __declspec(dllimport)
#   endif
#  else
#   define DECLSPEC __declspec(dllexport)
#  endif
# else
#  if defined(__GNUC__) && __GNUC__ >= 4
#   define DECLSPEC __attribute__ ((visibility("default")))
#  elif defined(__GNUC__) && __GNUC__ >= 2
#   define DECLSPEC __declspec(dllexport)
#  else
#   define DECLSPEC
#  endif
# endif
#endif
 
/* By default SDL uses the C calling convention */
#ifndef SDLCALL
#if (defined(__WIN32__) || defined(__WINRT__)) && !defined(__GNUC__)
#define SDLCALL __cdecl
#else
#define SDLCALL
#endif
#endif /* SDLCALL */
 
/* Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC */
#ifdef __SYMBIAN32__
#undef DECLSPEC
#define DECLSPEC
#endif /* __SYMBIAN32__ */
 
#endif // _begin_code_h
 
#ifndef SDL_config_h_
 
#define HAVE_STDARG_H   1
#define HAVE_STDDEF_H   1
#define HAVE_STDIO_H    1
 
/* Most everything except Visual Studio 2008 and earlier has stdint.h now */
#if defined(_MSC_VER) && (_MSC_VER < 1600)
/* Here are some reasonable defaults */
typedef unsigned int size_t;
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef signed short int16_t;
typedef unsigned short uint16_t;
typedef signed int int32_t;
typedef unsigned int uint32_t;
typedef signed long long int64_t;
typedef unsigned long long uint64_t;
typedef unsigned long uintptr_t;
#else
#define HAVE_STDINT_H 1
#endif /* Visual Studio 2008 */
 
#endif // SDL_config_h_
 
#ifndef SDL_error_h_
#define SDL_OutOfMemory()   SDL_Error(SDL_ENOMEM)
 
typedef enum
{
    SDL_ENOMEM,
    SDL_EFREAD,
    SDL_EFWRITE,
    SDL_EFSEEK,
    SDL_UNSUPPORTED,
    SDL_LASTERROR
} SDL_errorcode;
#endif // SDL_error_h_
 
#ifndef SDL_stdinc_h_
#if defined(HAVE_STDINT_H)
# include <stdint.h>
#endif
 
#ifdef __CC_ARM
/* ARM's compiler throws warnings if we use an enum: like "SDL_bool x = a < b;" */
#define SDL_FALSE 0
#define SDL_TRUE 1
typedef int SDL_bool;
#else
typedef enum
{
    SDL_FALSE = 0,
    SDL_TRUE = 1
} SDL_bool;
#endif
 
typedef int8_t Sint8;
typedef uint8_t Uint8;
typedef int16_t Sint16;
typedef uint16_t Uint16;
typedef int32_t Sint32;
typedef uint32_t Uint32;
typedef int64_t Sint64;
typedef uint64_t Uint64;
#endif // SDL_stdinc_h
 
#ifndef SDL_rwops_h_
 
#ifdef HAVE_STDDEF_H
#include <stddef.h>
#endif
 
#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
 
#define SDL_RWOPS_UNKNOWN   0U  
#define SDL_RWOPS_STDFILE   2U  
#define SDL_RWOPS_MEMORY    4U  
#define SDL_RWOPS_MEMORY_RO 5U  
 
typedef struct SDL_RWops
{
    Sint64 (SDLCALL * size) (struct SDL_RWops * context);

    Sint64 (SDLCALL * seek) (struct SDL_RWops * context, Sint64 offset,
                             int whence);

    size_t (SDLCALL * read) (struct SDL_RWops * context, void *ptr,
                             size_t size, size_t maxnum);

    size_t (SDLCALL * write) (struct SDL_RWops * context, const void *ptr,
                              size_t size, size_t num);

    int (SDLCALL * close) (struct SDL_RWops * context);
 
    Uint32 type;
    union
    {
#if defined(__ANDROID__)
        struct
        {
            void *fileNameRef;
            void *inputStreamRef;
            void *readableByteChannelRef;
            void *readMethod;
            void *assetFileDescriptorRef;
            long position;
            long size;
            long offset;
            int fd;
        } androidio;
#elif defined(__WIN32__)
        struct
        {
            SDL_bool append;
            void *h;
            struct
            {
                void *data;
                size_t size;
                size_t left;
            } buffer;
        } windowsio;
#endif
 
#ifdef HAVE_STDIO_H
        struct
        {
            SDL_bool autoclose;
            FILE *fp;
        } stdio;
#endif
        struct
        {
            Uint8 *base;
            Uint8 *here;
            Uint8 *stop;
        } mem;
        struct
        {
            void *data1;
            void *data2;
        } unknown;
    } hidden;
 
} SDL_RWops;
 
extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFile(const char *file,
                                                  const char *mode);
 
extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(FILE * fp,
                                                SDL_bool autoclose);
 
extern DECLSPEC SDL_RWops *SDLCALL SDL_AllocRW(void);
extern DECLSPEC void SDLCALL SDL_FreeRW(SDL_RWops * area);
 
#define RW_SEEK_SET 0       
#define RW_SEEK_CUR 1       
#define RW_SEEK_END 2       

#define SDL_RWseek(ctx, offset, whence) (ctx)->seek(ctx, offset, whence)
 
#define SDL_RWclose(ctx)        (ctx)->close(ctx)
 
#ifdef HAVE_FOPEN64
#define fopen   fopen64
#endif
#ifdef HAVE_FSEEKO64
#define fseek_off_t off64_t
#define fseek   fseeko64
#define ftell   ftello64
#elif defined(HAVE_FSEEKO)
#if defined(OFF_MIN) && defined(OFF_MAX)
#define FSEEK_OFF_MIN OFF_MIN
#define FSEEK_OFF_MAX OFF_MAX
#elif defined(HAVE_LIMITS_H)
/* POSIX doesn't specify the minimum and maximum macros for off_t so
 * we have to improvise and dance around implementation-defined
 * behavior. This may fail if the off_t type has padding bits or
 * is not a two's-complement representation. The compilers will detect
 * and eliminate the dead code if off_t has 64 bits.
 */
#define FSEEK_OFF_MAX (((((off_t)1 << (sizeof(off_t) * CHAR_BIT - 2)) - 1) << 1) + 1)
#define FSEEK_OFF_MIN (-(FSEEK_OFF_MAX) - 1)
#endif
#define fseek_off_t off_t
#define fseek   fseeko
#define ftell   ftello
#elif defined(HAVE__FSEEKI64)
#define fseek_off_t __int64
#define fseek   _fseeki64
#define ftell   _ftelli64
#else
#ifdef HAVE_LIMITS_H
#define FSEEK_OFF_MIN LONG_MIN
#define FSEEK_OFF_MAX LONG_MAX
#endif
#define fseek_off_t long
#endif
 
#endif // SDL_rwops_h_
 
#ifndef SDL_audio_h_
typedef Uint16 SDL_AudioFormat;

typedef void (SDLCALL * SDL_AudioCallback) (void *userdata, Uint8 * stream,
                                            int len);
 
typedef struct SDL_AudioSpec
{
    int freq;                   
    SDL_AudioFormat format;     
    Uint8 channels;             
    Uint8 silence;              
    Uint16 samples;             
    Uint16 padding;             
    Uint32 size;                
    SDL_AudioCallback callback; 
    void *userdata;             
} SDL_AudioSpec;
#endif // SDL_audio_h_
 
#endif // HTML5_MIXER_HAVE_SDL

// SDL Mixer Prerequisites
 
#ifndef HTML5_MIXER_HAVE_MIX
 
/* The different fading types supported */
typedef enum {
    MIX_NO_FADING,
    MIX_FADING_OUT,
    MIX_FADING_IN
} Mix_Fading;
 
/* These are types of music files (not libraries used to load them) */
typedef enum {
    MUS_NONE,
    MUS_HTML5,
    MUS_CMD,
    MUS_WAV,
    MUS_MOD,
    MUS_MID,
    MUS_OGG,
    MUS_MP3,
    MUS_MP3_MAD_UNUSED,
    MUS_FLAC,
    MUS_MODPLUG_UNUSED
} Mix_MusicType;
 
/* The internal format for a music chunk interpreted via mikmod */
typedef struct _Mix_Music Mix_Music;
 
#define SDL_MIX_MAXVOLUME (128)
#define MIX_MAX_VOLUME SDL_MIX_MAXVOLUME
 
#endif // HTML5_MIXER_HAVE_MIX
 
#endif // PREREQUISITES_H_