00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "pnmimage_base.h"
00016 #include "streamReader.h"
00017 #include "streamWriter.h"
00018 #include "config_pnmimage.h"
00019
00020 #include <stdarg.h>
00021 #include <stdio.h>
00022
00023
00024
00025
00026
00027
00028
00029 void
00030 pm_message(const char *format, ...) {
00031 va_list ap;
00032 va_start(ap, format);
00033
00034 static const size_t buffer_size = 1024;
00035 char buffer[buffer_size];
00036 #if defined(WIN32_VC) || defined(WIN64_VC)
00037
00038 vsprintf(buffer, format, ap);
00039 #else
00040 vsnprintf(buffer, buffer_size, format, ap);
00041 #endif
00042 nassertv(strlen(buffer) < buffer_size);
00043
00044 pnmimage_cat.info() << buffer << "\n";
00045
00046 va_end(ap);
00047 }
00048
00049
00050
00051
00052
00053
00054
00055 void
00056 pm_error(const char *format, ...) {
00057 va_list ap;
00058 va_start(ap, format);
00059
00060 static const size_t buffer_size = 1024;
00061 char buffer[buffer_size];
00062 #if defined(WIN32_VC) || defined(WIN64_VC)
00063
00064 vsprintf(buffer, format, ap);
00065 #else
00066 vsnprintf(buffer, buffer_size, format, ap);
00067 #endif
00068 nassertv(strlen(buffer) < buffer_size);
00069
00070 pnmimage_cat.error() << buffer << "\n";
00071
00072 va_end(ap);
00073
00074
00075
00076 exit(1);
00077 }
00078
00079
00080
00081
00082
00083
00084 int
00085 pm_maxvaltobits(int maxval) {
00086 int bits = 1;
00087 while (maxval > pm_bitstomaxval(bits)) {
00088 bits++;
00089 nassertr(bits != 0, 16);
00090 }
00091 return bits;
00092 }
00093
00094
00095
00096
00097
00098
00099 int
00100 pm_bitstomaxval(int bits) {
00101 return ( 1 << bits ) - 1;
00102 }
00103
00104
00105
00106
00107
00108 char *
00109 pm_allocrow(int cols, int size) {
00110 return (char *)PANDA_MALLOC_ARRAY(cols * size);
00111 }
00112
00113
00114
00115
00116
00117 void
00118 pm_freerow(char *itrow) {
00119 PANDA_FREE_ARRAY(itrow);
00120 }
00121
00122
00123
00124
00125
00126 int
00127 pm_readbigshort(istream *in, short *sP) {
00128 StreamReader reader(in, false);
00129 *sP = reader.get_be_int16();
00130 return (!in->eof() && !in->fail()) ? 0 : -1;
00131 }
00132
00133 int
00134 pm_writebigshort(ostream *out, short s) {
00135 StreamWriter writer(out, false);
00136 writer.add_be_int16(s);
00137 return (!out->fail()) ? 0 : -1;
00138 }
00139
00140 int
00141 pm_readbiglong(istream *in, long *lP) {
00142 StreamReader reader(in, false);
00143 *lP = reader.get_be_int32();
00144 return (!in->eof() && !in->fail()) ? 0 : -1;
00145 }
00146
00147 int
00148 pm_writebiglong(ostream *out, long l) {
00149 StreamWriter writer(out, false);
00150 writer.add_be_int32(l);
00151 return (!out->fail()) ? 0 : -1;
00152 }
00153
00154 int
00155 pm_readlittleshort(istream *in, short *sP) {
00156 StreamReader reader(in, false);
00157 *sP = reader.get_int16();
00158 return (!in->eof() && !in->fail()) ? 0 : -1;
00159 }
00160
00161 int
00162 pm_writelittleshort(ostream *out, short s) {
00163 StreamWriter writer(out, false);
00164 writer.add_int16(s);
00165 return (!out->fail()) ? 0 : -1;
00166 }
00167
00168 int
00169 pm_readlittlelong(istream *in, long *lP) {
00170 StreamReader reader(in, false);
00171 *lP = reader.get_int32();
00172 return (!in->eof() && !in->fail()) ? 0 : -1;
00173 }
00174
00175 int
00176 pm_writelittlelong(ostream *out, long l) {
00177 StreamWriter writer(out, false);
00178 writer.add_int32(l);
00179 return (!out->fail()) ? 0 : -1;
00180 }