This file is indexed.

/usr/include/libAfterImage/asstorage.h is in libafterimage-dev 2.2.12-6.

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
#ifndef ASSTORAGE_H_HEADER_INCLUDED
#define ASSTORAGE_H_HEADER_INCLUDED


#define AS_STORAGE_PAGE_SIZE		4096

/* 
 *	there could be up to 16 arrays of 1024 pointers to slots each in Storage Block
 *	There could be 2^18 StorageBlocks in ASStorage
 */
#define AS_STORAGE_SLOTS_BATCH		1024  /* we allocate pointers to slots in batches of one page eache  */ 
#define AS_STORAGE_SLOT_ID_BITS		14  /* 32*512 == 2^14 */ 
#define AS_STORAGE_MAX_SLOTS_CNT	(0x01<<AS_STORAGE_SLOT_ID_BITS)

#define AS_STORAGE_BLOCK_ID_BITS	(32-AS_STORAGE_SLOT_ID_BITS)
#define AS_STORAGE_MAX_BLOCK_CNT   	(0x01<<AS_STORAGE_BLOCK_ID_BITS)
/* #define AS_STORAGE_DEF_BLOCK_SIZE	(1024*256)  */
#define AS_STORAGE_DEF_BLOCK_SIZE	(1024*128)  /* 128 Kb */  
#define AS_STORAGE_NOUSE_THRESHOLD	(1024*8)  /* 8 Kb if total_free < 8K we should not try and use that 
											   *  block as we may fall into trap constantly defragmenting it
											   *  so we prefer to leave memory unused since 2 pages is not too much to loose */  


#define ASStorageSlot_SIZE 16 /* 16 bytes */
#define ASStorageSlot_USABLE_SIZE(slot) (((slot)->size+15)&0x8FFFFFF0)
#define ASStorageSlot_FULL_SIZE(slot) (ASStorageSlot_USABLE_SIZE(slot)+ASStorageSlot_SIZE)
/* space for slots is allocated in 16 byte increments */
#define AS_STORAGE_GetNextSlot(slot) ((slot)+1+(ASStorageSlot_USABLE_SIZE(slot)>>4))


/* RLE encoding of difference 
 * We calculate difference between following bytes. If differece is zero - its RLE encoded.
 * If its +-1 - its encoded as 2 bit values
 * If Its +-(from 2 to 7) - its encoded using 4 bit values
 * If Its +-(from 8 to 127) - its encoded using 8 bit values  
 * If Its +-(from 128 to 255) - its encoded using 9 bit values
 * 
 * The hope is that most of the bytes will be reduced to 0 
 * The next likely value will be from 2 to 7 
 * and only few cases will fall in other categories
 * 
 * For bitmaps we store lengths of ones and zerous, assuming that each string tsarts with 0
 * 
 * */

/* The following lines is used only for non-bitmaps : */
#define RLE_ZERO_MASK				0x0080  /* M        */  
#define RLE_ZERO_LENGTH				0x007F  /*  LLLLLLL */  
#define RLE_ZERO_SIG				0x0000  /* 0LLLLLLL - identical to a string of LLLLLLL zeros */  

#define RLE_NOZERO_SHORT_MASK		0x00C0  /* MM       */  
#define RLE_NOZERO_SHORT_LENGTH		0x003F  /*   LLLLLL */  
#define RLE_NOZERO_SHORT_SIG		0x00C0  /* 11LLLLLL followed by stream of LLLLLL 4 or 2 bit values */

#define RLE_NOZERO_LONG_MASK		0x00F0  /* MMMM     */  
#define RLE_NOZERO_LONG_LENGTH		0x000F  /*     LLLL */  
#define RLE_NOZERO_LONG1_SIG		0x00A0  /* 1010LLLL followed by stream of LLLL 2 or 4 bit values */  
#define RLE_NOZERO_LONG2_SIG		0x00B0  /* 1011LLLL followed by stream of LLLL 1 byte values */  

#define RLE_9BIT_SIG				0x0080  /* 1000LLLL followed by stream of LLLL 1 byte values 
                                               that change sign from byte to byte starting with positive */     
#define RLE_9BIT_NEG_SIG	  		0x0090  /* 1001LLLL followed by stream of LLLL 1 byte values 
                                               that change sign from byte to byte starting with negative */     

#define AS_STORAGE_DEFAULT_BMAP_THRESHOLD 0x7F
#define AS_STORAGE_DEFAULT_BMAP_VALUE	  0xFF


