This file is indexed.

/usr/include/Nux-4.0/NuxGraphics/ImageSurface.h is in libnux-4.0-dev 4.0.8+17.10.20170922-0ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
/*
 * Copyright 2010 Inalogic® Inc.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, as
 * published by the  Free Software Foundation; either version 2.1 or 3.0
 * of the License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
 * PURPOSE.  See the applicable version of the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of both the GNU Lesser General Public
 * License along with this program. If not, see <http://www.gnu.org/licenses/>
 *
 * Authored by: Jay Taoko <jaytaoko@inalogic.com>
 *
 */


#ifndef IMAGESURFACE_H
#define IMAGESURFACE_H

#include "BitmapFormats.h"
#include "NuxCore/Math/MathUtility.h"

#include <gdk-pixbuf/gdk-pixbuf.h>

#define DEBUG_ENTER(a)
#define DEBUG_WARNING(a)
#define DEBUG_EXIT(a)

namespace nux
{

  class RawData
  {
  public:
    RawData() {};
    ~RawData() {};

    //! Get number of elements.
    unsigned int GetElementCount()
    {
      return 0;
    }

    //! Get the number of bytes per elements.
    unsigned int GetElementSize()
    {
      return 0;
    }

    void GetSize() {};
  };

  struct DXTColBlock
  {
    unsigned short col0;
    unsigned short col1;

    unsigned char row[4];
  };

  struct DXT3AlphaBlock
  {
    unsigned short row[4];
  };

  struct DXT5AlphaBlock
  {
    unsigned char alpha0;
    unsigned char alpha1;

    unsigned char row[6];
  };

//! Image Surface class
  /*!
      Represent and image surface inside a complex data structure such as a 2D texture, Volume texture or Cube map.
  */
  class ImageSurface
  {
  public:
    ImageSurface();
    ImageSurface(BitmapFormat format, unsigned int width, unsigned int height);
    ImageSurface(const ImageSurface &);
    ImageSurface(ImageSurface&&);
    ImageSurface &operator = (ImageSurface);

    bool IsNull() const;
    int GetWidth() const
    {
      return width_;
    }
    int GetHeight() const
    {
      return height_;
    }
    void Allocate(BitmapFormat format, int width, int height);
    void Write32b(int i, int j, unsigned int value);
    void Write24b(int i, int j, unsigned int value);
    void Write16b(int i, int j, unsigned short value);
    void Write8b(int i, int j, unsigned char value);
    void Write(int i, int j, unsigned char r, unsigned char g, unsigned char b, unsigned char a);
    //! Read an element of the surface.
    /*!
        Return a 32 bits value representing the image element at coordinates(i, j).
        For the RGBA format, the LSB of the returned value represent the read value, and the MSB represents the alpha value.
        | LSB: Red | Green | Blue | MSB: Alpha|
        @return The image element at coordinates(i, j).
    */
    unsigned int Read(int i, int j);
    //! Set all surface elements to 0.
    void Clear();
    //! Flip the surface horizontally.
    void FlipHorizontal();
    //! Flip the surface vertically.
    void FlipVertical();
    //! Returns the surface pitch.
    int GetPitch() const;
    int GetBlockHeight() const;
    int GetAlignment() const;
    int GetSize() const;
    BitmapFormat GetFormat() const;
    const unsigned char *GetPtrRawData() const;
    unsigned char *GetPtrRawData();

    static int GetLevelPitch(BitmapFormat format, int width, int height, int miplevel);
    static int GetLevelPitchNoMemAlignment(BitmapFormat format, int width, int height, int miplevel);
    static int GetLevelSize(BitmapFormat format, int width, int height, int miplevel);
    static int GetLevelSize(BitmapFormat format, int width, int height, int depth, int miplevel);
    static int GetLevelWidth(BitmapFormat format, int width, int miplevel);
    static int GetLevelHeight(BitmapFormat format, int height, int miplevel);
    static int GetLevelDim(BitmapFormat format, int length, int miplevel);
    static int GetNumMipLevel(BitmapFormat format, int width, int height);
    static int GetMemAlignment(BitmapFormat format);
    static int GetLevelBlockWidth(BitmapFormat format, int width, int miplevel);
    static int GetLevelBlockHeight(BitmapFormat format, int height, int miplevel); // for DXT

    // Image Processing
    //! Compute the average color of the image surface.
    /*!
        Sum up all the image elements and divide by the number of elements.
        @return The average color of the image.
    */
    Color AverageColor();

