rawconvert.c-Dateireferenz

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <assert.h>

Include-Abhängigkeitsdiagramm für rawconvert.c:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	op_def_t

Makrodefinitionen
#define	OP_DEF(X, Y)   {#X "to" #Y, X, Y, get_##X##_pixel, set_##Y##_pixel},
#define	NUM_OP_DEFS   (sizeof(op_defs)/sizeof(op_def_t))

Typdefinitionen
typedef unsigned(*	get_pixel_func_t )(uint8_t *p, unsigned row_bytes, unsigned x, unsigned y)
typedef void(*	set_pixel_func_t )(uint8_t *p, unsigned row_bytes, unsigned x, unsigned y, unsigned value)
typedef unsigned(*	convert_pixel_func_t )(unsigned value)

Funktionen
void	set_12_pixel (uint8_t *p, unsigned row_bytes, unsigned x, unsigned y, unsigned value)
unsigned	get_12_pixel (uint8_t *p, unsigned row_bytes, unsigned x, unsigned y)
unsigned	get_10_pixel (uint8_t *p, unsigned row_bytes, unsigned x, unsigned y)
void	set_10_pixel (uint8_t *p, unsigned row_bytes, unsigned x, unsigned y, unsigned value)
unsigned	get_8_pixel (uint8_t *buf, unsigned row_bytes, unsigned x, unsigned y)
void	set_8_pixel (uint8_t *buf, unsigned row_bytes, unsigned x, unsigned y, unsigned value)
unsigned	get_16_pixel (uint8_t *buf, unsigned row_bytes, unsigned x, unsigned y)
void	set_16_pixel (uint8_t *buf, unsigned row_bytes, unsigned x, unsigned y, unsigned value)
void	swap_bytes (unsigned char *src, unsigned char *dst, size_t size)
const op_def_t *	find_op (const char *name)
void	usage ()
int	main (int argc, char **argv)

Variablen
op_def_t	op_defs []

Makro-Dokumentation

#define NUM_OP_DEFS   (sizeof(op_defs)/sizeof(op_def_t))

Definiert in Zeile 193 der Datei rawconvert.c.

