Return to picunpack.c CVS log

Up to [Research Unix] / researchv10no / libpicfile

Annotation of researchv10no/libpicfile/picunpack.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * picunpack -- non-ansi version, uses varargs instead of stdarg
                      3:  * Bugs:
                      4:  *     f and d are non-portable
                      5:  *     could be faster
                      6:  */
                      7: #include <picfile.h>
                      8: #include <stdio.h>
                      9: #include <varargs.h>
                     10: void picunpack(va_alist)
                     11: va_dcl
                     12: {
                     13:        register char *bp, *cp;
                     14:        register short *sp;
                     15:        register long *lp;
                     16:        register float *fp;
                     17:        register double *dp;
                     18:        register char *buf, *ebuf;
                     19:        PICFILE *f;
                     20:        char *fmt;
                     21:        int nchan;
                     22:        va_list pvar;
                     23:        va_start(pvar);
                     24:        f=va_arg(pvar, PICFILE *);
                     25:        buf=va_arg(pvar, char *);
                     26:        nchan=f->nchan;
                     27:        ebuf=buf+f->width*nchan;
                     28:        for(fmt=va_arg(pvar, char *);*fmt;fmt++) switch(*fmt){
                     29:        case 'c':
                     30:                cp=va_arg(pvar, char *);
                     31:                for(bp=buf;bp!=ebuf;bp+=nchan)
                     32:                        *cp++=*bp;
                     33:                buf++;
                     34:                ebuf++;
                     35:                break;
                     36:        case 's':
                     37:                sp=va_arg(pvar, short *);
                     38:                for(bp=buf;bp!=ebuf;bp+=nchan)
                     39:                        *sp++=(bp[0]&255)|(bp[1]<<8);
                     40:                buf+=2;
                     41:                ebuf+=2;
                     42:                break;
                     43:        case 'l':
                     44:                lp=va_arg(pvar, long *);
                     45:                for(bp=buf;bp!=ebuf;bp+=nchan)
                     46:                        *lp++=(bp[0]&255)|((bp[1]&255)<<8)|((bp[2]&255)<<16)|(bp[3]<<24);
                     47:                buf+=4;
                     48:                ebuf+=4;
                     49:                break;
                     50:        case 'f':
                     51:                fp=va_arg(pvar, float *);
                     52:                for(bp=buf;bp!=ebuf;bp+=nchan){
                     53:                        cp=(char *)fp++;
                     54:                        cp[0]=bp[0];
                     55:                        cp[1]=bp[1];
                     56:                        cp[2]=bp[2];
                     57:                        cp[3]=bp[3];
                     58:                }
                     59:                buf+=4;
                     60:                ebuf+=4;
                     61:                break;
                     62:        case 'd':
                     63:                dp=va_arg(pvar, double *);
                     64:                for(bp=buf;bp!=ebuf;bp+=nchan){
                     65:                        cp=(char *)dp++;
                     66:                        cp[0]=bp[0];
                     67:                        cp[1]=bp[1];
                     68:                        cp[2]=bp[2];
                     69:                        cp[3]=bp[3];
                     70:                        cp[4]=bp[4];
                     71:                        cp[5]=bp[5];
                     72:                        cp[6]=bp[6];
                     73:                        cp[7]=bp[7];
                     74:                }
                     75:                buf+=8;
                     76:                ebuf+=8;
                     77:                break;
                     78:        case '_':
                     79:                buf++;
                     80:                ebuf++;
                     81:                break;
                     82:        }
                     83:        va_end(pvar);
                     84: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.