typedef struct ASStorageSlot
{
/* Pointer to ASStorageSlot is the pointer to used memory beginning - ASStorageSlot_SIZE 
 * thus we need not to store it separately 
 */
#define ASStorage_ZlibCompress		(0x01<<0)  /* do we really want that ? */ 
#define ASStorage_RLEDiffCompress 	(0x01<<1)  /* RLE of difference */ 

#define ASStorage_CompressionType	(0x0F<<0)  /* allow for 16 compression schemes */
#define ASStorage_Used				(0x01<<4)
#define ASStorage_NotTileable		(0x01<<5)
#define ASStorage_Reference			(0x01<<6)  /* data is the id of some other slot */ 
#define ASStorage_Bitmap			(0x01<<7)  /* data is 1 bpp */ 
#define ASStorage_32Bit				(0x01<<8)  /* data is 32 bpp with only first 8 bits being significant */ 
#define ASStorage_BitShiftFlagPos   9
#define ASStorage_BitShift			(0x03<<ASStorage_BitShiftFlagPos)  
#define ASStorage_8BitShift			(0x01<<ASStorage_BitShiftFlagPos)  
												/* data is 32 bpp shifted left by 8 bit 
												 * (must combine with _32Bit flag )*/ 
#define ASStorage_16BitShift		(0x01<<(ASStorage_BitShiftFlagPos+1)) 
												/* data is 32 bpp shifted left by 16 bit 
												* (must combine with _32Bit flag )
												* If combined with 8BitShift - results in 24 bit shift */ 
#define ASStorage_24BitShift		(ASStorage_8BitShift|ASStorage_16BitShift)
#define ASStorage_Flags2ShiftIdx(f) (((f)>>ASStorage_BitShiftFlagPos)&0x03)
#define ASStorage_Flags2Shift(f) 	(ASStorage_Flags2ShiftIdx(f)*8)
#define ASStorage_Masked			(0x01<<11) /* mask 32bit value to filter out higher 24 bits
                                                * if combined with BitShift - bitshift is done 
												* prior to masking */ 


#define ASStorage_32BitRLE			(ASStorage_RLEDiffCompress|ASStorage_32Bit)

	CARD16  flags ;
	CARD16  ref_count ;
	CARD32  size ;
	CARD32  uncompressed_size ;
	CARD16  index ;  /* reverse mapping of slot address into index in array */
	/* slots may be placed in array pointing into different areas of the memory 
	 * block, since we will need to implement some sort of garbadge collection and 
	 * defragmentation mechanism - we need to be able to process them in orderly 	
	 * fashion. 
	 * So finally : 
	 * 1) slot's index does not specify where in the memory slot 
	 * is located, it is only used to address slot from outside.
	 * 2) Using slots memory address and its size we can go through the chain of slots
	 * and perform all the maintenance tasks  as long as we have reverse mapping 
	 * of addresses into indexes.
	 * 
	 */
	CARD16 reserved ;          /* to make us have size rounded by 16 bytes margin */
	/* Data immidiately follows here : 
	 * CARD8   data[0] ; */

#define ASStorage_Data(s)  ((CARD8*)((s)+1))

}ASStorageSlot;

/* turns out there is no performance gains from using int here instead of short - 
so save some memory if we can : */
typedef short ASStorageDiff;


typedef void (*compute_diff_func_type)(ASStorageDiff*,CARD8*,int);
typedef int  (*copy_data32_func_type)(CARD8*,CARD32*,int);
typedef int  (*copy_data32_tinted_func_type)(CARD8*,CARD32*,int,CARD32);


typedef struct ASStorageBlock
{
#define ASStorage_MonoliticBlock		(0x01<<0) /* block consists of a single batch of storage */
 	CARD32  flags ;
	int 	size ;

	int   	total_free;
	ASStorageSlot  *start, *end;
	/* array of pointers to slots is allocated separately, so that we can reallocate it 
	   in case we have lots of small slots */
	ASStorageSlot **slots;
	int slots_count, unused_count ;
	int first_free, last_used ;
	int long_searches ;

}ASStorageBlock;

typedef struct ASStorage
{
	int default_block_size ;


	ASStorageBlock **blocks ;
	int 			blocks_count;

	ASStorageDiff  *diff_buf ;
	CARD8  *comp_buf ;
	size_t 	comp_buf_size ; 

}ASStorage;


typedef CARD32 ASStorageID ;

ASStorageID store_data(ASStorage *storage, CARD8 *data, int size, ASFlagType flags, CARD8 bitmap_threshold);
ASStorageID store_data_tinted(ASStorage *storage, CARD8 *data, int size, ASFlagType flags, CARD16 tint);

/* data will be fetched fromthe slot identified by id and placed into buffer. 
 * Data will be fetched from offset  and will count buf_size bytes if buf_size is greater then
 * available data - data will be tiled to accomodate this size, unless NotTileable is set */
int  fetch_data(ASStorage *storage, ASStorageID id, CARD8 *buffer, int offset, int buf_size, CARD8 bitmap_value, int *original_size);
int  fetch_data32(ASStorage *storage, ASStorageID id, CARD32 *buffer, int offset, int buf_size, CARD8 bitmap_value, int *original_size);
int  threshold_stored_data(ASStorage *storage, ASStorageID id, unsigned int *runs, int width, unsigned int threshold);

/* slot identified by id will be marked as unused */
void forget_data(ASStorage *storage, ASStorageID id);

void print_storage(ASStorage *storage);

int print_storage_slot(ASStorage *storage, ASStorageID id);
Bool query_storage_slot(ASStorage *storage, ASStorageID id, ASStorageSlot *dst );

/* returns new ID without copying data. Data will be stored as copy-on-right. 
 * Reference count of the data will be increased. If optional dst_id is specified - 
 * its data will be erased, and it will point to the data of src_id: 
 */				
ASStorageID dup_data(ASStorage *storage, ASStorageID src_id);

/* this will provide access to default storage heap that is used whenever above functions get
 * NULL passed as ASStorage parameter :
 */
void flush_default_asstorage();
int set_asstorage_block_size( ASStorage *storage, int new_size );


#endif