自学教程：C++ ALLEGRO_WARN函数代码示例

static int xdpy_swap_control(ALLEGRO_DISPLAY *display, int vsync_setting){   /* We set the swap interval to 0 if vsync is forced off, and to 1    * if it is forced on.    * http://www.opengl.org/registry/specs/SGI/swap_control.txt    * If the option is set to 0, we simply use the system default. The    * above extension specifies vsync on as default though, so in the    * end with GLX we can't force vsync on, just off.    */   ALLEGRO_DEBUG("requested vsync=%d./n", vsync_setting);   if (vsync_setting) {      if (display->ogl_extras->extension_list->ALLEGRO_GLX_SGI_swap_control) {         int x = (vsync_setting == 2) ? 0 : 1;         if (glXSwapIntervalSGI(x)) {            ALLEGRO_WARN("glXSwapIntervalSGI(%d) failed./n", x);         }      }      else {         ALLEGRO_WARN("no vsync, GLX_SGI_swap_control missing./n");         /* According to the specification that means it's on, but          * the driver might have disabled it. So we do not know.          */         vsync_setting = 0;      }   }   return vsync_setting;}

static void d3d_destroy_bitmap(ALLEGRO_BITMAP *bitmap){   ALLEGRO_BITMAP_D3D *d3d_bmp = (ALLEGRO_BITMAP_D3D *)bitmap;   if (!al_is_sub_bitmap(bitmap)) {      if (d3d_bmp->video_texture) {         if (d3d_bmp->video_texture->Release() != 0) {            ALLEGRO_WARN("d3d_destroy_bitmap: Release video texture failed./n");         }      }      if (d3d_bmp->system_texture) {         if (d3d_bmp->system_texture->Release() != 0) {            ALLEGRO_WARN("d3d_destroy_bitmap: Release system texture failed./n");         }      }      if (d3d_bmp->render_target) {         if (d3d_bmp->render_target->Release() != 0) {            ALLEGRO_WARN("d3d_destroy_bitmap: Release render target failed./n");         }      }   }   _al_vector_find_and_delete(&created_bitmaps, &d3d_bmp);}

static bool glsl_set_shader_sampler(ALLEGRO_SHADER *shader,   const char *name, ALLEGRO_BITMAP *bitmap, int unit){   ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;   GLint handle;   GLuint texture;   if (bitmap && al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) {      ALLEGRO_WARN("Cannot use memory bitmap for sampler/n");      return false;   }   handle = glGetUniformLocation(gl_shader->program_object, name);   if (handle < 0) {      ALLEGRO_WARN("No uniform variable '%s' in shader program/n", name);      return false;   }   glActiveTexture(GL_TEXTURE0 + unit);   texture = bitmap ? al_get_opengl_texture(bitmap) : 0;   glBindTexture(GL_TEXTURE_2D, texture);   glUniform1i(handle, unit);   return check_gl_error(name);}

static void _al_xsys_xinerama_init(ALLEGRO_SYSTEM_XGLX *s){   int event_base = 0;   int error_base = 0;   /* init xinerama info to defaults */   s->xinerama_available = 0;   s->xinerama_screen_count = 0;   s->xinerama_screen_info = NULL;   _al_mutex_lock(&s->lock);   if (XineramaQueryExtension(s->x11display, &event_base, &error_base)) {      int minor_version = 0, major_version = 0;      int status = XineramaQueryVersion(s->x11display, &major_version, &minor_version);      ALLEGRO_INFO("Xinerama version: %i.%i/n", major_version, minor_version);      if (status && !XineramaIsActive(s->x11display)) {         ALLEGRO_WARN("Xinerama is not active/n");      }      else {         ALLEGRO_INFO("Xinerama is active/n");         s->xinerama_available = 1;      }   }   else {      ALLEGRO_WARN("Xinerama extension is not available./n");   }   _al_mutex_unlock(&s->lock);}