  private:
    void FlipDXTVertical();
    void SwapBlocks(void *byte1, void *byte2, int size);
    void FlipBlocksDXT1(DXTColBlock *line, int numBlocks);
    void FlipBlocksDXT3(DXTColBlock *line, int numBlocks);
    void FlipBlocksDXT5(DXTColBlock *line, int numBlocks);
    void FlipDXT5Alpha(DXT5AlphaBlock *block);
    friend void swap(ImageSurface&, ImageSurface&);

    int width_;           //!< Image width
    int height_;          //!< Image height.
    BitmapFormat format_;   //!< Image format.
    int m_Pitch;          //!< Image pitch.
    int bpe_;             //!< Number of byte per element.
    int Alignment_;       //!< Data alignment.
    std::vector<unsigned char> RawData_;
  };

  void swap(ImageSurface&, ImageSurface&);


  class NBitmapData
  {
  public:
    NBitmapData();
    virtual ~NBitmapData();

    virtual const ImageSurface &GetSurface(int MipLevel) const = 0;
    virtual ImageSurface &GetSurface(int MipLevel) = 0;
    virtual const ImageSurface &GetSurface(int face, int MipLevel) const = 0;
    virtual ImageSurface &GetSurface(int face, int MipLevel) = 0;

    virtual bool IsTextureData() const
    {
      return false;
    };
    virtual bool IsCubemapTextureData() const
    {
      return false;
    }
    virtual bool IsVolumeTextureData() const
    {
      return false;
    }
    virtual bool IsAnimatedTextureData() const
    {
      return false;
    }

    virtual int GetNumMipmap() const = 0;
    virtual int GetWidth() const = 0;
    virtual int GetHeight() const = 0;
    virtual int GetDepth() const
    {
      return 0;
    }
    virtual BitmapFormat GetFormat() const = 0;
    virtual bool IsNull() const = 0;
    virtual int GetMemorySize() const
    {
      return m_TotalMemorySize;
    }

  protected:
    unsigned int m_TotalMemorySize;
//protected:
//    unsigned int m_Width;
//    unsigned int m_Height;
//    BitmapFormat m_Format;
  };

  class NTextureData: public NBitmapData
  {
  public:
    NTextureData(BitmapFormat f = BITFMT_R8G8B8A8, int width = 16, int height = 16, int NumMipmap = 1);
    virtual ~NTextureData() {}
    //! Copy constructor.
    NTextureData(const NTextureData &);
    //! Assignment constructor.
    NTextureData &operator = (NTextureData);
    //! Move constructor
    NTextureData(NTextureData&&);

    virtual void Allocate(BitmapFormat f, int width, int height, int NumMipmap = 1);
    virtual void AllocateCheckBoardTexture(int width, int height, int NumMipmap, Color color0, Color color1, int TileWidth = 4, int TileHeight = 4);
    virtual void AllocateColorTexture(int width, int height, int NumMipmap, Color color0 = Color(0xFFFFFFF));

    virtual const ImageSurface &GetSurface(int MipLevel) const
    {
      return m_MipSurfaceArray[MipLevel];
    };
    virtual ImageSurface &GetSurface(int MipLevel)
    {
      return const_cast<ImageSurface &> ((const_cast< const NTextureData * > (this))->GetSurface(MipLevel));
    }
    virtual const ImageSurface &GetSurface(int /* face */, int MipLevel) const
    {
      //nuxAssertMsg(0, "[NTextureData::GetSurface] Use GetSurface(unsigned int MipLevel) for NTextureData.");
      return GetSurface(MipLevel);
    }
    virtual ImageSurface &GetSurface(int /* face */, int MipLevel)
    {
      //nuxAssertMsg(0, "[NTextureData::GetSurface] Use GetSurface(unsigned int MipLevel) for NTextureData.");
      return GetSurface(MipLevel);
    }

    bool SetSurface(int MipLevel, const ImageSurface &object);

    virtual bool IsTextureData() const
    {
      return true;
    }

    virtual int GetNumMipmap() const;
    virtual int GetWidth() const
    {
      return m_MipSurfaceArray[0].GetWidth();
    }
    virtual int GetHeight() const
    {
      return m_MipSurfaceArray[0].GetHeight();
    }
    virtual BitmapFormat GetFormat() const
    {
      return m_MipSurfaceArray[0].GetFormat();
    }
    virtual bool IsNull() const
    {
      return m_MipSurfaceArray[0].IsNull();
    }

  private:
    void swap(NTextureData& other);

    int m_NumMipmap;
    std::vector<ImageSurface> m_MipSurfaceArray;

#if defined(NUX_OS_WINDOWS)
    friend NBitmapData *read_tga_file(const TCHAR *file_name);
#endif
  };

