blender-archive/source/blender/windowmanager/intern/wm_playanim.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 */

/** \file
 * \ingroup wm
 *
 * Animation player for image sequences & video's with sound support.
 * Launched in a separate process from Blender's #RENDER_OT_play_rendered_anim
 *
 * \note This file uses ghost directly and none of the WM definitions.
 * this could be made into its own module, alongside creator.
 */

#include <fcntl.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

#ifndef WIN32
#  include <sys/times.h>
#  include <sys/wait.h>
#  include <unistd.h>
#else
#  include <io.h>
#endif
#include "MEM_guardedalloc.h"

#include "PIL_time.h"

#include "BLI_fileops.h"
#include "BLI_listbase.h"
#include "BLI_path_util.h"
#include "BLI_rect.h"
#include "BLI_string.h"
#include "BLI_utildefines.h"

#include "IMB_colormanagement.h"
#include "IMB_imbuf.h"
#include "IMB_imbuf_types.h"

#include "BKE_image.h"

#include "BIF_glutil.h"

#include "GPU_context.h"
#include "GPU_framebuffer.h"
#include "GPU_immediate.h"
#include "GPU_immediate_util.h"
#include "GPU_init_exit.h"
#include "GPU_matrix.h"
#include "GPU_state.h"

#include "BLF_api.h"
#include "DNA_scene_types.h"
#include "ED_datafiles.h" /* for fonts */
#include "GHOST_C-api.h"

#include "DEG_depsgraph.h"

#include "WM_api.h" /* only for WM_main_playanim */

#ifdef WITH_AUDASPACE
#  include <AUD_Device.h>
#  include <AUD_Handle.h>
#  include <AUD_Sound.h>
#  include <AUD_Special.h>

static AUD_Sound *source = NULL;
static AUD_Handle *playback_handle = NULL;
static AUD_Handle *scrub_handle = NULL;
static AUD_Device *audio_device = NULL;
#endif

/* simple limiter to avoid flooding memory */
#define USE_FRAME_CACHE_LIMIT
#ifdef USE_FRAME_CACHE_LIMIT
#  define PLAY_FRAME_CACHE_MAX 30
#endif

struct PlayState;
static void playanim_window_zoom(struct PlayState *ps, const float zoom_offset);

/**
 * The current state of the player.
 *
 * \warning Don't store results of parsing command-line arguments
 * in this struct if they need to persist across playing back different
 * files as these will be cleared when playing other files (drag & drop).
 */
typedef struct PlayState {

  /** Window and viewport size. */
  int win_x, win_y;

  /** Current zoom level. */
  float zoom;

  /** Playback direction (-1, 1). */
  short direction;
  /** Set the next frame to implement frame stepping (using shortcuts). */
  short next_frame;

  /** Playback once then wait. */
  bool once;
  /** Play forwards/backwards. */
  bool pingpong;
  /** Disable frame skipping. */
  bool noskip;
  /** Display current frame over the window. */
  bool indicator;
  /** Single-frame stepping has been enabled (frame loading and update pending). */
  bool sstep;
  /** Playback has stopped the image has been displayed. */
  bool wait2;
  /** Playback stopped state once stop/start variables have been handled. */
  bool stopped;
  /**
   * When disabled the current animation will exit,
   * after this either the application exits or a new animation window is opened.
   *
   * This is used so drag & drop can load new files which setup a newly created animation window.
   */
  bool go;
  /** True when waiting for images to load. */
  bool loading;
  /** X/Y image flip (set via key bindings). */
  bool draw_flip[2];

  /** The number of frames to step each update (default to 1, command line argument). */
  int fstep;

  /** Current frame (picture). */
  struct PlayAnimPict *picture;

  /** Image size in pixels, set once at the start. */
  int ibufx, ibufy;
  /** Mono-space font ID. */
  int fontid;

  /** Restarts player for file drop (drag & drop). */
  char dropped_file[FILE_MAX];

  /** Force update when scrubbing with the cursor. */
  bool need_frame_update;
  /** The current frame calculated by scrubbing the mouse cursor. */
  int frame_cursor_x;

  ColorManagedViewSettings view_settings;
  ColorManagedDisplaySettings display_settings;
} PlayState;

/* for debugging */
#if 0
static void print_ps(PlayState *ps)
{
  printf("ps:\n");
  printf("    direction=%d,\n", (int)ps->direction);
  printf("    once=%d,\n", ps->once);
  printf("    pingpong=%d,\n", ps->pingpong);
  printf("    noskip=%d,\n", ps->noskip);
  printf("    sstep=%d,\n", ps->sstep);
  printf("    wait2=%d,\n", ps->wait2);
  printf("    stopped=%d,\n", ps->stopped);
  printf("    go=%d,\n\n", ps->go);
  fflush(stdout);
}
#endif

/* global for window and events */
typedef enum eWS_Qual {
  WS_QUAL_LSHIFT = (1 << 0),
  WS_QUAL_RSHIFT = (1 << 1),
  WS_QUAL_SHIFT = (WS_QUAL_LSHIFT | WS_QUAL_RSHIFT),
  WS_QUAL_LALT = (1 << 2),
  WS_QUAL_RALT = (1 << 3),
  WS_QUAL_ALT = (WS_QUAL_LALT | WS_QUAL_RALT),
  WS_QUAL_LCTRL = (1 << 4),
  WS_QUAL_RCTRL = (1 << 5),
  WS_QUAL_CTRL = (WS_QUAL_LCTRL | WS_QUAL_RCTRL),
  WS_QUAL_LMOUSE = (1 << 16),
  WS_QUAL_MMOUSE = (1 << 17),
  WS_QUAL_RMOUSE = (1 << 18),
  WS_QUAL_MOUSE = (WS_QUAL_LMOUSE | WS_QUAL_MMOUSE | WS_QUAL_RMOUSE),
} eWS_Qual;

static struct WindowStateGlobal {
  GHOST_SystemHandle ghost_system;
  void *ghost_window;
  GPUContext *gpu_context;

  /* events */
  eWS_Qual qual;
} g_WS = {NULL};

static void playanim_window_get_size(int *r_width, int *r_height)
{
  GHOST_RectangleHandle bounds = GHOST_GetClientBounds(g_WS.ghost_window);
  *r_width = GHOST_GetWidthRectangle(bounds);
  *r_height = GHOST_GetHeightRectangle(bounds);
  GHOST_DisposeRectangle(bounds);
}

static void playanim_gl_matrix(void)
{
  /* unified matrix, note it affects offset for drawing */
  /* note! cannot use GPU_matrix_ortho_2d_set here because shader ignores. */
  GPU_matrix_ortho_set(0.0f, 1.0f, 0.0f, 1.0f, -1.0, 1.0f);
}