/* _al_win_thread_init: *  Initializes COM interface for the calling thread. *  Attempts to use Distributed COM if available (installed by default *  on every 32-bit Windows starting with Win98 and Win NT4). */void _al_win_thread_init(void){   HMODULE ole32 = NULL;   if (first_call) {      first_call = 0;      ole32 = GetModuleHandle(TEXT("OLE32.DLL"));      if (ole32 != NULL) {	 _CoInitializeEx = (_CoInitializeEx_ptr) GetProcAddress(						ole32, "CoInitializeEx");      }      else {         ALLEGRO_WARN("OLE32.DLL can't be loaded./n");      }      if (_CoInitializeEx == NULL) {         ALLEGRO_WARN("Microsoft Distributed COM is not installed on this system. If you have problems ");         ALLEGRO_WARN("with this application, please install the DCOM update. You can find it on the ");         ALLEGRO_WARN("Microsoft homepage/n");      }   }   if (_CoInitializeEx != NULL)      _CoInitializeEx(NULL, _COINIT_MULTITHREADED);   else      CoInitialize(NULL);}

static bool hapxi_upload_effect(ALLEGRO_HAPTIC *dev,                                ALLEGRO_HAPTIC_EFFECT *effect, ALLEGRO_HAPTIC_EFFECT_ID *id){   ALLEGRO_HAPTIC_XINPUT *hapxi = hapxi_from_al(dev);   ALLEGRO_HAPTIC_EFFECT_XINPUT *effxi = NULL;   ASSERT(dev);   ASSERT(id);   ASSERT(effect);   /* Set id's values to indicate failure beforehand. */   id->_haptic = NULL;   id->_id = -1;   id->_pointer = NULL;   id->_playing = false;   id->_effect_duration = 0.0;   id->_start_time = 0.0;   id->_end_time = 0.0;   if (!al_is_haptic_effect_ok(dev, effect))      return false;   al_lock_mutex(hapxi_mutex);   /* Is a haptic effect slot available? */   effxi = hapxi_get_available_effect(hapxi);   /* No more space for an effect. */   if (!effxi) {      ALLEGRO_WARN("No free effect slot.");      al_unlock_mutex(hapxi_mutex);      return false;   }   if (!hapxi_effect2win(effxi, effect, hapxi)) {      ALLEGRO_WARN("Cannot convert haptic effect to XINPUT effect./n");      al_unlock_mutex(hapxi_mutex);      return false;   }   effxi->state = ALLEGRO_HAPTIC_EFFECT_XINPUT_STATE_READY;   effxi->effect = (*effect);   /* set ID handle to signify success */   id->_haptic = dev;   id->_pointer = effxi;   id->_id = effxi->id;   id->_effect_duration = al_get_haptic_effect_duration(effect);   al_unlock_mutex(hapxi_mutex);   return true;}

static bool glsl_set_shader_float_vector(ALLEGRO_SHADER *shader,   const char *name, int num_components, float *f, int num_elems){   ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;   GLint handle;   handle = glGetUniformLocation(gl_shader->program_object, name);   if (handle < 0) {      ALLEGRO_WARN("No uniform variable '%s' in shader program/n", name);      return false;   }   switch (num_components) {      case 1:         glUniform1fv(handle, num_elems, f);         break;      case 2:         glUniform2fv(handle, num_elems, f);         break;      case 3:         glUniform3fv(handle, num_elems, f);         break;      case 4:         glUniform4fv(handle, num_elems, f);         break;      default:         ASSERT(false);         break;   }   return check_gl_error(name);}

static ALLEGRO_DISPLAY_INTERFACE *xglx_get_display_driver(void){   ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();   /* Look up the toggle_mouse_grab_key binding.  This isn't such a great place    * to do it, but the config file is not available until after the system driver    * is initialised.    */   if (!system->toggle_mouse_grab_keycode) {      const char *binding = al_get_config_value(al_get_system_config(),         "keyboard", "toggle_mouse_grab_key");      if (binding) {         system->toggle_mouse_grab_keycode = _al_parse_key_binding(binding,            &system->toggle_mouse_grab_modifiers);         if (system->toggle_mouse_grab_keycode) {            ALLEGRO_DEBUG("Toggle mouse grab key: '%s'/n", binding);         }         else {            ALLEGRO_WARN("Cannot parse key binding '%s'/n", binding);         }      }   }   return _al_display_xglx_driver();}