  class NCubemapData: public NBitmapData
  {
  public:
    NCubemapData(BitmapFormat f = BITFMT_R8G8B8A8, int width = 16, int height = 16, int NumMipmap = 1);
    virtual ~NCubemapData();
    //! Copy constructor
    NCubemapData(const NCubemapData &);
    //! Assignment constructor
    NCubemapData &operator = (const NCubemapData &);

    virtual void Allocate(BitmapFormat f, int width, int height, int NumMipmap = 1);
    virtual void AllocateCheckBoardTexture(int width, int height, int NumMipmap, Color color0, Color color1, int TileWidth = 4, int TileHeight = 4);
    virtual void AllocateColorTexture(int width, int height, int NumMipmap, Color color0 = Color(0xFFFFFFF));

    virtual const ImageSurface &GetSurface(int face, int MipLevel) const
    {
      return *m_MipSurfaceArray[face][MipLevel];
    };
    virtual ImageSurface &GetSurface(int face, int MipLevel)
    {
      return const_cast<ImageSurface &> ((const_cast< const NCubemapData * > (this))->GetSurface(face, MipLevel));
    }
    virtual const ImageSurface &GetSurface(int MipLevel) const
    {
      nuxAssertMsg(0, "[NCubemapData::GetSurface] Use GetSurface(unsigned int face, unsigned int MipLevel) for NCubemapData.");
      return GetSurface(0, MipLevel);
    }
    virtual ImageSurface &GetSurface(int MipLevel)
    {
      nuxAssertMsg(0, "[NCubemapData::GetSurface] Use GetSurface(unsigned int face, unsigned int MipLevel) for NCubemapData.");
      return GetSurface(0, MipLevel);
    }
    bool SetSurface(int face, int MipLevel, const ImageSurface &object);

    virtual bool IsCubemapTextureData() const
    {
      return true;
    }

    virtual int GetNumMipmap() const;
    virtual int GetWidth() const
    {
      return m_MipSurfaceArray[0][0]->GetWidth();
    }
    virtual int GetHeight() const
    {
      return m_MipSurfaceArray[0][0]->GetHeight();
    }
    virtual BitmapFormat GetFormat() const
    {
      return m_MipSurfaceArray[0][0]->GetFormat();
    }
    virtual bool IsNull() const
    {
      return m_MipSurfaceArray[0][0]->IsNull();
    }

  private:
    void ClearData();
    int m_NumMipmap;
    std::vector<ImageSurface *> m_MipSurfaceArray[6];
  };

  class NVolumeData: public NBitmapData
  {
  public:
    NVolumeData(BitmapFormat f = BITFMT_R8G8B8A8, int width = 16, int height = 16, int slice = 1, int NumMipmap = 1);
    virtual ~NVolumeData();
    //! Copy constructor
    NVolumeData(const NVolumeData &);
    //! Assignment constructor
    NVolumeData &operator = (const NVolumeData &);

    virtual void Allocate(BitmapFormat f, int width, int height, int slice, int NumMipmap = 1);
    virtual void AllocateCheckBoardTexture(int width, int height, int slice, int NumMipmap, Color color0, Color color1, int TileWidth = 4, int TileHeight = 4);
    virtual void AllocateColorTexture(int width, int height, int slice, int NumMipmap, Color color0 = Color(0xFFFFFFF));

    virtual const ImageSurface &GetSurface(int slice, int MipLevel) const
    {
      return *m_MipSurfaceArray[MipLevel][slice];
    };
    virtual ImageSurface &GetSurface(int slice, int MipLevel)
    {
      return const_cast<ImageSurface &> ((const_cast< const NVolumeData * > (this))->GetSurface(slice, MipLevel));
    }
    virtual const ImageSurface &GetSurface(int MipLevel) const
    {
      nuxAssertMsg(0, "[NVolumeData::GetSurface] Use GetSurface(unsigned int MipLevel, unsigned int MipLevel) for NVolumeData.");
      return GetSurface(MipLevel, 0);
    }
    virtual ImageSurface &GetSurface(int MipLevel)
    {
      nuxAssertMsg(0, "[NVolumeData::GetSurface] Use GetSurface(unsigned int MipLevel, unsigned int MipLevel) for NVolumeData.");
      return GetSurface(MipLevel, 0);
    }
    bool SetSurface(int face, int MipLevel, const ImageSurface &object);

    virtual bool IsVolumeTextureData() const
    {
      return true;
    }

    int GetNumMipmap() const;
    virtual int GetWidth() const
    {
      return m_MipSurfaceArray[0][0]->GetWidth();
    }
    virtual int GetHeight() const
    {
      return m_MipSurfaceArray[0][0]->GetHeight();
    }
    virtual int GetDepth() const
    {
      return m_Depth;
    }
    virtual BitmapFormat GetFormat() const
    {
      return m_MipSurfaceArray[0][0]->GetFormat();
    }
    virtual bool IsNull() const
    {
      return m_MipSurfaceArray[0][0]->IsNull();
    }

