Public API Reference

csplugincommon/imageloader/commonimagefile.h

Go to the documentation of this file.

/*
    Copyright (C) 2005 by Jorrit Tyberghein
                  2005 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSPLUGINCOMMON_IMAGELOADER_COMMONIMAGEFILE_H__
#define __CS_CSPLUGINCOMMON_IMAGELOADER_COMMONIMAGEFILE_H__

#include "csextern.h"
#include "csgfx/imagememory.h"
#include "csutil/ref.h"
#include "csutil/scf_interface.h"
#include "csutil/scf_implementation.h"
#include "iutil/databuff.h"
#include "iutil/job.h"

struct iObjectRegistry;

enum csLoaderDataType
{
  rdtInvalid,
  rdtR8G8B8,
  rdtRGBpixel,
  rdtIndexed
};

class csCommonImageFile;

struct iImageFileLoader : public virtual iBase
{
  SCF_INTERFACE(iImageFileLoader, 2,0,0);
  virtual bool LoadData () = 0;
  virtual csRef<iDataBuffer> GetRawData() = 0;
  virtual csLoaderDataType GetDataType() = 0;
  virtual int GetWidth() = 0;
  virtual int GetHeight() = 0;
  virtual int GetFormat() = 0;
  virtual void ApplyTo (csImageMemory* image) = 0;
  virtual bool HasKeyColor() const = 0;
  virtual void GetKeyColor (int &r, int &g, int &b) const = 0;
};

class CS_CRYSTALSPACE_EXPORT csCommonImageFileLoader : 
  public scfImplementation1<csCommonImageFileLoader, iImageFileLoader>
{
protected:
  int Format;
  csRef<iDataBuffer> rawData;
  csLoaderDataType dataType;
  csRGBpixel* rgbaData;
  uint8* indexData;
  csRGBpixel* palette;
  size_t paletteCount;
  uint8* alpha;
  bool hasKeycolor;
  csRGBcolor keycolor;
  int Width, Height;
public:
  csCommonImageFileLoader (int format);
  virtual ~csCommonImageFileLoader();

  virtual csRef<iDataBuffer> GetRawData() 
  { return rawData; }
  virtual csLoaderDataType GetDataType() 
  { return dataType; }
  virtual int GetWidth() { return Width; }
  virtual int GetHeight() { return Height; }
  virtual int GetFormat() { return Format; }
  virtual void ApplyTo (csImageMemory* image);
  virtual bool HasKeyColor() const { return hasKeycolor; }
  virtual void GetKeyColor (int &r, int &g, int &b) const
  { 
    r = keycolor.red; g = keycolor.green; b = keycolor.blue; 
  }
};

#define THREADED_LOADING

class CS_CRYSTALSPACE_EXPORT csCommonImageFile : 
  public scfImplementationExt0<csCommonImageFile, csImageMemory>
{
protected:
  friend class csCommonImageFileLoader;
  
  class CS_CRYSTALSPACE_EXPORT LoaderJob : 
    public scfImplementation1<LoaderJob, iJob>
  {
  public:
    csRef<iImageFileLoader> currentLoader;
    bool loadResult;
    LoaderJob (iImageFileLoader* loader);
    virtual ~LoaderJob();

    virtual void Run();
  };

#ifdef THREADED_LOADING
  csRef<LoaderJob> loadJob;
  csRef<iJobQueue> jobQueue;
#else
  csRef<iImageFileLoader> currentLoader;
#endif
  iObjectRegistry* object_reg;

  csCommonImageFile (iObjectRegistry* object_reg, int format);
  virtual ~csCommonImageFile();

  virtual bool Load (csRef<iDataBuffer> source);
  virtual csRef<iImageFileLoader> InitLoader (csRef<iDataBuffer> source) = 0;

  void WaitForJob() const;
  void MakeImageData();

  virtual const void *GetImageData ();
  virtual const csRGBpixel* GetPalette ();
  virtual const uint8* GetAlpha ();

  virtual bool HasKeyColor () const 
  { 
#ifdef THREADED_LOADING
    if (loadJob)
    {
      return loadJob->currentLoader->HasKeyColor();
    }
#endif
    return has_keycolour; 
  }

  virtual void GetKeyColor (int &r, int &g, int &b) const
  { 
#ifdef THREADED_LOADING
    if (loadJob)
    {
      // Keycolor may only be available after loading...
      WaitForJob();
      loadJob->currentLoader->GetKeyColor (r, g, b);
      return;
    }
#endif
    r = keycolour.red; g = keycolour.green; b = keycolour.blue; 
  }

  static const char* DataTypeString (csLoaderDataType dataType);
  virtual const char* GetRawFormat() const;
  virtual csRef<iDataBuffer> GetRawData() const;
};

#endif // __CS_CSPLUGINCOMMON_IMAGELOADER_COMMONIMAGEFILE_H__

---