static bool _ogl_is_extension_with_version_supported(    const char *extension, ALLEGRO_DISPLAY *disp, uint32_t ver){    ALLEGRO_CONFIG *cfg;    char const *value;    /* For testing purposes, any OpenGL extension can be disable in      * the config by using something like:      *      * [opengl_disabled_extensions]      * GL_ARB_texture_non_power_of_two=0      * GL_EXT_framebuffer_object=0      *      */    cfg = al_get_system_config();    if (cfg) {        value = al_get_config_value(cfg,                                    "opengl_disabled_extensions", extension);        if (value) {            ALLEGRO_WARN("%s found in [opengl_disabled_extensions]./n",                         extension);            return false;        }    }    /* If the extension is included in the OpenGL version, there is no     * need to check the extensions list.     */    if (ver > 0 && disp->ogl_extras->ogl_info.version >= ver) {        return true;    }    return _ogl_is_extension_supported(extension, disp);}

/* [user thread] */static bool xgtk_create_display_hook(ALLEGRO_DISPLAY *display, int w, int h){   ALLEGRO_DISPLAY_XGLX *d = (ALLEGRO_DISPLAY_XGLX *)display;   ARGS_CREATE args;   d->gtk = al_calloc(1, sizeof(*(d->gtk)));   if (!d->gtk) {      ALLEGRO_WARN("Out of memory/n");      return false;   }   if (!_al_gtk_ensure_thread()) {      al_free(d->gtk);      d->gtk = NULL;      return false;   }   if (!_al_gtk_init_args(&args, sizeof(args))) {      al_free(d->gtk);      d->gtk = NULL;      return false;   }   args.display = d;   args.w = w;   args.h = h;   args.title = al_get_new_window_title();   return _al_gtk_wait_for_args(do_create_display_hook, &args);}

/* Function: al_set_voice_playing */bool al_set_voice_playing(ALLEGRO_VOICE *voice, bool val){   ASSERT(voice);   if (!voice->attached_stream) {      ALLEGRO_DEBUG("Voice has no attachment/n");      return false;   }   if (voice->is_streaming) {      ALLEGRO_WARN("Attempted to change the playing state of a voice "         "with a streaming attachment (mixer or audiostreams)/n");      return false;   }   else {      bool playing = al_get_voice_playing(voice);      if (playing == val) {         if (playing) {            ALLEGRO_DEBUG("Voice is already playing/n");         }         else {            ALLEGRO_DEBUG("Voice is already stopped/n");         }         return true;      }      return _al_kcm_set_voice_playing(voice, voice->mutex, val);   }}

static HMODULE load_library_at_path(const char *path_str){    HMODULE lib;    /*     * XXX LoadLibrary will search the current directory for any dependencies of     * the library we are loading.  Using LoadLibraryEx with the appropriate     * flags would fix that, but when I tried it I was unable to load dsound.dll     * on Vista.     */    ALLEGRO_DEBUG("Calling LoadLibrary %s/n", path_str);    lib = LoadLibraryA(path_str);    if (lib) {        ALLEGRO_INFO("Loaded %s/n", path_str);    }    else {        DWORD error = GetLastError();        HRESULT hr = HRESULT_FROM_WIN32(error);        /* XXX do something with it */        (void)hr;        ALLEGRO_WARN("Failed to load %s (error: %ld)/n", path_str, error);    }    return lib;}

static bool check_gl_error(const char* name){   GLenum err = glGetError();   if (err != 0) {      ALLEGRO_WARN("%s (%s)/n", name, _al_gl_error_string(err));      return false;   }   return true;}