#define OP_DEF	(		X,
			Y
	)		{#X "to" #Y, X, Y, get_##X##_pixel, set_##Y##_pixel},

Definiert in Zeile 177 der Datei rawconvert.c.

Dokumentation der benutzerdefinierten Typen

typedef unsigned(* convert_pixel_func_t)(unsigned value)

Definiert in Zeile 44 der Datei rawconvert.c.

typedef unsigned(* get_pixel_func_t)(uint8_t *p, unsigned row_bytes, unsigned x, unsigned y)

Definiert in Zeile 42 der Datei rawconvert.c.

typedef void(* set_pixel_func_t)(uint8_t *p, unsigned row_bytes, unsigned x, unsigned y, unsigned value)

Definiert in Zeile 43 der Datei rawconvert.c.

Dokumentation der Funktionen

const op_def_t* find_op

(

const char *

name)

Definiert in Zeile 195 der Datei rawconvert.c.

{
    unsigned i;
    for( i=0; i < NUM_OP_DEFS; i++) {
        if(strcmp(name,op_defs[i].name) == 0)
            return op_defs+i;
    }
    return NULL;
}

unsigned get_10_pixel	(	uint8_t *	p,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y
	)

Definiert in Zeile 89 der Datei rawconvert.c.

{
    uint8_t* addr = p + y * row_bytes + (x>>3) * 10;
    switch (x&7) {
        case 0: return ((0x3fc&(((unsigned short)addr[1])<<2)) | (addr[0] >> 6));
        case 1: return ((0x3f0&(((unsigned short)addr[0])<<4)) | (addr[3] >> 4));
        case 2: return ((0x3c0&(((unsigned short)addr[3])<<6)) | (addr[2] >> 2));
        case 3: return ((0x300&(((unsigned short)addr[2])<<8)) | (addr[5]));
        case 4: return ((0x3fc&(((unsigned short)addr[4])<<2)) | (addr[7] >> 6));
        case 5: return ((0x3f0&(((unsigned short)addr[7])<<4)) | (addr[6] >> 4));
        case 6: return ((0x3c0&(((unsigned short)addr[6])<<6)) | (addr[9] >> 2));
        case 7: return ((0x300&(((unsigned short)addr[9])<<8)) | (addr[8]));
    }
    return 0;
}

unsigned get_12_pixel	(	uint8_t *	p,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y
	)

Definiert in Zeile 77 der Datei rawconvert.c.

{
 uint8_t* addr = p + y * row_bytes + (x>>2) * 6;
 switch (x&3) {
  case 0: return ((unsigned short)(addr[1]) << 4) | (addr[0] >> 4);
  case 1: return ((unsigned short)(addr[0] & 0x0F) << 8) | (addr[3]);
  case 2: return ((unsigned short)(addr[2]) << 4) | (addr[5] >> 4);
  case 3: return ((unsigned short)(addr[5] & 0x0F) << 8) | (addr[4]);
 }
 return 0;
}

unsigned get_16_pixel	(	uint8_t *	buf,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y
	)

Definiert in Zeile 154 der Datei rawconvert.c.

{
    return ((uint16_t *)buf)[(row_bytes/2)*y + x];
}

unsigned get_8_pixel	(	uint8_t *	buf,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y
	)

Definiert in Zeile 144 der Datei rawconvert.c.

{
    return buf[row_bytes*y+x];
}

int main	(	int	argc,
		char **	argv
	)

Definiert in Zeile 217 der Datei rawconvert.c.

{
    uint8_t *in_data;
    uint8_t *out_data;
    FILE *fp;
    char *iname=NULL;
    char *oname=NULL;

    const op_def_t *op=NULL;

    unsigned height=0;
    unsigned width=0;
    unsigned npixels;
    unsigned osize;

    unsigned pixel_shift=1;
    unsigned pgm_format=0;
    int bpp_diff;

    struct stat st;

    size_t rcount;

    unsigned i;

    for(i = 1; i < (unsigned)argc; i++) {
        if ( strncmp(argv[i],"-h=",3) == 0 ) {
            height=atoi(argv[i]+3);
        }
        else if ( strncmp(argv[i],"-w=",3) == 0 ) {
            width=atoi(argv[i]+3);
        }
        else if ( strcmp(argv[i],"-noshift") == 0 ) {
            pixel_shift=0;
        }
        else if( strcmp(argv[i],"-pgm") == 0 ) {
            pgm_format=1;
        }
        else if ( argv[i][0]=='-' ) {
            if( !(op = find_op(argv[i]+1))) {
                fprintf(stderr,"%s: unknown option %s\n",argv[0],argv[i]);
                usage();
            }
        }
        else {
            if(!iname) {
                iname=argv[i];
            }
            else if (!oname) {
                oname=argv[i];
            }
            else {
                fprintf(stderr,"%s: unknown option %s\n",argv[0],argv[i]);
                usage();
            }
        }
    }
    if(!iname) {
        fprintf(stderr,"%s: missing input file\n",argv[0]);
        usage();
    }
    if(!oname) {
        fprintf(stderr,"%s: missing output file\n",argv[0]);
        usage();
    }
    if(!op) {
        fprintf(stderr,"%s: no op given\n",argv[0]);
        usage();
    }
    if(!height || !width) {
        fprintf(stderr,"%s: invalid dimensions\n",argv[0]);
        usage();
    }

    if(stat(iname,&st) != 0) {
        fprintf(stderr,"%s: bad input file %s\n",argv[0],iname);
        exit(1);
    }

    if((width*op->ibpp)%8 != 0) {
        fprintf(stderr,"WARNING: width %u not an integral number of bytes at %u bpp\n",width,op->ibpp);
    }
    if((width*op->obpp)%8 != 0) {
        fprintf(stderr,"WARNING: width %u not an integral number of bytes at %u bpp\n",width,op->obpp);
    }
    if(pgm_format && op->obpp!=8 && op->obpp!=16) {
        fprintf(stderr,"WARNING: Portable Gray Map (PGM) format supports only 8 or 16 bpp.\n");
        pgm_format=0;
    }

    in_data=malloc(st.st_size);
    assert(in_data);

    fp=fopen(iname,"rb");
    assert(fp);

    rcount=fread(in_data,1,st.st_size,fp);
    assert(rcount==(size_t)st.st_size);

    fclose(fp);

    npixels=height*width;
    if((npixels*op->ibpp) >> 3 != st.st_size) {
        fprintf(stderr,"%s: %s mismatched size (%u*%u*%u)/8 -> %u != %u\n",
                    argv[0], iname, width, height, op->ibpp, (npixels*op->ibpp) >> 3, (unsigned)st.st_size);
        exit(1);
    }
    osize = (npixels*op->obpp) >> 3;
    out_data=malloc(osize);
    assert(out_data);

    fprintf(stderr,"input:  %s %ux%u %u bpp %u bytes\n",iname, width, height, op->ibpp, (unsigned)(st.st_size));
    fprintf(stderr,"output: %s %u bpp %u bytes\n", oname, op->obpp, osize);

    bpp_diff = op->obpp - op->ibpp;
    if(pixel_shift) {
        if(bpp_diff < 0) 
            fprintf(stderr," discard lower %d bits\n",-bpp_diff);
        else
            fprintf(stderr," multiply pixel values %d\n",1 << bpp_diff);
    } 
    else if(bpp_diff < 0) {
        fprintf(stderr," discard upper %d bits\n",-bpp_diff);
    }
    
    {
        unsigned pixel_value;
        unsigned in_row_bytes=(width*op->ibpp)>>3;
        unsigned out_row_bytes=(width*op->obpp)>>3;
        for(i=0; i<npixels; i++) {
            pixel_value = op->get_pixel(in_data, in_row_bytes, i%width, i/width);
            if (pixel_shift) {
                if (bpp_diff < 0) {
                    pixel_value >>= -bpp_diff;
                }
                else if (bpp_diff > 0) {
                    pixel_value <<= bpp_diff;
                }
            }
            op->set_pixel(out_data, out_row_bytes, i%width, i/width, pixel_value);
        }
    }

    fp=fopen(oname,"wb");
    assert(fp);
    if(pgm_format)
    {
        fprintf(fp, "P5\n%d\n%d\n%d\n", width, height, (1 << op->obpp)-1);
        if(op->obpp==16) swap_bytes(out_data, out_data, osize);
    }
    fwrite(out_data, 1, osize, fp);
    fclose(fp);

    free(in_data);
    free(out_data);
    fprintf(stderr,"done\n");
    return 0;
}

void set_10_pixel	(	uint8_t *	p,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y,
		unsigned	value
	)

Definiert in Zeile 105 der Datei rawconvert.c.

{
    uint8_t* addr = p + y*row_bytes + (x>>3)*10;
    switch (x&7) {
        case 0:
            addr[0] = (addr[0]&0x3F)|(value<<6); 
            addr[1] = value>>2;
        break;
        case 1:
            addr[0] = (addr[0]&0xC0)|(value>>4);
            addr[3] = (addr[3]&0x0F)|(value<<4);
        break;
        case 2:
            addr[2] = (addr[2]&0x03)|(value<<2);
            addr[3] = (addr[3]&0xF0)|(value>>6);
        break;
        case 3:
            addr[2] = (addr[2]&0xFC)|(value>>8); 
            addr[5] = value;
        break;
        case 4:
            addr[4] = value>>2;
            addr[7] = (addr[7]&0x3F)|(value<<6);
        break;
        case 5:
            addr[6] = (addr[6]&0x0F)|(value<<4);
            addr[7] = (addr[7]&0xC0)|(value>>4);
        break;
        case 6:
            addr[6] = (addr[6]&0xF0)|(value>>6);
            addr[9] = (addr[9]&0x03)|(value<<2);
        break;
        case 7:
            addr[8] = value;
            addr[9] = (addr[9]&0xFC)|(value>>8);
        break;
    }
}

void set_12_pixel	(	uint8_t *	p,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y,
		unsigned	value
	)

Definiert in Zeile 54 der Datei rawconvert.c.

{
 uint8_t* addr=p+y*row_bytes+(x>>2)*6;
 switch (x%4) {
  case 0: 
   addr[0] = (addr[0]&0x0F) | (unsigned char)(value << 4);
   addr[1] = (unsigned char)(value >> 4);
   break;
  case 1: 
   addr[0] = (addr[0]&0xF0) | (unsigned char)(value >> 8);
   addr[3] = (unsigned char)value;
   break;
  case 2: 
   addr[2] = (unsigned char)(value >> 4);
   addr[5] = (addr[5]&0x0F) | (unsigned char)(value << 4);
   break;
  case 3: 
   addr[4] = (unsigned char)value;
   addr[5] = (addr[5]&0xF0) | (unsigned char)(value >> 8);
   break;
 }
}

void set_16_pixel	(	uint8_t *	buf,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y,
		unsigned	value
	)

Definiert in Zeile 159 der Datei rawconvert.c.

{
    ((uint16_t *)buf)[(row_bytes/2)*y + x] = (uint16_t)value;
}

void set_8_pixel	(	uint8_t *	buf,
		unsigned	row_bytes,
		unsigned	x,
		unsigned	y,
		unsigned	value
	)

Definiert in Zeile 149 der Datei rawconvert.c.

{
    buf[row_bytes*y+x] = (uint8_t)value;
}

void swap_bytes	(	unsigned char *	src,
		unsigned char *	dst,
		size_t	size
	)

Definiert in Zeile 164 der Datei rawconvert.c.

{
    unsigned char c1, c2;
    while(size>1)
    {
        c1=*src++;
        c2=*src++;
        *dst++=c2;
        *dst++=c1;
        size-=2;
    }
}

void usage

(

void

)

Definiert in Zeile 205 der Datei rawconvert.c.

{
    unsigned i;
    fprintf(stderr,"Usage: -<op> -w=<width> -h=<height> [-pgm] [-noshift] <infile> <outfile>\n");
    fprintf(stderr," op one of:");
    for( i=0; i < NUM_OP_DEFS; i++) {
        fprintf(stderr," %s",op_defs[i].name);
    }
    fprintf(stderr,"\n");
    exit(1);
}

Variablen-Dokumentation

op_def_t op_defs[]

Initialisierung:

={












}

Definiert in Zeile 178 der Datei rawconvert.c.