  private:
    void ClearData();
    int m_NumMipmap;
    int m_Depth;
    std::vector<ImageSurface *> *m_MipSurfaceArray;
  };

  class NAnimatedTextureData: public NBitmapData
  {
  public:
    NAnimatedTextureData(BitmapFormat f = BITFMT_R8G8B8A8, int width = 16, int height = 16, int slice = 1 /*, unsigned int NumMipmap = 1*/);
    virtual ~NAnimatedTextureData();
    //! Copy constructor
    NAnimatedTextureData(const NAnimatedTextureData &);
    //! Assignment constructor
    NAnimatedTextureData &operator = (const NAnimatedTextureData &);

    virtual void Allocate(BitmapFormat f, int width, int height, int slice, int NumMipmap = 1);
    virtual void AllocateCheckBoardTexture(int width, int height, int slice, int NumMipmap, Color color0, Color color1, int TileWidth = 4, int TileHeight = 4);
    virtual void AllocateColorTexture(int width, int height, int slice, int NumMipmap, Color color0 = Color(0xFFFFFFF));

    virtual const ImageSurface &GetSurface(int /* MipLevel */, int /* slice */) const
    {
      nuxAssertMsg(0, "[NAnimatedTextureData::GetSurface] Use GetSurface(unsigned int Frame) for NAnimatedTextureData.");
      return GetSurface(0);
    }
    virtual ImageSurface &GetSurface(int /* MipLevel */, int /* slice */)
    {
      nuxAssertMsg(0, "[NAnimatedTextureData::GetSurface] Use GetSurface(unsigned int Frame) for NAnimatedTextureData.");
      return GetSurface(0);
    }
    virtual const ImageSurface &GetSurface(int Frame) const
    {
      nuxAssert(Frame >= 0);
      nuxAssert(Frame < m_Depth);
      return *m_MipSurfaceArray[0][Frame];
    }
    virtual ImageSurface &GetSurface(int Frame)
    {
      nuxAssert(Frame >= 0);
      nuxAssert(Frame < m_Depth);
      return const_cast<ImageSurface &> ((const_cast< const NAnimatedTextureData * > (this))->GetSurface(Frame));
    }

    bool SetSurface(int face, int MipLevel, const ImageSurface &object);

    virtual bool IsAnimatedTextureData() const
    {
      return true;
    }

    int GetFrameTime(int Frame) const
    {
      nuxAssert(Frame >= 0);
      nuxAssert(Frame < m_Depth);
      return m_FrameTimeArray[Frame];
    }

    void AddFrameTime(unsigned int FrameTime)
    {
      m_FrameTimeArray.push_back(FrameTime);
    }

    int GetNumMipmap() const;
    virtual int GetWidth() const
    {
      return m_MipSurfaceArray[0][0]->GetWidth();
    }
    virtual int GetHeight() const
    {
      return m_MipSurfaceArray[0][0]->GetHeight();
    }
    virtual int GetDepth() const
    {
      return m_Depth;
    }
    virtual BitmapFormat GetFormat() const
    {
      return m_MipSurfaceArray[0][0]->GetFormat();
    }
    virtual bool IsNull() const
    {
      return m_MipSurfaceArray[0][0]->IsNull();
    }

  private:
    void ClearData();
    int m_NumMipmap;
    int m_Depth;
    std::vector<ImageSurface *> *m_MipSurfaceArray;
    std::vector<unsigned int> m_FrameTimeArray;
  };


  struct ImageInfo
  {
    bool         isDelegate;        // true if delegate knows this format
    int width ;            // Image size(if known)
    int height;
    int bytes_per_pixel;   // Bytes per pixel(if known)
    int planes;            // Number of planes(if known) 0=mono, 3=color
    std::string  format;            // Additional image format information
  };

  void MakeCheckBoardImage(ImageSurface& Image,
                           int width, int height,
                           Color const& dark, Color const& light,
                           int TileWidth = 4, int TileHeight = 4);

  bool HasOpenEXRSupport();

  /*!
      Return and object that has to be destroyed with delete.

      @return A bitmap source. Destroy it with delete.
  */
  NBitmapData* LoadGdkPixbuf(GdkPixbuf *pixbuf);

  /*!
      Return and object that has to be destroyed with delete.

      @return A bitmap source. Destroy it with delete.
  */
  NBitmapData* LoadImageFile(const TCHAR *Filename);

}

#endif // IMAGE_H