static bool init_dynlib(void){#ifdef ALLEGRO_CFG_ACODEC_VORBISFILE_DLL   if (ov_dll) {      return true;   }   if (!ov_virgin) {      return false;   }   ov_virgin = false;   ov_dll = _al_open_library(ALLEGRO_CFG_ACODEC_VORBISFILE_DLL);   if (!ov_dll) {      ALLEGRO_WARN("Could not load " ALLEGRO_CFG_ACODEC_VORBISFILE_DLL "/n");      return false;   }   _al_add_exit_func(shutdown_dynlib, "shutdown_dynlib");   #define INITSYM(x)                                                         /      do                                                                      /      {                                                                       /         lib.x = _al_import_symbol(ov_dll, #x);                               /         if (lib.x == 0) {                                                    /            ALLEGRO_ERROR("undefined symbol in lib structure: " #x "/n");     /            return false;                                                     /         }                                                                    /      } while(0)#else   #define INITSYM(x)   (lib.x = (x))#endif   memset(&lib, 0, sizeof(lib));   INITSYM(ov_clear);   INITSYM(ov_open_callbacks);   INITSYM(ov_pcm_total);   INITSYM(ov_info);#ifndef TREMOR   INITSYM(ov_time_total);   INITSYM(ov_time_seek_lap);   INITSYM(ov_time_tell);   INITSYM(ov_read);#else   INITSYM(ov_time_total);   INITSYM(ov_time_seek);   INITSYM(ov_time_tell);   INITSYM(ov_read);#endif   return true;#undef INITSYM}

GtkWidget *_al_gtk_get_window(ALLEGRO_DISPLAY *display){   ALLEGRO_DISPLAY_XGLX *d = (ALLEGRO_DISPLAY_XGLX *)display;   if (d->overridable_vt == &xgtk_override_vt) {      return d->gtk->gtkwindow;   }   ALLEGRO_WARN("Not display created with GTK./n");   return NULL;}

/* * Calling LoadLibrary with a relative file name is a security risk: * see e.g. Microsoft Security Advisory (2269637) * "Insecure Library Loading Could Allow Remote Code Execution" */HMODULE _al_win_safe_load_library(const char *filename){    ALLEGRO_PATH *path1 = NULL;    ALLEGRO_PATH *path2 = NULL;    char buf[MAX_PATH];    const char *other_dirs[3];    HMODULE lib = NULL;    bool msvc_only = false;    /* MSVC only: if the executable is in the build configuration directory,     * which is also just under the current directory, then also try to load the     * library from the current directory.  This leads to less surprises when     * running example programs.     */#if defined(ALLEGRO_MSVC)    msvc_only = true;#endif    /* Try to load the library from the directory containing the running     * executable, the Windows system directories, or directories on the PATH.     * Do NOT try to load the library from the current directory.     */    if (al_is_system_installed()) {        path1 = al_get_standard_path(ALLEGRO_RESOURCES_PATH);    }    else if (GetModuleFileName(NULL, buf, sizeof(buf)) < sizeof(buf)) {        path1 = al_create_path(buf);    }    if (msvc_only) {        path2 = maybe_parent_dir(path1);    }    other_dirs[0] = path1 ? al_path_cstr(path1, '//') : NULL;    other_dirs[1] = path2 ? al_path_cstr(path2, '//') : NULL;    other_dirs[2] = NULL; /* sentinel */    _al_sane_strncpy(buf, filename, sizeof(buf));    if (PathFindOnPath(buf, other_dirs)) {        ALLEGRO_DEBUG("PathFindOnPath found: %s/n", buf);        lib = load_library_at_path(buf);    }    else {        ALLEGRO_WARN("PathFindOnPath failed to find %s/n", filename);    }    al_destroy_path(path1);    al_destroy_path(path2);    return lib;}

/* ljoy_init_joystick: [primary thread] *  Initialise the joystick driver. */static bool ljoy_init_joystick(void){    _al_vector_init(&joysticks, sizeof(ALLEGRO_JOYSTICK_LINUX *));    num_joysticks = 0;    if (!(config_mutex = al_create_mutex())) {        return false;    }    // Scan for joysticks    ljoy_scan(false);    ljoy_merge();#ifdef SUPPORT_HOTPLUG    if (!(hotplug_mutex = al_create_mutex())) {        al_destroy_mutex(config_mutex);        return false;    }    if (!(hotplug_cond = al_create_cond())) {        al_destroy_mutex(config_mutex);        al_destroy_mutex(hotplug_mutex);        return false;    }    if (!(hotplug_thread = al_create_thread(hotplug_proc, NULL))) {        al_destroy_mutex(config_mutex);        al_destroy_mutex(hotplug_mutex);        al_destroy_cond(hotplug_cond);        return false;    }    al_start_thread(hotplug_thread);    inotify_fd = inotify_init();    if (inotify_fd != -1) {        fcntl(inotify_fd, F_SETFL, O_NONBLOCK);        /* Modern Linux probably only needs to monitor /dev/input. */        inotify_add_watch(inotify_fd, "/dev/input", IN_CREATE|IN_DELETE);        _al_unix_start_watching_fd(inotify_fd, ljoy_config_dev_changed, NULL);        ALLEGRO_INFO("Hotplugging enabled/n");    }    else {        ALLEGRO_WARN("Hotplugging not enabled/n");        if (inotify_fd != -1) {            close(inotify_fd);            inotify_fd = -1;        }    }#endif    return true;}

/* The voice_is_playing method should only be called on non-streaming sources,   and should return true if the voice is playing */static bool _dsound_voice_is_playing(const ALLEGRO_VOICE *voice){   ALLEGRO_DS_DATA *ex_data = (ALLEGRO_DS_DATA *)voice->extra;   DWORD status;   if (!ex_data) {      ALLEGRO_WARN("ex_data is null/n");      return false;   }   ex_data->ds8_buffer->GetStatus(&status);   return (status & DSBSTATUS_PLAYING);}

static int oss_open(void){   bool force_oss3 = false;   ALLEGRO_CONFIG *config = al_get_system_config();   if (config) {      const char *force_oss3_cfg;      force_oss3_cfg = al_get_config_value(config, "oss", "force_ver3");      if (force_oss3_cfg && force_oss3_cfg[0] != '/0')         force_oss3 = strcmp(force_oss3_cfg, "yes") ? false : true;   }   if (force_oss3) {      ALLEGRO_WARN("Skipping OSS4 probe./n");   }#ifdef OSS_VER_4   bool inited = false;   if (!force_oss3) {      if (oss_open_ver4())         ALLEGRO_WARN("OSS ver. 4 init failed, trying ver. 3.../n");      else         inited = true;   }   if (!inited && oss_open_ver3()) {      ALLEGRO_ERROR("Failed to init OSS./n");      return 1;   }#else   ALLEGRO_INFO("OSS4 support not compiled in. Skipping OSS4 probe./n");   if (oss_open_ver3()) {      ALLEGRO_ERROR("Failed to init OSS./n");      return 1;   }#endif   return 0;}

/* _al_kcm_refill_stream: *  Called by the mixer when the current buffer has been used up.  It should *  point to the next pending buffer and reset the sample position. *  Returns true if the next buffer is available and set up. *  Otherwise returns false. */bool _al_kcm_refill_stream(ALLEGRO_AUDIO_STREAM *stream){   ALLEGRO_SAMPLE_INSTANCE *spl = &stream->spl;   void *old_buf = spl->spl_data.buffer.ptr;   void *new_buf;   size_t i;   if (old_buf) {      /* Slide the buffers down one position and put the       * completed buffer into the used array to be refilled.       */      for (i = 0;            i < stream->buf_count-1 && stream->pending_bufs[i];            i++) {         stream->pending_bufs[i] = stream->pending_bufs[i+1];      }      stream->pending_bufs[i] = NULL;      for (i = 0; stream->used_bufs[i]; i++)         ;      stream->used_bufs[i] = old_buf;   }   new_buf = stream->pending_bufs[0];   stream->spl.spl_data.buffer.ptr = new_buf;   if (!new_buf) {      ALLEGRO_WARN("Out of buffers/n");      return false;   }   /* Copy the last MAX_LAG sample values to the front of the new buffer    * for interpolation.    */   if (old_buf) {      const int bytes_per_sample =         al_get_channel_count(spl->spl_data.chan_conf) *         al_get_audio_depth_size(spl->spl_data.depth);      memcpy(         (char *) new_buf - bytes_per_sample * MAX_LAG,         (char *) old_buf + bytes_per_sample * (spl->pos-MAX_LAG),         bytes_per_sample * MAX_LAG);      stream->consumed_fragments++;   }   stream->spl.pos = 0;   return true;}

/* joydx_thread_proc: [joystick thread] *  Thread loop function for the joystick thread. */static unsigned __stdcall joydx_thread_proc(LPVOID unused){   double last_update = al_get_time();   /* XXX is this needed? */   _al_win_thread_init();   while (true) {      DWORD result;      result = WaitForMultipleObjects(joydx_num_joysticks + 1, /* +1 for STOP_EVENT */                                      joydx_thread_wakers,                                      false,       /* wait for any */                                      1000);   /* 1 second wait */      if (result == WAIT_OBJECT_0)         break; /* STOP_EVENT */      EnterCriticalSection(&joydx_thread_cs);      {         if (al_get_time() > last_update+1 || result == WAIT_TIMEOUT) {            joydx_scan(true);            last_update = al_get_time();         }         if (result != WAIT_TIMEOUT) {            int waker_num = result - WAIT_OBJECT_0 - 1; /* -1 for STOP_EVENT */            HANDLE waker = JOYSTICK_WAKER(waker_num);            unsigned i;            for (i = 0; i < MAX_JOYSTICKS; i++) {               if (waker == joydx_joystick[i].waker_event) {                  update_joystick(&joydx_joystick[i]);                  break;               }            }            if (i == MAX_JOYSTICKS) {               ALLEGRO_WARN("unable to match event to joystick/n");            }         }      }      LeaveCriticalSection(&joydx_thread_cs);   }   _al_win_thread_exit();   (void)unused;   return 0;}

/* By default the combined xinput/directinput driver is used unless directinput * or xinput exclusive is set.*/static ALLEGRO_JOYSTICK_DRIVER *win_get_joystick_driver(void){    if (win_use_directinput()) {        ALLEGRO_DEBUG("Selected DirectInput joystick driver./n");        return &_al_joydrv_directx;    }    if (win_use_xinput()) {#ifdef ALLEGRO_CFG_XINPUT        ALLEGRO_DEBUG("Selected XInput joystick driver./n");        return &_al_joydrv_xinput;#else        ALLEGRO_WARN("XInput joystick driver not supported./n");#endif    }#ifdef ALLEGRO_CFG_XINPUT    ALLEGRO_DEBUG("Selected combined XInput/DirectInput joystick driver./n");    return &_al_joydrv_windows_all;#else    ALLEGRO_WARN("Combined XInput/DirectInput joystick driver not supported. Usign DirectInput in stead./n");    return &_al_joydrv_directx;#endif}

bool _al_win_init_touch_input_api(void){   /* Reference counter will be negative if we already tried to initialize the driver.    * Lack of touch input API is persistent state, so do not test for it again. */   if (touch_input_api_reference_counter < 0)      return false;   /* Increase API reference counter if it is already initialized. */   if (touch_input_api_reference_counter > 0)   {      touch_input_api_reference_counter++;      return true;   }   /* Open handle to user32.dll. This one should be always present. */   user32_module = _al_open_library("user32.dll");   if (NULL == user32_module)      return false;   _al_win_close_touch_input_handle = (CLOSETOUCHINPUTHANDLEPROC)_al_import_symbol(user32_module, "CloseTouchInputHandle");   _al_win_get_touch_input_info     = (GETTOUCHINPUTINFOPROC)    _al_import_symbol(user32_module, "GetTouchInputInfo");   _al_win_is_touch_window          = (ISTOUCHWINDOWPROC)        _al_import_symbol(user32_module, "IsTouchWindow");   _al_win_register_touch_window    = (REGISTERTOUCHWINDOWPROC)  _al_import_symbol(user32_module, "RegisterTouchWindow");   _al_win_unregister_touch_window  = (UNREGISTERTOUCHWINDOWPROC)_al_import_symbol(user32_module, "UnregisterTouchWindow");   if (NULL == _al_win_close_touch_input_handle || NULL == _al_win_get_touch_input_info  ||       NULL == _al_win_is_touch_window          || NULL == _al_win_register_touch_window ||       NULL == _al_win_unregister_touch_window) {      _al_close_library(user32_module);      _al_win_close_touch_input_handle = NULL;      _al_win_get_touch_input_info     = NULL;      _al_win_is_touch_window          = NULL;      _al_win_register_touch_window    = NULL;      _al_win_unregister_touch_window  = NULL;      /* Mark as 'do not try this again'. */      touch_input_api_reference_counter = -1;	  ALLEGRO_WARN("failed loading the touch input API/n");      return false;   }   /* Set initial reference count. */   touch_input_api_reference_counter = 1;   ALLEGRO_INFO("touch input API installed successfully/n");   return true;}

static bool init_dynlib(void){#ifdef ALLEGRO_CFG_ACODEC_OPUSFILE_DLL   if (op_dll) {      return true;   }   if (!op_virgin) {      return false;   }   op_virgin = false;   op_dll = _al_open_library(ALLEGRO_CFG_ACODEC_OPUSFILE_DLL);   if (!op_dll) {      ALLEGRO_WARN("Could not load " ALLEGRO_CFG_ACODEC_OPUSFILE_DLL "/n");      return false;   }   _al_add_exit_func(shutdown_dynlib, "shutdown_dynlib");   #define INITSYM(x)                                                         /      do                                                                      /      {                                                                       /         lib.x = _al_import_symbol(op_dll, #x);                               /         if (lib.x == 0) {                                                    /            ALLEGRO_ERROR("undefined symbol in lib structure: " #x "/n");     /            return false;                                                     /         }                                                                    /      } while(0)#else   #define INITSYM(x)   (lib.x = (x))#endif   memset(&lib, 0, sizeof(lib));   INITSYM(op_free);   INITSYM(op_channel_count);   INITSYM(op_open_callbacks);   INITSYM(op_pcm_total);   INITSYM(op_pcm_seek);   INITSYM(op_pcm_tell);   INITSYM(op_read);   return true;#undef INITSYM}

/* Function: al_load_ogg_vorbis */ALLEGRO_SAMPLE *al_load_ogg_vorbis(const char *filename){   ALLEGRO_FILE *f;   ALLEGRO_SAMPLE *spl;   ASSERT(filename);      ALLEGRO_INFO("Loading sample %s./n", filename);   f = al_fopen(filename, "rb");   if (!f) {      ALLEGRO_WARN("Failed reading %s./n", filename);      return NULL;   }   spl = al_load_ogg_vorbis_f(f);   return spl;}

static bool glsl_set_shader_matrix(ALLEGRO_SHADER *shader,   const char *name, ALLEGRO_TRANSFORM *matrix){   ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;   GLint handle;   handle = glGetUniformLocation(gl_shader->program_object, name);   if (handle < 0) {      ALLEGRO_WARN("No uniform variable '%s' in shader program/n", name);      return false;   }   glUniformMatrix4fv(handle, 1, false, (float *)matrix->m);   return check_gl_error(name);}

static bool glsl_set_shader_float(ALLEGRO_SHADER *shader,   const char *name, float f){   ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;   GLint handle;   handle = glGetUniformLocation(gl_shader->program_object, name);   if (handle < 0) {      ALLEGRO_WARN("No uniform variable '%s' in shader program/n", name);      return false;   }   glUniform1f(handle, f);   return check_gl_error(name);}