TIL/TIL_ImageCache.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Alexander
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        TIL_ImageCache.h (IMGUI library, C++)
 *
 * COMMENTS:
 *      Manages a cache of TIL_Raster images for viewing.
 */
#ifndef TIL_IMAGE_CACHE_H
#define TIL_IMAGE_CACHE_H

#include "TIL_API.h"
#include <iostream.h>
#include <UT/UT_Cache.h>
#include <UT/UT_FilterType.h>

#include "TIL_Defines.h"

class TIL_Image;
class TIL_ImageState;
class TIL_SoftwareEmulState;
class TIL_Look;
class TIL_ImageSource;
class TIL_Raster;

enum TIL_AlphaOption {
    TIL_NO_ALPHA,
    TIL_USE_ALPHA,
    TIL_SOLID_ALPHA
};


class TIL_API TIL_ImageCache : public UT_Cache
{
public:
                         TIL_ImageCache();
                        ~TIL_ImageCache();

    void                 setCacheLimit(bool enable);
    void                 setCacheSize(unsigned size_in_kb);

    int64                getCurrentSize() const { return mySize; }
    int64                getMaxSize() const { return myMaxSize; }

    static int64         getSystemMaxSize();

    void                 addToCache(TIL_Image *image);
    void                 returnToCache(TIL_Image *&image);
    void                 returnToCache(const TIL_Raster *r);
    
    void                 removeSourceFromCache(TIL_ImageSource *source);
    void                 removeFrameFromCache(TIL_ImageSource *source, int fr);

    // the tokenstring, frame index and node path should be filled in.
    // returns 1 and fills in the raster if found (0 otherwise). 
    TIL_Image   *        getImageFromCache(TIL_ImageState *match,
                                           bool usedscaled = false,
                                           UT_FilterType f = UT_FILTER_BOX,
                                           bool bump = true);

    // Do not set force_all to true unless calling in a UT_Exit callback.
    void                 clearImageCache(bool force_all = false);

    int                  getImage(TIL_Image        *&image,
                                  TIL_ImageSource *source,
                                  const char        *plane,
                                  int                planeindex,
                                  float              t,
                                  void              *look,
                                  bool               updateflag,
                                  float zoom = 1.0F, float izoom = 1.0f,
                                  float u1 =0.0F, float v1=0.0F,
                                  float u2 =1.0F, float v2=1.0F,
                                  bool scaled = false,
                                  TIL_AlphaOption alpha = TIL_NO_ALPHA,
                                  bool onlyifcached = false,
                                  bool override_res = false,
                                  int overx = -1, int overy = -1,
                                  TIL_DataFormat data = TILE_MAX_DATA_FORMAT,
                                  bool apply_software_emul = true,
                                  bool halffloatsupport = true,
                                  bool useaspectratio = true);

    static void          setUpdateCallback(void (*callback)(void *,
                                                            TIL_Raster *,
                                                            int,int,
                                                            float,float));

    void                 dumpCache(ostream &os);
    
    void                 setEmulation(bool hardaccel,
                                      float black,
                                      float white,
                                      float scale,
                                      float shift,
                                      int component,
                                      bool hardlut,
                                      const char *lut,
                                      float gamma,
                                      bool fastaspect,
                                      float aspect,
                                      bool use8bit);

    virtual int64       utReduceCacheSizeBy(int64 amount);
protected:
    // the UT_Cache interface
    virtual const char *utGetCacheName() const { return "COP Flipbook Cache"; }
    virtual int64       utGetCurrentSize() { return getCurrentSize(); }
    virtual bool        utHasMaxSize() const { return true; }
    virtual int64       utGetMaxSize() { return getMaxSize()*1024; }
    virtual void        utSetMaxSize(int64 size); 

private:
    int                  fetchImage(TIL_Image      *&image,
                                    TIL_ImageState *state,
                                    float           t,
                                    void           *look,
                                    bool            updateflag,
                                    bool            scaled,
                                    bool            include_alpha,
                                    bool            interactive,
                                    int             fxres,
                                    int             fyres,
                                    bool            onlyifcached,
                                    bool            use_software_emul,
                                    bool            halffloatsupport);
    
    void                 applySoftwareEmulation(TIL_Image *&image);
    void                 removeAllOldEmulations();
    void                 removeObsoleteEmulation(TIL_Image *image);

    void                 removeReference(TIL_Image *&image);
    bool                 removeImage(TIL_Image *image);
    
    void                 pruneCache();

    void                 pruneAnyObsoleteImages();
    void                 unlinkImage(TIL_Image *image);

    void                 lockCache(bool lock = true);
    
    TIL_Image           *myHead;
    TIL_Image           *myTail;
    int64                mySize;
    int64                myMaxSize;
    int                  myNumImages;
    int                  myNumObsolete;
    TIL_SoftwareEmulState *myEmulation;
    unsigned             myCacheLimit : 1,
                         my8BitEmulOnly :1,
                         myKeepOriginal :1;
    TIL_FastLock         myLock;
};

TIL_API TIL_ImageCache *TILgetCache();

#endif

---