/* implementation */
static void playanim_event_qual_update(void)
{
  int val;

  /* Shift */
  GHOST_GetModifierKeyState(g_WS.ghost_system, GHOST_kModifierKeyLeftShift, &val);
  SET_FLAG_FROM_TEST(g_WS.qual, val, WS_QUAL_LSHIFT);

  GHOST_GetModifierKeyState(g_WS.ghost_system, GHOST_kModifierKeyRightShift, &val);
  SET_FLAG_FROM_TEST(g_WS.qual, val, WS_QUAL_RSHIFT);

  /* Control */
  GHOST_GetModifierKeyState(g_WS.ghost_system, GHOST_kModifierKeyLeftControl, &val);
  SET_FLAG_FROM_TEST(g_WS.qual, val, WS_QUAL_LCTRL);

  GHOST_GetModifierKeyState(g_WS.ghost_system, GHOST_kModifierKeyRightControl, &val);
  SET_FLAG_FROM_TEST(g_WS.qual, val, WS_QUAL_RCTRL);

  /* Alt */
  GHOST_GetModifierKeyState(g_WS.ghost_system, GHOST_kModifierKeyLeftAlt, &val);
  SET_FLAG_FROM_TEST(g_WS.qual, val, WS_QUAL_LALT);

  GHOST_GetModifierKeyState(g_WS.ghost_system, GHOST_kModifierKeyRightAlt, &val);
  SET_FLAG_FROM_TEST(g_WS.qual, val, WS_QUAL_RALT);
}

typedef struct PlayAnimPict {
  struct PlayAnimPict *next, *prev;
  uchar *mem;
  int size;
  const char *name;
  struct ImBuf *ibuf;
  struct anim *anim;
  int frame;
  int IB_flags;

#ifdef USE_FRAME_CACHE_LIMIT
  /** Back pointer to the #LinkData node for this struct in the #g_frame_cache.pics list. */
  LinkData *frame_cache_node;
  size_t size_in_memory;
#endif
} PlayAnimPict;

static struct ListBase picsbase = {NULL, NULL};
/* frames in memory - store them here to for easy deallocation later */
static bool fromdisk = false;
static double ptottime = 0.0, swaptime = 0.04;
#ifdef WITH_AUDASPACE
static double fps_movie;
#endif

#ifdef USE_FRAME_CACHE_LIMIT
static struct {
  /** A list of #LinkData nodes referencing #PlayAnimPict to track cached frames. */
  struct ListBase pics;
  /** Number if elements in `pics`. */
  int pics_len;
  /** Keep track of memory used by #g_frame_cache.pics when `g_frame_cache.memory_limit != 0`. */
  size_t pics_size_in_memory;
  /** Optionally limit the amount of memory used for cache (in bytes), ignored when zero. */
  size_t memory_limit;
} g_frame_cache = {
    .pics = {NULL, NULL},
    .pics_len = 0,
    .pics_size_in_memory = 0,
    .memory_limit = 0,
};

static void frame_cache_add(PlayAnimPict *pic)
{
  pic->frame_cache_node = BLI_genericNodeN(pic);
  BLI_addhead(&g_frame_cache.pics, pic->frame_cache_node);
  g_frame_cache.pics_len++;

  if (g_frame_cache.memory_limit != 0) {
    BLI_assert(pic->size_in_memory == 0);
    pic->size_in_memory = IMB_get_size_in_memory(pic->ibuf);
    g_frame_cache.pics_size_in_memory += pic->size_in_memory;
  }
}

static void frame_cache_remove(PlayAnimPict *pic)
{
  LinkData *node = pic->frame_cache_node;
  IMB_freeImBuf(pic->ibuf);
  if (g_frame_cache.memory_limit != 0) {
    BLI_assert(pic->size_in_memory != 0);
    g_frame_cache.pics_size_in_memory -= pic->size_in_memory;
    pic->size_in_memory = 0;
  }
  pic->ibuf = NULL;
  pic->frame_cache_node = NULL;
  BLI_freelinkN(&g_frame_cache.pics, node);
  g_frame_cache.pics_len--;
}

/* Don't free the current frame by moving it to the head of the list. */
static void frame_cache_touch(PlayAnimPict *pic)
{
  BLI_assert(pic->frame_cache_node->data == pic);
  BLI_remlink(&g_frame_cache.pics, pic->frame_cache_node);
  BLI_addhead(&g_frame_cache.pics, pic->frame_cache_node);
}

static bool frame_cache_limit_exceeded(void)
{
  return g_frame_cache.memory_limit ?
             (g_frame_cache.pics_size_in_memory > g_frame_cache.memory_limit) :
             (g_frame_cache.pics_len > PLAY_FRAME_CACHE_MAX);
}

static void frame_cache_limit_apply(ImBuf *ibuf_keep)
{
  /* Really basic memory conservation scheme. Keep frames in a FIFO queue. */
  LinkData *node = g_frame_cache.pics.last;
  while (node && frame_cache_limit_exceeded()) {
    PlayAnimPict *pic = node->data;
    BLI_assert(pic->frame_cache_node == node);

    node = node->prev;
    if (pic->ibuf && pic->ibuf != ibuf_keep) {
      frame_cache_remove(pic);
    }
  }
}

#endif /* USE_FRAME_CACHE_LIMIT */

static ImBuf *ibuf_from_picture(PlayAnimPict *pic)
{
  ImBuf *ibuf = NULL;

  if (pic->ibuf) {
    ibuf = pic->ibuf;
  }
  else if (pic->anim) {
    ibuf = IMB_anim_absolute(pic->anim, pic->frame, IMB_TC_NONE, IMB_PROXY_NONE);
  }
  else if (pic->mem) {
    /* use correct colorspace here */
    ibuf = IMB_ibImageFromMemory(pic->mem, pic->size, pic->IB_flags, NULL, pic->name);
  }
  else {
    /* use correct colorspace here */
    ibuf = IMB_loadiffname(pic->name, pic->IB_flags, NULL);
  }

  return ibuf;
}

static PlayAnimPict *playanim_step(PlayAnimPict *playanim, int step)
{
  if (step > 0) {
    while (step-- && playanim) {
      playanim = playanim->next;
    }
  }
  else if (step < 0) {
    while (step++ && playanim) {
      playanim = playanim->prev;
    }
  }
  return playanim;
}

static int pupdate_time(void)
{
  static double ltime;

  double time = PIL_check_seconds_timer();

  ptottime += (time - ltime);
  ltime = time;
  return (ptottime < 0);
}

