This file is indexed.

/usr/include/libAfterImage/scanline.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
#ifndef _SCANLINE_H_HEADER_INCLUDED
#define _SCANLINE_H_HEADER_INCLUDED

#include "asvisual.h"

#ifdef __cplusplus
extern "C" {
#endif

/****h* libAfterImage/scanline.h
 * NAME
 * scanline - Structures and functions for manipulation of image data 
 * in blocks of uncompressed scanlines. Each scanline has 4 32 bit channels.
 * Data in scanline could be both 8bit or 16 bit, with automated 
 * dithering of 16 bit data into standard 8-bit image.
 * SEE ALSO
 * Structures:
 *  	    ASScanline
 *
 * Functions :
 *   ASScanline handling:
 *  	    prepare_scanline(), free_scanline()
 *
 * Other libAfterImage modules :
 *          asvisual.h imencdec.h asimage.h blender.h
 * AUTHOR
 * Sasha Vasko <sasha at aftercode dot net>
 ******************/

/****s* libAfterImage/ASScanline
 * NAME
 * ASScanline - structure to hold contents of the single scanline.
 * DESCRIPTION
 * ASScanline holds data for the single scanline, split into channels
 * with 32 bits per pixel per channel. All the memory is allocated at
 * once, and then split in between channels. There are three ways to
 * access channel data :
 * 1) using blue, green, red, alpha pointers.
 * 2) using channels[] array of pointers - convenient in loops
 * 4) using xc3, xc2, xc1 pointers. These are different from red, green,
 * blue in the way that xc3 will point to blue when BGR mode is specified
 * at the time of creation, otherwise it will point to red channel.
 * Likewise xc1 will point to red in BGR mode and blue otherwise.
 * xc2 always points to green channel's data. This is convenient while
 * writing XImages and when channels in source and destination has to be
 * reversed, while reading images from files.
 * Channel data is always aligned by 8 byte boundary allowing for
 * utilization of MMX, floating point and other 64bit registers for
 * transfer and processing.
 * SEE ALSO
 * ASImage
 * SOURCE
 */
typedef struct ASScanline
{
#define SCL_DO_BLUE         (0x01<<ARGB32_BLUE_CHAN )
#define SCL_DO_GREEN        (0x01<<ARGB32_GREEN_CHAN)
#define SCL_DO_RED          (0x01<<ARGB32_RED_CHAN  )
#define SCL_DO_ALPHA		(0x01<<ARGB32_ALPHA_CHAN)
#define SCL_DO_COLOR		(SCL_DO_RED|SCL_DO_GREEN|SCL_DO_BLUE)
#define SCL_DO_ALL			(SCL_DO_RED|SCL_DO_GREEN|SCL_DO_BLUE| \
                             SCL_DO_ALPHA)
#define SCL_RESERVED_MASK	0x0000FFFF
#define SCL_CUSTOM_MASK		0xFFFF0000
#define SCL_CUSTOM_OFFSET	16
							 
	CARD32	 	   flags ;   /* combination of  the above values */
	CARD32        *buffer ;
	CARD32        *blue, *green, *red, *alpha ;
	CARD32	      *channels[IC_NUM_CHANNELS];
	CARD32        *xc3, *xc2, *xc1; /* since some servers require
									 * BGR mode here we store what
									 * goes into what color component
									 * in XImage */
	ARGB32         back_color;
	unsigned int   width, shift;
	unsigned int   offset_x ;
}ASScanline;
/*******************/

#define ASIM_DEMOSAIC_DEFAULT_STRIP_SIZE 	5

typedef struct ASIMStrip
{
#define ASIM_SCL_InterpolatedH 		(0x01<<SCL_CUSTOM_OFFSET)
#define ASIM_SCL_InterpolatedV 		(0x01<<(SCL_CUSTOM_OFFSET+ARGB32_CHANNELS))
#define ASIM_SCL_InterpolatedAll 	(ASIM_SCL_InterpolatedV|ASIM_SCL_InterpolatedH)

#define ASIM_SCL_RGDiffCalculated 	(0x01<<(SCL_CUSTOM_OFFSET+ARGB32_CHANNELS*2))
#define ASIM_SCL_BGDiffCalculated 	(0x01<<(SCL_CUSTOM_OFFSET+ARGB32_CHANNELS*2+1))

	int 		 size, width;
	ASScanline 	**lines;
	int 		 start_line;
	
	void 	   **aux_data;

#define ASIM_SCL_MissingValue	0xF0000000
#define ASIM_IsMissingValue(v)		((v)&0xF0000000)

#define ASIM_IsStripLineLoaded(sptr,l)   		((sptr)->lines[l]->flags & SCL_DO_COLOR)
#define ASIM_IsStripLineInterpolated(sptr,l)   	((sptr)->lines[l]->flags & ASIM_SCL_Interpolated)
}ASIMStrip;

typedef void (*ASIMStripLoader)(ASScanline *scl, CARD8 *data, int data_size);



/****f* libAfterImage/prepare_scanline()
 * NAME
 * prepare_scanline()
 * SYNOPSIS
 * ASScanline *prepare_scanline ( unsigned int width,
 *                                unsigned int shift,
 *                                ASScanline *reusable_memory,
 *                                Bool BGR_mode);
 * INPUTS
 * width           - width of the scanline.
 * shift           - format of contained data. 0 means - 32bit unshifted
 *                   8 means - 24.8bit ( 8 bit left shifted ).
 * reusable_memory - preallocated object.
 * BGR_mode        - if True will cause xc3 to point to Blue and xc1 to
 *                   point to red.
 * DESCRIPTION
 * This function allocates memory ( if reusable_memory is NULL ) for
 * the new ASScanline structure. Structures buffers gets allocated to
 * hold scanline data of at least width pixel wide. Buffers are adjusted
 * to start on 8 byte boundary.
 *********/
/****f* libAfterImage/free_scanline()
 * NAME
 * free_scanline()
 * SYNOPSIS
 * void       free_scanline ( ASScanline *sl, Bool reusable );
 * INPUTS
 * sl       - pointer to previously allocated ASScanline structure to be
 *            deallocated.
 * reusable - if true then ASScanline object itself will not be
 *            deallocated.
 * DESCRIPTION
 * free_scanline() frees all the buffer memory allocated for ASScanline.
 * If reusable is false then object itself in not freed. That is usable
 * for declaring ASScanline on stack.
 *********/
ASScanline* prepare_scanline( unsigned int width, unsigned int shift,
	                          ASScanline *reusable_memory, Bool BGR_mode);
void       free_scanline( ASScanline *sl, Bool reusable );

/* Scanline strips */
void destroy_asim_strip (ASIMStrip **pstrip);
ASIMStrip *create_asim_strip(unsigned int size, unsigned int width, int shift, int bgr);
void advance_asim_strip (ASIMStrip *strip);

/* demosaicing */
/* returns number of lines processed from the data */
int load_asim_strip (ASIMStrip *strip, CARD8 *data, int data_size, int data_start_line, int data_row_size, 
					 ASIMStripLoader *line_loaders, int line_loaders_num);
void decode_BG_12_be (ASScanline *scl, CARD8 *data, int data_size);
void decode_GR_12_be (ASScanline *scl, CARD8 *data, int data_size);
void decode_RG_12_be (ASScanline *scl, CARD8 *data, int data_size);
void decode_GB_12_be (ASScanline *scl, CARD8 *data, int data_size);

void interpolate_asim_strip_custom_rggb2 (ASIMStrip *strip, ASFlagType filter, Bool force_all);

#ifdef __cplusplus
}
#endif

#endif /* _SCANLINE_H_HEADER_INCLUDED */