static void *ocio_transform_ibuf(PlayState *ps,
                                 ImBuf *ibuf,
                                 bool *r_glsl_used,
                                 eGPUTextureFormat *r_format,
                                 eGPUDataFormat *r_data,
                                 void **r_buffer_cache_handle)
{
  void *display_buffer;
  bool force_fallback = false;
  *r_glsl_used = false;
  force_fallback |= (ED_draw_imbuf_method(ibuf) != IMAGE_DRAW_METHOD_GLSL);
  force_fallback |= (ibuf->dither != 0.0f);

  /* Default */
  *r_format = GPU_RGBA8;
  *r_data = GPU_DATA_UBYTE;

  /* Fallback to CPU based color space conversion. */
  if (force_fallback) {
    *r_glsl_used = false;
    display_buffer = NULL;
  }
  else if (ibuf->rect_float) {
    display_buffer = ibuf->rect_float;

    *r_data = GPU_DATA_FLOAT;
    if (ibuf->channels == 4) {
      *r_format = GPU_RGBA16F;
    }
    else if (ibuf->channels == 3) {
      /* Alpha is implicitly 1. */
      *r_format = GPU_RGB16F;
    }

    if (ibuf->float_colorspace) {
      *r_glsl_used = IMB_colormanagement_setup_glsl_draw_from_space(&ps->view_settings,
                                                                    &ps->display_settings,
                                                                    ibuf->float_colorspace,
                                                                    ibuf->dither,
                                                                    false,
                                                                    false);
    }
    else {
      *r_glsl_used = IMB_colormanagement_setup_glsl_draw(
          &ps->view_settings, &ps->display_settings, ibuf->dither, false);
    }
  }
  else if (ibuf->rect) {
    display_buffer = ibuf->rect;
    *r_glsl_used = IMB_colormanagement_setup_glsl_draw_from_space(&ps->view_settings,
                                                                  &ps->display_settings,
                                                                  ibuf->rect_colorspace,
                                                                  ibuf->dither,
                                                                  false,
                                                                  false);
  }
  else {
    display_buffer = NULL;
  }

  /* There is data to be displayed, but GLSL is not initialized
   * properly, in this case we fallback to CPU-based display transform. */
  if ((ibuf->rect || ibuf->rect_float) && !*r_glsl_used) {
    display_buffer = IMB_display_buffer_acquire(
        ibuf, &ps->view_settings, &ps->display_settings, r_buffer_cache_handle);
    *r_format = GPU_RGBA8;
    *r_data = GPU_DATA_UBYTE;
  }

  return display_buffer;
}

static void draw_display_buffer(PlayState *ps, ImBuf *ibuf)
{
  void *display_buffer;

  /* Format needs to be created prior to any #immBindShader call.
   * Do it here because OCIO binds its own shader. */
  eGPUTextureFormat format;
  eGPUDataFormat data;
  bool glsl_used = false;
  GPUVertFormat *imm_format = immVertexFormat();
  uint pos = GPU_vertformat_attr_add(imm_format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
  uint texCoord = GPU_vertformat_attr_add(
      imm_format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);

  void *buffer_cache_handle = NULL;
  display_buffer = ocio_transform_ibuf(ps, ibuf, &glsl_used, &format, &data, &buffer_cache_handle);

  GPUTexture *texture = GPU_texture_create_2d("display_buf", ibuf->x, ibuf->y, 1, format, NULL);
  GPU_texture_update(texture, data, display_buffer);
  GPU_texture_filter_mode(texture, false);

  GPU_texture_bind(texture, 0);

  if (!glsl_used) {
    immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_COLOR);
    immUniformColor3f(1.0f, 1.0f, 1.0f);
    immUniform1i("image", 0);
  }

  immBegin(GPU_PRIM_TRI_FAN, 4);

  rctf preview;
  rctf canvas;

  BLI_rctf_init(&canvas, 0.0f, 1.0f, 0.0f, 1.0f);
  BLI_rctf_init(&preview, 0.0f, 1.0f, 0.0f, 1.0f);

  if (ps->draw_flip[0]) {
    SWAP(float, canvas.xmin, canvas.xmax);
  }
  if (ps->draw_flip[1]) {
    SWAP(float, canvas.ymin, canvas.ymax);
  }

  immAttr2f(texCoord, canvas.xmin, canvas.ymin);
  immVertex2f(pos, preview.xmin, preview.ymin);

  immAttr2f(texCoord, canvas.xmin, canvas.ymax);
  immVertex2f(pos, preview.xmin, preview.ymax);

  immAttr2f(texCoord, canvas.xmax, canvas.ymax);
  immVertex2f(pos, preview.xmax, preview.ymax);

  immAttr2f(texCoord, canvas.xmax, canvas.ymin);
  immVertex2f(pos, preview.xmax, preview.ymin);

  immEnd();

  GPU_texture_unbind(texture);
  GPU_texture_free(texture);

  if (!glsl_used) {
    immUnbindProgram();
  }
  else {
    IMB_colormanagement_finish_glsl_draw();
  }

  if (buffer_cache_handle) {
    IMB_display_buffer_release(buffer_cache_handle);
  }
}

static void playanim_toscreen(
    PlayState *ps, PlayAnimPict *picture, struct ImBuf *ibuf, int fontid, int fstep)
{
  if (ibuf == NULL) {
    printf("%s: no ibuf for picture '%s'\n", __func__, picture ? picture->name : "<NIL>");
    return;
  }

  GHOST_ActivateWindowDrawingContext(g_WS.ghost_window);

  /* size within window */
  float span_x = (ps->zoom * ibuf->x) / (float)ps->win_x;
  float span_y = (ps->zoom * ibuf->y) / (float)ps->win_y;

  /* offset within window */
  float offs_x = 0.5f * (1.0f - span_x);
  float offs_y = 0.5f * (1.0f - span_y);

  CLAMP(offs_x, 0.0f, 1.0f);
  CLAMP(offs_y, 0.0f, 1.0f);

  GPU_clear_color(0.1f, 0.1f, 0.1f, 0.0f);

  /* checkerboard for case alpha */
  if (ibuf->planes == 32) {
    GPU_blend(GPU_BLEND_ALPHA);

    imm_draw_box_checker_2d_ex(offs_x,
                               offs_y,
                               offs_x + span_x,
                               offs_y + span_y,
                               (const float[4]){0.15, 0.15, 0.15, 1.0},
                               (const float[4]){0.20, 0.20, 0.20, 1.0},
                               8);
  }

  draw_display_buffer(ps, ibuf);

  GPU_blend(GPU_BLEND_NONE);

  pupdate_time();

  if (picture && (g_WS.qual & (WS_QUAL_SHIFT | WS_QUAL_LMOUSE)) && (fontid != -1)) {
    int sizex, sizey;
    float fsizex_inv, fsizey_inv;
    char str[32 + FILE_MAX];
    BLI_snprintf(str, sizeof(str), "%s | %.2f frames/s", picture->name, fstep / swaptime);

    playanim_window_get_size(&sizex, &sizey);
    fsizex_inv = 1.0f / sizex;
    fsizey_inv = 1.0f / sizey;

    BLF_color4f(fontid, 1.0, 1.0, 1.0, 1.0);
    BLF_enable(fontid, BLF_ASPECT);
    BLF_aspect(fontid, fsizex_inv, fsizey_inv, 1.0f);
    BLF_position(fontid, 10.0f * fsizex_inv, 10.0f * fsizey_inv, 0.0f);
    BLF_draw(fontid, str, sizeof(str));
  }

  if (ps->indicator) {
    float fac = ps->picture->frame / (double)(((PlayAnimPict *)picsbase.last)->frame -
                                              ((PlayAnimPict *)picsbase.first)->frame);

    fac = 2.0f * fac - 1.0f;
    GPU_matrix_push_projection();
    GPU_matrix_identity_projection_set();
    GPU_matrix_push();
    GPU_matrix_identity_set();

    uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);

    immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
    immUniformColor3ub(0, 255, 0);

    immBegin(GPU_PRIM_LINES, 2);
    immVertex2f(pos, fac, -1.0f);
    immVertex2f(pos, fac, 1.0f);
    immEnd();

    immUnbindProgram();

    GPU_matrix_pop();
    GPU_matrix_pop_projection();
  }

  GHOST_SwapWindowBuffers(g_WS.ghost_window);
}

static void build_pict_list_ex(
    PlayState *ps, const char *first, int totframes, int fstep, int fontid)
{
  if (IMB_isanim(first)) {
    /* OCIO_TODO: support different input color space */
    struct anim *anim = IMB_open_anim(first, IB_rect, 0, NULL);
    if (anim) {
      int pic;
      struct ImBuf *ibuf = IMB_anim_absolute(anim, 0, IMB_TC_NONE, IMB_PROXY_NONE);
      if (ibuf) {
        playanim_toscreen(ps, NULL, ibuf, fontid, fstep);
        IMB_freeImBuf(ibuf);
      }

      for (pic = 0; pic < IMB_anim_get_duration(anim, IMB_TC_NONE); pic++) {
        PlayAnimPict *picture = (PlayAnimPict *)MEM_callocN(sizeof(PlayAnimPict), "Pict");
        picture->anim = anim;
        picture->frame = pic;
        picture->IB_flags = IB_rect;
        picture->name = BLI_sprintfN("%s : %4.d", first, pic + 1);
        BLI_addtail(&picsbase, picture);
      }
    }
    else {
      printf("couldn't open anim %s\n", first);
    }
  }
  else {
    /* Load images into cache until the cache is full,
     * this resolves choppiness for images that are slow to load, see: T81751. */
#ifdef USE_FRAME_CACHE_LIMIT
    bool fill_cache = true;
#else
    bool fill_cache = false;
#endif

    int count = 0;

    int fp_framenr;
    struct {
      char head[FILE_MAX], tail[FILE_MAX];
      unsigned short digits;
    } fp_decoded;

    char filepath[FILE_MAX];
    BLI_strncpy(filepath, first, sizeof(filepath));
    fp_framenr = BLI_path_sequence_decode(
        filepath, fp_decoded.head, fp_decoded.tail, &fp_decoded.digits);

    pupdate_time();
    ptottime = 1.0;

    /* O_DIRECT
     *
     * If set, all reads and writes on the resulting file descriptor will
     * be performed directly to or from the user program buffer, provided
     * appropriate size and alignment restrictions are met.  Refer to the
     * F_SETFL and F_DIOINFO commands in the fcntl(2) manual entry for
     * information about how to determine the alignment constraints.
     * O_DIRECT is a Silicon Graphics extension and is only supported on
     * local EFS and XFS file systems.
     */

    while (IMB_ispic(filepath) && totframes) {
      bool has_event;
      size_t size;
      int file;

      file = BLI_open(filepath, O_BINARY | O_RDONLY, 0);
      if (file < 0) {
        /* print errno? */
        return;
      }

      PlayAnimPict *picture = (PlayAnimPict *)MEM_callocN(sizeof(PlayAnimPict), "picture");
      if (picture == NULL) {
        printf("Not enough memory for pict struct '%s'\n", filepath);
        close(file);
        return;
      }
      size = BLI_file_descriptor_size(file);

      if (size < 1) {
        close(file);
        MEM_freeN(picture);
        return;
      }

      picture->size = size;
      picture->IB_flags = IB_rect;

      uchar *mem;
      if (fromdisk == false) {
        mem = MEM_mallocN(size, "build pic list");
        if (mem == NULL) {
          printf("Couldn't get memory\n");
          close(file);
          MEM_freeN(picture);
          return;
        }

        if (read(file, mem, size) != size) {
          printf("Error while reading %s\n", filepath);
          close(file);
          MEM_freeN(picture);
          MEM_freeN(mem);
          return;
        }
      }
      else {
        mem = NULL;
      }

      picture->mem = mem;
      picture->name = BLI_strdup(filepath);
      picture->frame = count;
      close(file);
      BLI_addtail(&picsbase, picture);
      count++;

      pupdate_time();

      const bool display_imbuf = ptottime > 1.0;

      if (display_imbuf || fill_cache) {
        /* OCIO_TODO: support different input color space */
        ImBuf *ibuf = ibuf_from_picture(picture);

        if (ibuf) {
          if (display_imbuf) {
            playanim_toscreen(ps, picture, ibuf, fontid, fstep);
          }
#ifdef USE_FRAME_CACHE_LIMIT
          if (fill_cache) {
            picture->ibuf = ibuf;
            frame_cache_add(picture);
            fill_cache = !frame_cache_limit_exceeded();
          }
          else
#endif
          {
            IMB_freeImBuf(ibuf);
          }
        }

        if (display_imbuf) {
          pupdate_time();
          ptottime = 0.0;
        }
      }

      /* create a new filepath each time */
      fp_framenr += fstep;
      BLI_path_sequence_encode(
          filepath, fp_decoded.head, fp_decoded.tail, fp_decoded.digits, fp_framenr);

      while ((has_event = GHOST_ProcessEvents(g_WS.ghost_system, false))) {
        GHOST_DispatchEvents(g_WS.ghost_system);
        if (ps->loading == false) {
          return;
        }
      }

      totframes--;
    }
  }
}

static void build_pict_list(PlayState *ps, const char *first, int totframes, int fstep, int fontid)
{
  ps->loading = true;
  build_pict_list_ex(ps, first, totframes, fstep, fontid);
  ps->loading = false;
}

static void update_sound_fps(void)
{
#ifdef WITH_AUDASPACE
  if (playback_handle) {
    /* swaptime stores the 1.0/fps ratio */
    double speed = 1.0 / (swaptime * fps_movie);

    AUD_Handle_setPitch(playback_handle, speed);
  }
#endif
}

static void tag_change_frame(PlayState *ps, int cx)
{
  ps->need_frame_update = true;
  ps->frame_cursor_x = cx;
}

static void change_frame(PlayState *ps)
{
  if (!ps->need_frame_update) {
    return;
  }

  int sizex, sizey;
  int i, i_last;

  if (BLI_listbase_is_empty(&picsbase)) {
    return;
  }

  playanim_window_get_size(&sizex, &sizey);
  i_last = ((struct PlayAnimPict *)picsbase.last)->frame;
  i = (i_last * ps->frame_cursor_x) / sizex;
  CLAMP(i, 0, i_last);

#ifdef WITH_AUDASPACE
  if (scrub_handle) {
    AUD_Handle_stop(scrub_handle);
    scrub_handle = NULL;
  }

  if (playback_handle) {
    AUD_Status status = AUD_Handle_getStatus(playback_handle);
    if (status != AUD_STATUS_PLAYING) {
      AUD_Handle_stop(playback_handle);
      playback_handle = AUD_Device_play(audio_device, source, 1);
      if (playback_handle) {
        AUD_Handle_setPosition(playback_handle, i / fps_movie);
        scrub_handle = AUD_pauseAfter(playback_handle, 1 / fps_movie);
      }
      update_sound_fps();
    }
    else {
      AUD_Handle_setPosition(playback_handle, i / fps_movie);
      scrub_handle = AUD_pauseAfter(playback_handle, 1 / fps_movie);
    }
  }
  else if (source) {
    playback_handle = AUD_Device_play(audio_device, source, 1);
    if (playback_handle) {
      AUD_Handle_setPosition(playback_handle, i / fps_movie);
      scrub_handle = AUD_pauseAfter(playback_handle, 1 / fps_movie);
    }
    update_sound_fps();
  }
#endif

  ps->picture = BLI_findlink(&picsbase, i);
  BLI_assert(ps->picture != NULL);

  ps->sstep = true;
  ps->wait2 = false;
  ps->next_frame = 0;

  ps->need_frame_update = false;
}

static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr ps_void)
{
  PlayState *ps = (PlayState *)ps_void;
  const GHOST_TEventType type = GHOST_GetEventType(evt);
  /* Convert ghost event into value keyboard or mouse. */
  const int val = ELEM(type, GHOST_kEventKeyDown, GHOST_kEventButtonDown);

  // print_ps(ps);

  playanim_event_qual_update();

  /* first check if we're busy loading files */
  if (ps->loading) {
    switch (type) {
      case GHOST_kEventKeyDown:
      case GHOST_kEventKeyUp: {
        GHOST_TEventKeyData *key_data;

        key_data = (GHOST_TEventKeyData *)GHOST_GetEventData(evt);
        switch (key_data->key) {
          case GHOST_kKeyEsc:
            ps->loading = false;
            break;
          default:
            break;
        }
        break;
      }
      default:
        break;
    }
    return 1;
  }

  if (ps->wait2 && ps->stopped == false) {
    ps->stopped = true;
  }

  if (ps->wait2) {
    pupdate_time();
    ptottime = 0;
  }

  switch (type) {
    case GHOST_kEventKeyDown:
    case GHOST_kEventKeyUp: {
      GHOST_TEventKeyData *key_data;

      key_data = (GHOST_TEventKeyData *)GHOST_GetEventData(evt);
      switch (key_data->key) {
        case GHOST_kKeyA:
          if (val) {
            ps->noskip = !ps->noskip;
          }
          break;
        case GHOST_kKeyI:
          if (val) {
            ps->indicator = !ps->indicator;
          }
          break;
        case GHOST_kKeyP:
          if (val) {
            ps->pingpong = !ps->pingpong;
          }
          break;
        case GHOST_kKeyF: {
          if (val) {
            int axis = (g_WS.qual & WS_QUAL_SHIFT) ? 1 : 0;
            ps->draw_flip[axis] = !ps->draw_flip[axis];
          }
          break;
        }
        case GHOST_kKey1:
        case GHOST_kKeyNumpad1:
          if (val) {
            swaptime = ps->fstep / 60.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey2:
        case GHOST_kKeyNumpad2:
          if (val) {
            swaptime = ps->fstep / 50.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey3:
        case GHOST_kKeyNumpad3:
          if (val) {
            swaptime = ps->fstep / 30.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey4:
        case GHOST_kKeyNumpad4:
          if (g_WS.qual & WS_QUAL_SHIFT) {
            swaptime = ps->fstep / 24.0;
            update_sound_fps();
          }
          else {
            swaptime = ps->fstep / 25.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey5:
        case GHOST_kKeyNumpad5:
          if (val) {
            swaptime = ps->fstep / 20.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey6:
        case GHOST_kKeyNumpad6:
          if (val) {
            swaptime = ps->fstep / 15.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey7:
        case GHOST_kKeyNumpad7:
          if (val) {
            swaptime = ps->fstep / 12.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey8:
        case GHOST_kKeyNumpad8:
          if (val) {
            swaptime = ps->fstep / 10.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKey9:
        case GHOST_kKeyNumpad9:
          if (val) {
            swaptime = ps->fstep / 6.0;
            update_sound_fps();
          }
          break;
        case GHOST_kKeyLeftArrow:
          if (val) {
            ps->sstep = true;
            ps->wait2 = false;
            if (g_WS.qual & WS_QUAL_SHIFT) {
              ps->picture = picsbase.first;
              ps->next_frame = 0;
            }
            else {
              ps->next_frame = -1;
            }
          }
          break;
        case GHOST_kKeyDownArrow:
          if (val) {
            ps->wait2 = false;
            if (g_WS.qual & WS_QUAL_SHIFT) {
              ps->next_frame = ps->direction = -1;
            }
            else {
              ps->next_frame = -10;
              ps->sstep = true;
            }
          }
          break;
        case GHOST_kKeyRightArrow:
          if (val) {
            ps->sstep = true;
            ps->wait2 = false;
            if (g_WS.qual & WS_QUAL_SHIFT) {
              ps->picture = picsbase.last;
              ps->next_frame = 0;
            }
            else {
              ps->next_frame = 1;
            }
          }
          break;
        case GHOST_kKeyUpArrow:
          if (val) {
            ps->wait2 = false;
            if (g_WS.qual & WS_QUAL_SHIFT) {
              ps->next_frame = ps->direction = 1;
            }
            else {
              ps->next_frame = 10;
              ps->sstep = true;
            }
          }
          break;

        case GHOST_kKeySlash:
        case GHOST_kKeyNumpadSlash:
          if (val) {
            if (g_WS.qual & WS_QUAL_SHIFT) {
              if (ps->picture && ps->picture->ibuf) {
                printf(" Name: %s | Speed: %.2f frames/s\n",
                       ps->picture->ibuf->name,
                       ps->fstep / swaptime);
              }
            }
            else {
              swaptime = ps->fstep / 5.0;
              update_sound_fps();
            }
          }
          break;
        case GHOST_kKey0:
        case GHOST_kKeyNumpad0:
          if (val) {
            if (ps->once) {
              ps->once = ps->wait2 = false;
            }
            else {
              ps->picture = NULL;
              ps->once = true;
              ps->wait2 = false;
            }
          }
          break;

        case GHOST_kKeySpace:
          if (val) {
            if (ps->wait2 || ps->sstep) {
              ps->wait2 = ps->sstep = false;
#ifdef WITH_AUDASPACE
              {
                PlayAnimPict *picture = picsbase.first;
                /* TODO - store in ps direct? */
                int i = 0;

                while (picture && picture != ps->picture) {
                  i++;
                  picture = picture->next;
                }
                if (playback_handle) {
                  AUD_Handle_stop(playback_handle);
                }
                playback_handle = AUD_Device_play(audio_device, source, 1);
                if (playback_handle) {
                  AUD_Handle_setPosition(playback_handle, i / fps_movie);
                }
                update_sound_fps();
              }
#endif
            }
            else {
              ps->sstep = true;
              ps->wait2 = true;
#ifdef WITH_AUDASPACE
              if (playback_handle) {
                AUD_Handle_stop(playback_handle);
                playback_handle = NULL;
              }
#endif
            }
          }
          break;
        case GHOST_kKeyEnter:
        case GHOST_kKeyNumpadEnter:
          if (val) {
            ps->wait2 = ps->sstep = false;
#ifdef WITH_AUDASPACE
            {
              PlayAnimPict *picture = picsbase.first;
              /* TODO - store in ps direct? */
              int i = 0;
              while (picture && picture != ps->picture) {
                i++;
                picture = picture->next;
              }
              if (playback_handle) {
                AUD_Handle_stop(playback_handle);
              }
              playback_handle = AUD_Device_play(audio_device, source, 1);
              if (playback_handle) {
                AUD_Handle_setPosition(playback_handle, i / fps_movie);
              }
              update_sound_fps();
            }
#endif
          }
          break;
        case GHOST_kKeyPeriod:
        case GHOST_kKeyNumpadPeriod:
          if (val) {
            if (ps->sstep) {
              ps->wait2 = false;
            }
            else {
              ps->sstep = true;
              ps->wait2 = !ps->wait2;
#ifdef WITH_AUDASPACE
              if (playback_handle) {
                AUD_Handle_stop(playback_handle);
                playback_handle = NULL;
              }
#endif
            }
          }
          break;
        case GHOST_kKeyEqual:
        case GHOST_kKeyPlus:
        case GHOST_kKeyNumpadPlus: {
          if (val == 0) {
            break;
          }
          if (g_WS.qual & WS_QUAL_CTRL) {
            playanim_window_zoom(ps, 0.1f);
          }
          else {
            if (swaptime > ps->fstep / 60.0) {
              swaptime /= 1.1;
              update_sound_fps();
            }
          }
          break;
        }
        case GHOST_kKeyMinus:
        case GHOST_kKeyNumpadMinus: {
          if (val == 0) {
            break;
          }
          if (g_WS.qual & WS_QUAL_CTRL) {
            playanim_window_zoom(ps, -0.1f);
          }
          else {
            if (swaptime < ps->fstep / 5.0) {
              swaptime *= 1.1;
              update_sound_fps();
            }
          }
          break;
        }
        case GHOST_kKeyEsc:
          ps->go = false;
          break;
        default:
          break;
      }
      break;
    }
    case GHOST_kEventButtonDown:
    case GHOST_kEventButtonUp: {
      GHOST_TEventButtonData *bd = GHOST_GetEventData(evt);
      int cx, cy, sizex, sizey, inside_window;

      GHOST_GetCursorPosition(g_WS.ghost_system, &cx, &cy);
      GHOST_ScreenToClient(g_WS.ghost_window, cx, cy, &cx, &cy);
      playanim_window_get_size(&sizex, &sizey);

      inside_window = (cx >= 0 && cx < sizex && cy >= 0 && cy <= sizey);

      if (bd->button == GHOST_kButtonMaskLeft) {
        if (type == GHOST_kEventButtonDown) {
          if (inside_window) {
            g_WS.qual |= WS_QUAL_LMOUSE;
            tag_change_frame(ps, cx);
          }
        }
        else {
          g_WS.qual &= ~WS_QUAL_LMOUSE;
        }
      }
      else if (bd->button == GHOST_kButtonMaskMiddle) {
        if (type == GHOST_kEventButtonDown) {
          if (inside_window) {
            g_WS.qual |= WS_QUAL_MMOUSE;
          }
        }
        else {
          g_WS.qual &= ~WS_QUAL_MMOUSE;
        }
      }
      else if (bd->button == GHOST_kButtonMaskRight) {
        if (type == GHOST_kEventButtonDown) {
          if (inside_window) {
            g_WS.qual |= WS_QUAL_RMOUSE;
          }
        }
        else {
          g_WS.qual &= ~WS_QUAL_RMOUSE;
        }
      }
      break;
    }
    case GHOST_kEventCursorMove: {
      if (g_WS.qual & WS_QUAL_LMOUSE) {
        GHOST_TEventCursorData *cd = GHOST_GetEventData(evt);
        int cx, cy;

        /* Ignore 'in-between' events, since they can make scrubbing lag.
         *
         * Ideally we would keep into the event queue and see if this is the last motion event.
         * however the API currently doesn't support this. */
        {
          int x_test, y_test;
          GHOST_GetCursorPosition(g_WS.ghost_system, &x_test, &y_test);
          if (x_test != cd->x || y_test != cd->y) {
            /* we're not the last event... skipping */
            break;
          }
        }

        GHOST_ScreenToClient(g_WS.ghost_window, cd->x, cd->y, &cx, &cy);

        tag_change_frame(ps, cx);
      }
      break;
    }
    case GHOST_kEventWindowActivate:
    case GHOST_kEventWindowDeactivate: {
      g_WS.qual &= ~WS_QUAL_MOUSE;
      break;
    }
    case GHOST_kEventWindowSize:
    case GHOST_kEventWindowMove: {
      float zoomx, zoomy;

      playanim_window_get_size(&ps->win_x, &ps->win_y);
      GHOST_ActivateWindowDrawingContext(g_WS.ghost_window);

      zoomx = (float)ps->win_x / ps->ibufx;
      zoomy = (float)ps->win_y / ps->ibufy;

      /* zoom always show entire image */
      ps->zoom = MIN2(zoomx, zoomy);

      GPU_viewport(0, 0, ps->win_x, ps->win_y);
      GPU_scissor(0, 0, ps->win_x, ps->win_y);

      playanim_gl_matrix();

      ptottime = 0.0;
      playanim_toscreen(
          ps, ps->picture, ps->picture ? ps->picture->ibuf : NULL, ps->fontid, ps->fstep);

      break;
    }
    case GHOST_kEventQuitRequest:
    case GHOST_kEventWindowClose: {
      ps->go = false;
      break;
    }
    case GHOST_kEventDraggingDropDone: {
      GHOST_TEventDragnDropData *ddd = GHOST_GetEventData(evt);

      if (ddd->dataType == GHOST_kDragnDropTypeFilenames) {
        GHOST_TStringArray *stra = ddd->data;
        int a;

        for (a = 0; a < stra->count; a++) {
          BLI_strncpy(ps->dropped_file, (char *)stra->strings[a], sizeof(ps->dropped_file));
          ps->go = false;
          printf("drop file %s\n", stra->strings[a]);
          break; /* only one drop element supported now */
        }
      }
      break;
    }
    default:
      /* quiet warnings */
      break;
  }

  return 1;
}

static void playanim_window_open(const char *title, int posx, int posy, int sizex, int sizey)
{
  GHOST_GLSettings glsettings = {0};
  GHOST_TUns32 scr_w, scr_h;

  GHOST_GetMainDisplayDimensions(g_WS.ghost_system, &scr_w, &scr_h);

  posy = (scr_h - posy - sizey);

  g_WS.ghost_window = GHOST_CreateWindow(g_WS.ghost_system,
                                         NULL,
                                         title,
                                         posx,
                                         posy,
                                         sizex,
                                         sizey,
                                         /* could optionally start fullscreen */
                                         GHOST_kWindowStateNormal,
                                         false,
                                         GHOST_kDrawingContextTypeOpenGL,
                                         glsettings);
}

static void playanim_window_zoom(PlayState *ps, const float zoom_offset)
{
  int sizex, sizey;
  /* int ofsx, ofsy; */ /* UNUSED */

  if (ps->zoom + zoom_offset > 0.0f) {
    ps->zoom += zoom_offset;
  }

  // playanim_window_get_position(&ofsx, &ofsy);
  playanim_window_get_size(&sizex, &sizey);
  /* ofsx += sizex / 2; */ /* UNUSED */
  /* ofsy += sizey / 2; */ /* UNUSED */
  sizex = ps->zoom * ps->ibufx;
  sizey = ps->zoom * ps->ibufy;
  /* ofsx -= sizex / 2; */ /* UNUSED */
  /* ofsy -= sizey / 2; */ /* UNUSED */
  // window_set_position(g_WS.ghost_window, sizex, sizey);
  GHOST_SetClientSize(g_WS.ghost_window, sizex, sizey);
}

/**
 * \return The a path used to restart the animation player or NULL to exit.
 */
static char *wm_main_playanim_intern(int argc, const char **argv)
{
  struct ImBuf *ibuf = NULL;
  static char filepath[FILE_MAX]; /* abused to return dropped file path */
  GHOST_TUns32 maxwinx, maxwiny;
  int i;
  /* This was done to disambiguate the name for use under c++. */
  int start_x = 0, start_y = 0;
  int sfra = -1;
  int efra = -1;
  int totblock;

  PlayState ps = {0};

  ps.go = true;
  ps.direction = true;
  ps.next_frame = 1;
  ps.once = false;
  ps.pingpong = false;
  ps.noskip = false;
  ps.sstep = false;
  ps.wait2 = false;
  ps.stopped = false;
  ps.loading = false;
  ps.picture = NULL;
  ps.indicator = false;
  ps.dropped_file[0] = 0;
  ps.zoom = 1.0f;
  ps.draw_flip[0] = false;
  ps.draw_flip[1] = false;

  ps.fstep = 1;

  ps.fontid = -1;

  STRNCPY(ps.display_settings.display_device,
          IMB_colormanagement_role_colorspace_name_get(COLOR_ROLE_DEFAULT_BYTE));
  IMB_colormanagement_init_default_view_settings(&ps.view_settings, &ps.display_settings);

  /* Skip the first argument which is assumed to be '-a' (used to launch this player). */
  while (argc > 1) {
    if (argv[1][0] == '-') {
      switch (argv[1][1]) {
        case 'm':
          fromdisk = true;
          break;
        case 'p':
          if (argc > 3) {
            start_x = atoi(argv[2]);
            start_y = atoi(argv[3]);
            argc -= 2;
            argv += 2;
          }
          else {
            printf("too few arguments for -p (need 2): skipping\n");
          }
          break;
        case 'f':
          if (argc > 3) {
            double fps = atof(argv[2]);
            double fps_base = atof(argv[3]);
            if (fps == 0.0) {
              fps = 1;
              printf(
                  "invalid fps,"
                  "forcing 1\n");
            }
            swaptime = fps_base / fps;
            argc -= 2;
            argv += 2;
          }
          else {
            printf("too few arguments for -f (need 2): skipping\n");
          }
          break;
        case 's':
          sfra = atoi(argv[2]);
          CLAMP(sfra, 1, MAXFRAME);
          argc--;
          argv++;
          break;
        case 'e':
          efra = atoi(argv[2]);
          CLAMP(efra, 1, MAXFRAME);
          argc--;
          argv++;
          break;
        case 'j':
          ps.fstep = atoi(argv[2]);
          CLAMP(ps.fstep, 1, MAXFRAME);
          swaptime *= ps.fstep;
          argc--;
          argv++;
          break;
        case 'c': {
#ifdef USE_FRAME_CACHE_LIMIT
          const int memory_in_mb = max_ii(0, atoi(argv[2]));
          g_frame_cache.memory_limit = (size_t)memory_in_mb * (1024 * 1024);
#endif
          argc--;
          argv++;
          break;
        }
        default:
          printf("unknown option '%c': skipping\n", argv[1][1]);
          break;
      }
      argc--;
      argv++;
    }
    else {
      break;
    }
  }

  if (argc > 1) {
    BLI_strncpy(filepath, argv[1], sizeof(filepath));
  }
  else {
    printf("%s: no filepath argument given\n", __func__);
    exit(1);
  }

  if (IMB_isanim(filepath)) {
    /* OCIO_TODO: support different input color spaces */
    struct anim *anim;
    anim = IMB_open_anim(filepath, IB_rect, 0, NULL);
    if (anim) {
      ibuf = IMB_anim_absolute(anim, 0, IMB_TC_NONE, IMB_PROXY_NONE);
      IMB_close_anim(anim);
      anim = NULL;
    }
  }
  else if (!IMB_ispic(filepath)) {
    printf("%s: '%s' not an image file\n", __func__, filepath);
    exit(1);
  }

  if (ibuf == NULL) {
    /* OCIO_TODO: support different input color space */
    ibuf = IMB_loadiffname(filepath, IB_rect, NULL);
  }

  if (ibuf == NULL) {
    printf("%s: '%s' couldn't open\n", __func__, filepath);
    exit(1);
  }

  {

    GHOST_EventConsumerHandle consumer = GHOST_CreateEventConsumer(ghost_event_proc, &ps);

    g_WS.ghost_system = GHOST_CreateSystem();
    GHOST_AddEventConsumer(g_WS.ghost_system, consumer);

    playanim_window_open("Blender Animation Player", start_x, start_y, ibuf->x, ibuf->y);
  }

  GHOST_GetMainDisplayDimensions(g_WS.ghost_system, &maxwinx, &maxwiny);

  // GHOST_ActivateWindowDrawingContext(g_WS.ghost_window);

  /* initialize OpenGL immediate mode */
  g_WS.gpu_context = GPU_context_create(g_WS.ghost_window);
  GPU_init();

  /* initialize the font */
  BLF_init();
  ps.fontid = BLF_load_mono_default(false);
  BLF_size(ps.fontid, 11, 72);

  ps.ibufx = ibuf->x;
  ps.ibufy = ibuf->y;

  ps.win_x = ps.ibufx;
  ps.win_y = ps.ibufy;

  if (maxwinx % ibuf->x) {
    maxwinx = ibuf->x * (1 + (maxwinx / ibuf->x));
  }
  if (maxwiny % ibuf->y) {
    maxwiny = ibuf->y * (1 + (maxwiny / ibuf->y));
  }

  GPU_clear_color(0.1f, 0.1f, 0.1f, 0.0f);

  int win_x, win_y;
  playanim_window_get_size(&win_x, &win_y);
  GPU_viewport(0, 0, win_x, win_y);
  GPU_scissor(0, 0, win_x, win_y);
  playanim_gl_matrix();

  GHOST_SwapWindowBuffers(g_WS.ghost_window);

  if (sfra == -1 || efra == -1) {
    /* one of the frames was invalid, just use all images */
    sfra = 1;
    efra = MAXFRAME;
  }

  build_pict_list(&ps, filepath, (efra - sfra) + 1, ps.fstep, ps.fontid);

#ifdef WITH_AUDASPACE
  source = AUD_Sound_file(filepath);
  {
    struct anim *anim_movie = ((struct PlayAnimPict *)picsbase.first)->anim;
    if (anim_movie) {
      short frs_sec = 25;
      float frs_sec_base = 1.0;

      IMB_anim_get_fps(anim_movie, &frs_sec, &frs_sec_base, true);

      fps_movie = (double)frs_sec / (double)frs_sec_base;
      /* enforce same fps for movie as sound */
      swaptime = ps.fstep / fps_movie;
    }
  }
#endif

  for (i = 2; i < argc; i++) {
    BLI_strncpy(filepath, argv[i], sizeof(filepath));
    build_pict_list(&ps, filepath, (efra - sfra) + 1, ps.fstep, ps.fontid);
  }

  IMB_freeImBuf(ibuf);
  ibuf = NULL;

  pupdate_time();
  ptottime = 0;

  /* newly added in 2.6x, without this images never get freed */
#define USE_IMB_CACHE

  while (ps.go) {
    if (ps.pingpong) {
      ps.direction = -ps.direction;
    }

    if (ps.direction == 1) {
      ps.picture = picsbase.first;
    }
    else {
      ps.picture = picsbase.last;
    }

    if (ps.picture == NULL) {
      printf("couldn't find pictures\n");
      ps.go = false;
    }
    if (ps.pingpong) {
      if (ps.direction == 1) {
        ps.picture = ps.picture->next;
      }
      else {
        ps.picture = ps.picture->prev;
      }
    }
    if (ptottime > 0.0) {
      ptottime = 0.0;
    }

#ifdef WITH_AUDASPACE
    if (playback_handle) {
      AUD_Handle_stop(playback_handle);
    }
    playback_handle = AUD_Device_play(audio_device, source, 1);
    update_sound_fps();
#endif

    while (ps.picture) {
      bool has_event;
#ifndef USE_IMB_CACHE
      if (ibuf != NULL && ibuf->ftype == IMB_FTYPE_NONE) {
        IMB_freeImBuf(ibuf);
      }
#endif

      ibuf = ibuf_from_picture(ps.picture);

      if (ibuf) {
#ifdef USE_IMB_CACHE
        ps.picture->ibuf = ibuf;
#endif

#ifdef USE_FRAME_CACHE_LIMIT
        if (ps.picture->frame_cache_node == NULL) {
          frame_cache_add(ps.picture);
        }
        else {
          frame_cache_touch(ps.picture);
        }
        frame_cache_limit_apply(ibuf);

#endif /* USE_FRAME_CACHE_LIMIT */

        BLI_strncpy(ibuf->name, ps.picture->name, sizeof(ibuf->name));

        /* why only windows? (from 2.4x) - campbell */
#ifdef _WIN32
        GHOST_SetTitle(g_WS.ghost_window, ps.picture->name);
#endif

        while (pupdate_time()) {
          PIL_sleep_ms(1);
        }
        ptottime -= swaptime;
        playanim_toscreen(&ps, ps.picture, ibuf, ps.fontid, ps.fstep);
      } /* else delete */
      else {
        printf("error: can't play this image type\n");
        exit(0);
      }

      if (ps.once) {
        if (ps.picture->next == NULL) {
          ps.wait2 = true;
        }
        else if (ps.picture->prev == NULL) {
          ps.wait2 = true;
        }
      }

      ps.next_frame = ps.direction;

      while ((has_event = GHOST_ProcessEvents(g_WS.ghost_system, false))) {
        GHOST_DispatchEvents(g_WS.ghost_system);
      }
      if (ps.go == false) {
        break;
      }
      change_frame(&ps);
      if (!has_event) {
        PIL_sleep_ms(1);
      }
      if (ps.wait2) {
        continue;
      }

      ps.wait2 = ps.sstep;

      if (ps.wait2 == false && ps.stopped) {
        ps.stopped = false;
      }

      pupdate_time();

      if (ps.picture && ps.next_frame) {
        /* Advance to the next frame, always at least set one step.
         * Implement frame-skipping when enabled and playback is not fast enough. */
        while (ps.picture) {
          ps.picture = playanim_step(ps.picture, ps.next_frame);

          if (ps.once && ps.picture != NULL) {
            if (ps.picture->next == NULL) {
              ps.wait2 = true;
            }
            else if (ps.picture->prev == NULL) {
              ps.wait2 = true;
            }
          }

          if (ps.wait2 || ptottime < swaptime || ps.noskip) {
            break;
          }
          ptottime -= swaptime;
        }
        if (ps.picture == NULL && ps.sstep) {
          ps.picture = playanim_step(ps.picture, ps.next_frame);
        }
      }
      if (ps.go == false) {
        break;
      }
    }
  }
  while ((ps.picture = BLI_pophead(&picsbase))) {
    if (ps.picture->anim) {
      if ((ps.picture->next == NULL) || (ps.picture->next->anim != ps.picture->anim)) {
        IMB_close_anim(ps.picture->anim);
      }
    }

    if (ps.picture->ibuf) {
      IMB_freeImBuf(ps.picture->ibuf);
    }
    if (ps.picture->mem) {
      MEM_freeN(ps.picture->mem);
    }

    MEM_freeN((void *)ps.picture->name);
    MEM_freeN(ps.picture);
  }

  /* cleanup */
#ifndef USE_IMB_CACHE
  if (ibuf) {
    IMB_freeImBuf(ibuf);
  }
#endif

  BLI_freelistN(&picsbase);

#ifdef USE_FRAME_CACHE_LIMIT
  BLI_freelistN(&g_frame_cache.pics);
  g_frame_cache.pics_len = 0;
  g_frame_cache.pics_size_in_memory = 0;
#endif

#ifdef WITH_AUDASPACE
  if (playback_handle) {
    AUD_Handle_stop(playback_handle);
    playback_handle = NULL;
  }
  if (scrub_handle) {
    AUD_Handle_stop(scrub_handle);
    scrub_handle = NULL;
  }
  AUD_Sound_free(source);
  source = NULL;
#endif
  /* we still miss freeing a lot!,
   * but many areas could skip initialization too for anim play */

  GPU_shader_free_builtin_shaders();

  if (g_WS.gpu_context) {
    GPU_context_active_set(g_WS.gpu_context);
    GPU_context_discard(g_WS.gpu_context);
    g_WS.gpu_context = NULL;
  }

  BLF_exit();

  GPU_exit();

  GHOST_DisposeWindow(g_WS.ghost_system, g_WS.ghost_window);

  /* early exit, IMB and BKE should be exited only in end */
  if (ps.dropped_file[0]) {
    BLI_strncpy(filepath, ps.dropped_file, sizeof(filepath));
    return filepath;
  }

  IMB_exit();
  BKE_images_exit();
  DEG_free_node_types();

  totblock = MEM_get_memory_blocks_in_use();
  if (totblock != 0) {
    /* prints many bAKey, bArgument's which are tricky to fix */
#if 0
    printf("Error Totblock: %d\n", totblock);
    MEM_printmemlist();
#endif
  }

  return NULL;
}

void WM_main_playanim(int argc, const char **argv)
{
  const char *argv_next[2];
  bool looping = true;

#ifdef WITH_AUDASPACE
  {
    AUD_DeviceSpecs specs;

    specs.rate = AUD_RATE_48000;
    specs.format = AUD_FORMAT_S16;
    specs.channels = AUD_CHANNELS_STEREO;

    AUD_initOnce();

    if (!(audio_device = AUD_init(NULL, specs, 1024, "Blender"))) {
      audio_device = AUD_init("None", specs, 0, "Blender");
    }
  }
#endif

  while (looping) {
    const char *filepath = wm_main_playanim_intern(argc, argv);

    if (filepath) { /* use simple args */
      argv_next[0] = argv[0];
      argv_next[1] = filepath;
      argc = 2;

      /* continue with new args */
      argv = argv_next;
    }
    else {
      looping = false;
    }
  }

#ifdef WITH_AUDASPACE
  AUD_exit(audio_device);
  AUD_exitOnce();
#endif
}