00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #include "assert.h"
00032 #include "xalloc.h"
00033 #include "uti.h"
00034 #include "spl.h"
00035 #include "samp.hpp"
00036
00037
00038
00039
00040 enum { TPTR_NONE, TPTR_i16, TPTR_d, TPTR_i16ChAll, TPTR_dChAll };
00041
00042
00043
00044
00045
00046
00047 #define FLUSH_WHEN_WRITE
00048
00049
00050
00051 Samp::Samp( VOID )
00052 {
00053 ptr=0;
00054
00055 sSize = 1;
00056 nchan = 1;
00057 sSizeCh = 1;
00058 }
00059
00060
00061
00062 UINT Samp::getSampTypeSize( INT sampType )
00063 {
00064 switch (sampType) {
00065 case SAMPTYPE_PCM8U: return sizeof(UINT8);
00066 case SAMPTYPE_PCM16: return sizeof(INT16);
00067 case SAMPTYPE_PCM32: return sizeof(INT32);
00068 case SAMPTYPE_FLOAT32: return sizeof(FLOAT32);
00069 case SAMPTYPE_FLOAT64: return sizeof(FLOAT64);
00070 }
00071
00072 die_beep("Samp: invalid SampType (%li)",(long)sampType);
00073 return 0;
00074 }
00075
00076
00077
00078 VOID Samp::attach( FILE* fBin, INT sampType, UINT nChan, LONG N )
00079 {
00080 if (!fBin) {
00081 FBlock::attach(NULL,0);
00082 if (ptr) xfree(ptr);
00083 ptr=0;
00084 return;
00085 }
00086
00087 tSamp = sampType;
00088 sSize = getSampTypeSize(sampType);
00089 nchan = nChan;
00090 cdie_beep(nchan<1,"Samp: invalid number of channels (%li)",(long)nchan);
00091 sSizeCh = sSize*nchan;
00092
00093 if (N>=0) FBlock::attach(fBin,N*sSizeCh);
00094 else {
00095 FBlock::attach(fBin,N);
00096 cdie_beep((UINT)(FBlock::getN()%sSizeCh),
00097 "Samp: not enough bytes in file to complete last sample");
00098 }
00099 }
00100
00101
00102
00103 INT16 *Samp::get_i16( UINT len, BOOL reloadall )
00104 {
00105 LONG nn=(LONG)len*sizeof(INT16);
00106 if ((!ptr)||(nptr!=nn)) {
00107 nptr=nn; if (ptr) xfree(ptr); ptr=xmalloc(nptr); reloadall=TRUE;
00108 }
00109 if ((tptr!=TPTR_i16)||(reloadall)) { pptr=getPos(); getBlk((INT16*)ptr,len); }
00110 else {
00111 LONG p=getPos();
00112 if (p<pptr) {
00113 LONG nn=pptr-p;
00114 UINT n=(UINT)nn;
00115 if (nn>=(LONG)len) n=len;
00116 else memmove((void *)((INT16*)ptr+n),ptr,(len-n)*sizeof(INT16));
00117 getBlk((INT16*)ptr,n);
00118 pptr=p;
00119 }
00120 else if (p>pptr) {
00121 LONG nn=p-pptr;
00122 UINT n=(UINT)nn;
00123 if (nn>=(LONG)len) getBlk((INT16*)ptr,len);
00124 else {
00125 memmove(ptr,(void*)((INT16*)ptr+n),(len-n)*sizeof(INT16));
00126 setPos(p+(len-n));
00127 getBlk((INT16*)ptr+(len-n),n);
00128 }
00129 pptr=p;
00130 }
00131 }
00132 tptr=TPTR_i16;
00133 return (INT16*)ptr;
00134 }
00135
00136
00137
00138 DOUBLE *Samp::get_d( UINT len, BOOL reloadall )
00139 {
00140 LONG nn=(LONG)len*sizeof(DOUBLE);
00141 if ((!ptr)||(nptr!=nn)) {
00142 nptr=nn; if (ptr) xfree(ptr); ptr=xmalloc(nptr); reloadall=TRUE;
00143 }
00144 if ((tptr!=TPTR_d)||(reloadall)) { pptr=getPos(); getBlk((DOUBLE*)ptr,len); }
00145 else {
00146 LONG p=getPos();
00147 if (p<pptr) {
00148 LONG nn=pptr-p;
00149 UINT n=(UINT)nn;
00150 if (nn>=(LONG)len) n=len;
00151 else memmove((void *)((DOUBLE*)ptr+n),ptr,(len-n)*sizeof(DOUBLE));
00152 getBlk((DOUBLE*)ptr,n);
00153 pptr=p;
00154 }
00155 else if (p>pptr) {
00156 LONG nn=p-pptr;
00157 UINT n=(UINT)nn;
00158 if (nn>=(LONG)len) getBlk((DOUBLE*)ptr,len);
00159 else {
00160 memmove(ptr,(void*)((DOUBLE*)ptr+n),(len-n)*sizeof(DOUBLE));
00161 setPos(p+(len-n));
00162 getBlk((DOUBLE*)ptr+(len-n),n);
00163 }
00164 pptr=p;
00165 }
00166 }
00167 tptr=TPTR_d;
00168 return (DOUBLE*)ptr;
00169 }
00170
00171
00172
00173 INT16 *Samp::getChAll_i16( UINT len, BOOL reloadall )
00174 {
00175 LONG nn=(LONG)len*nchan*sizeof(INT16);
00176 if ((!ptr)||(nptr!=nn)) {
00177 nptr=nn; if (ptr) xfree(ptr); ptr=xmalloc(nptr); reloadall=TRUE;
00178 }
00179 if ((tptr!=TPTR_i16ChAll)||(reloadall)) { pptr=getPos(); getBlkChAll((INT16*)ptr,len); }
00180 else {
00181 LONG p=getPos();
00182 if (p<pptr) {
00183 LONG nn=pptr-p;
00184 UINT n=(UINT)nn;
00185 if (nn>=(LONG)len) n=len;
00186 else memmove((void *)((INT16*)ptr+n*nchan),ptr,(len-n)*sizeof(INT16)*nchan);
00187 getBlkChAll((INT16*)ptr,n);
00188 pptr=p;
00189 }
00190 else if (p>pptr) {
00191 LONG nn=p-pptr;
00192 UINT n=(UINT)nn;
00193 if (nn>=(LONG)len) getBlkChAll((INT16*)ptr,len);
00194 else {
00195 memmove(ptr,(void*)((INT16*)ptr+n*nchan),(len-n)*sizeof(INT16)*nchan);
00196 setPos(p+(len-n));
00197 getBlkChAll((INT16*)ptr+(len-n)*nchan,n);
00198 }
00199 pptr=p;
00200 }
00201 }
00202 tptr=TPTR_i16ChAll;
00203 return (INT16*)ptr;
00204 }
00205
00206
00207
00208 DOUBLE *Samp::getChAll_d( UINT len, BOOL reloadall )
00209 {
00210 LONG nn=(LONG)len*nchan*sizeof(DOUBLE);
00211 if ((!ptr)||(nptr!=nn)) {
00212 nptr=nn; if (ptr) xfree(ptr); ptr=xmalloc(nptr); reloadall=TRUE;
00213 }
00214 if ((tptr!=TPTR_dChAll)||(reloadall)) { pptr=getPos(); getBlkChAll((DOUBLE*)ptr,len); }
00215 else {
00216 LONG p=getPos();
00217 if (p<pptr) {
00218 LONG nn=pptr-p;
00219 UINT n=(UINT)nn;
00220 if (nn>=(LONG)len) n=len;
00221 else memmove((void *)((DOUBLE*)ptr+n*nchan),ptr,(len-n)*sizeof(DOUBLE)*nchan);
00222 getBlkChAll((DOUBLE*)ptr,n);
00223 pptr=p;
00224 }
00225 else if (p>pptr) {
00226 LONG nn=p-pptr;
00227 UINT n=(UINT)nn;
00228 if (nn>=(LONG)len) getBlkChAll((DOUBLE*)ptr,len);
00229 else {
00230 memmove(ptr,(void*)((DOUBLE*)ptr+n*nchan),(len-n)*sizeof(DOUBLE)*nchan);
00231 setPos(p+(len-n));
00232 getBlkChAll((DOUBLE*)ptr+(len-n)*nchan,n);
00233 }
00234 pptr=p;
00235 }
00236 }
00237 tptr=TPTR_dChAll;
00238 return (DOUBLE*)ptr;
00239 }
00240
00241
00242
00243 BOOL Samp::OK( VOID ) const
00244 {
00245 if (!FBlock::OK()) return FALSE;
00246 if (testblk(ptr)) return FALSE;
00247
00248 return TRUE;
00249 }
00250
00251
00252
00253 Samp::~Samp( VOID )
00254 {
00255 if (ptr) xfree(ptr);
00256 ptr=0; nptr=-1;
00257 };
00258
00259
00260
00261 PRIVATE class { public: INT i; const CHAR *a; } allSampTypes[]= {
00262 { SAMPTYPE_PCM8U, SAMPTYPE_STR_PCM8U },
00263 { SAMPTYPE_PCM16, SAMPTYPE_STR_PCM16 },
00264 { SAMPTYPE_PCM32, SAMPTYPE_STR_PCM32 },
00265 { SAMPTYPE_FLOAT32, SAMPTYPE_STR_FLOAT32 },
00266 { SAMPTYPE_FLOAT64, SAMPTYPE_STR_FLOAT64 },
00267 { -1, NULL }
00268 };
00269
00270
00271
00272
00273
00274
00275
00276 INT SampType_a2i( const CHAR* sampType, BOOL errexit )
00277 {
00278 if (sampType) {
00279 INT i=0;
00280 while (allSampTypes[i].i>=0) {
00281 if (!strcmp(allSampTypes[i].a,sampType))
00282 return allSampTypes[i].i;
00283 i++;
00284 }
00285 }
00286 if (errexit) die_beep("SampType: invalid sample type (%s)",sampType);
00287 return -1;
00288 }
00289
00290
00291
00292
00293
00294
00295 const CHAR* SampType_i2a( INT sampType, BOOL errexit )
00296 {
00297 if (sampType) {
00298 INT i=0;
00299 while (allSampTypes[i].i>=0) {
00300 if (allSampTypes[i].i==sampType)
00301 return allSampTypes[i].a;
00302 i++;
00303 }
00304 }
00305 if (errexit) die_beep("SampType: invalid sample type (%d)",sampType);
00306 return NULL;
00307 }
00308
00309
00310
00311 UINT Samp::getNoCh( INT16& sample )
00312 {
00313 UINT8 u8;
00314 FLOAT32 f32;
00315 FLOAT64 f64;
00316 UINT ret;
00317
00318 switch (tSamp) {
00319 case SAMPTYPE_PCM8U:
00320 ret=FBlock::get((BYTE*)&u8,sSize)/sSize;
00321 sample = (((INT16)u8)-128)<<8;
00322 return ret;
00323 case SAMPTYPE_PCM16:
00324 ret=FBlock::get((BYTE*)&sample,sSize)/sSize;
00325 if (endian>0) endian_fromlittle16(&sample); else if (endian<0) endian_frombig16(&sample);
00326 return ret;
00327 case SAMPTYPE_FLOAT32:
00328 ret=FBlock::get((BYTE*)&f32,sSize)/sSize;
00329 if (endian>0) endian_fromlittle32(&f32); else if (endian<0) endian_frombig32(&f32);
00330 sample = sunnorm_i16(f32);
00331 return ret;
00332 case SAMPTYPE_FLOAT64:
00333 ret=FBlock::get((BYTE*)&f64,sSize)/sSize;
00334 if (endian>0) endian_fromlittle64(&f64); else if (endian<0) endian_frombig64(&f64);
00335 sample = sunnorm_i16(f64);
00336 return ret;
00337 }
00338
00339 die_beep("Samp: invalid SampType (%ld)",(long)tSamp);
00340 return 0;
00341 }
00342
00343
00344
00345 UINT Samp::getNoCh( DOUBLE& sample )
00346 {
00347 UINT8 u8;
00348 INT16 i16;
00349 FLOAT32 f32;
00350 FLOAT64 f64;
00351 UINT ret;
00352
00353 switch (tSamp) {
00354 case SAMPTYPE_PCM8U:
00355 ret = FBlock::get((BYTE*)&u8,sSize)/sSize;
00356 sample = norm_i16((((INT16)u8)-128)<<8);
00357 return ret;
00358 case SAMPTYPE_PCM16:
00359 ret = FBlock::get((BYTE*)&i16,sSize)/sSize;
00360 if (endian>0) endian_fromlittle16(&i16); else if (endian<0) endian_frombig16(&i16);
00361 sample = norm_i16(i16);
00362 return ret;
00363 case SAMPTYPE_FLOAT32:
00364 ret=FBlock::get((BYTE*)&f32,sSize)/sSize;
00365 if (endian>0) endian_fromlittle32(&f32); else if (endian<0) endian_frombig32(&f32);
00366 sample = f32;
00367 return ret;
00368 case SAMPTYPE_FLOAT64:
00369 ret=FBlock::get((BYTE*)&f64,sSize)/sSize;
00370 if (endian>0) endian_fromlittle64(&f64); else if (endian<0) endian_frombig64(&f64);
00371 sample=f64;
00372 return ret;
00373 }
00374
00375 die_beep("Samp: invalid SampType (%li)",(long)tSamp);
00376 return 0;
00377 }
00378
00379
00380
00381 UINT Samp::insNoCh( INT16 sample )
00382 {
00383 UINT8 u8;
00384 FLOAT32 f32;
00385 FLOAT64 f64;
00386 UINT ret;
00387
00388 #ifdef FLUSH_WHEN_WRITE
00389 nptr=-1;
00390 #endif
00391 switch (tSamp) {
00392 case SAMPTYPE_PCM8U:
00393 u8 = (sample>>8)+128;
00394 ret=FBlock::ins((BYTE*)&u8,sSize)/sSize;
00395 return ret;
00396 case SAMPTYPE_PCM16:
00397 if (endian>0) endian_tolittle16(&sample); else if (endian<0) endian_tobig16(&sample);
00398 return FBlock::ins((BYTE*)&sample,sSize)/sSize;
00399 case SAMPTYPE_FLOAT32:
00400 f32 = norm_i16(sample);
00401 if (endian>0) endian_tolittle32(&f32); else if (endian<0) endian_tobig32(&f32);
00402 ret=FBlock::ins((BYTE*)&f32,sSize)/sSize;
00403 return ret;
00404 case SAMPTYPE_FLOAT64:
00405 f64 = norm_i16(sample);
00406 if (endian>0) endian_tolittle64(&f64); else if (endian<0) endian_tobig64(&f64);
00407 ret=FBlock::ins((BYTE*)&f64,sSize)/sSize;
00408 return ret;
00409 }
00410
00411 die_beep("Samp: invalid SampType (%li)",(long)tSamp);
00412 return 0;
00413 }
00414
00415
00416
00417 UINT Samp::insNoCh( DOUBLE sample )
00418 {
00419 UINT8 u8;
00420 INT16 i16;
00421 FLOAT32 f32;
00422 FLOAT64 f64;
00423 UINT ret;
00424
00425 #ifdef FLUSH_WHEN_WRITE
00426 nptr=-1;
00427 #endif
00428 switch (tSamp) {
00429 case SAMPTYPE_PCM8U:
00430 u8 = (sunnorm_i16(sample)>>8)+128;
00431 ret=FBlock::ins((BYTE*)&u8,sSize)/sSize;
00432 return ret;
00433 case SAMPTYPE_PCM16:
00434 i16 = sunnorm_i16(sample);
00435 if (endian>0) endian_tolittle16(&i16); else if (endian<0) endian_tobig16(&i16);
00436 ret = FBlock::ins((BYTE*)&i16,sSize)/sSize;
00437 return ret;
00438 case SAMPTYPE_FLOAT32:
00439 f32 = sample;
00440 if (endian>0) endian_tolittle32(&f32); else if (endian<0) endian_tobig32(&f32);
00441 ret=FBlock::ins((BYTE*)&f32,sSize)/sSize;
00442 return ret;
00443 case SAMPTYPE_FLOAT64:
00444 f64 = sample;
00445 if (endian>0) endian_tolittle64(&f64); else if (endian<0) endian_tobig64(&f64);
00446 ret=FBlock::ins((BYTE*)&f64,sSize)/sSize;
00447 return ret;
00448 }
00449
00450 die_beep("Samp: invalid SampType (%li)",(long)tSamp);
00451 return 0;
00452 }
00453
00454
00455
00456 UINT Samp::setNoCh( INT16 sample )
00457 {
00458 UINT8 u8;
00459 FLOAT32 f32;
00460 FLOAT64 f64;
00461 UINT ret;
00462
00463 #ifdef FLUSH_WHEN_WRITE
00464 nptr=-1;
00465 #endif
00466 switch (tSamp) {
00467 case SAMPTYPE_PCM8U:
00468 u8 = (sample>>8)+128;
00469 ret=FBlock::set((BYTE*)&u8,sSize)/sSize;
00470 return ret;
00471 case SAMPTYPE_PCM16:
00472 if (endian>0) endian_tolittle16(&sample); else if (endian<0) endian_tobig16(&sample);
00473 return FBlock::set((BYTE*)&sample,sSize)/sSize;
00474 case SAMPTYPE_FLOAT32:
00475 f32 = norm_i16(sample);
00476 if (endian>0) endian_tolittle32(&f32); else if (endian<0) endian_tobig32(&f32);
00477 ret=FBlock::set((BYTE*)&f32,sSize)/sSize;
00478 return ret;
00479 case SAMPTYPE_FLOAT64:
00480 f64 = norm_i16(sample);
00481 if (endian>0) endian_tolittle64(&f64); else if (endian<0) endian_tobig64(&f64);
00482 ret=FBlock::set((BYTE*)&f64,sSize)/sSize;
00483 return ret;
00484 }
00485
00486 die_beep("Samp: invalid SampType (%li)",(long)tSamp);
00487 return 0;
00488 }
00489
00490
00491
00492 UINT Samp::setNoCh( DOUBLE sample )
00493 {
00494 UINT8 u8;
00495 INT16 i16;
00496 FLOAT32 f32;
00497 FLOAT64 f64;
00498 UINT ret;
00499
00500 #ifdef FLUSH_WHEN_WRITE
00501 nptr=-1;
00502 #endif
00503 switch (tSamp) {
00504 case SAMPTYPE_PCM8U:
00505 u8= (sunnorm_i16(sample)>>8) + 128;
00506 ret = FBlock::set((BYTE*)&u8,sSize)/sSize;
00507 return ret;
00508 case SAMPTYPE_PCM16:
00509 i16 = sunnorm_i16(sample);
00510 if (endian>0) endian_tolittle16(&i16); else if (endian<0) endian_tobig16(&i16);
00511 ret = FBlock::set((BYTE*)&i16,sSize)/sSize;
00512 return ret;
00513 case SAMPTYPE_FLOAT32:
00514 f32 = sample;
00515 if (endian>0) endian_tolittle32(&f32); else if (endian<0) endian_tobig32(&f32);
00516 ret=FBlock::set((BYTE*)&f32,sSize)/sSize;
00517 return ret;
00518 case SAMPTYPE_FLOAT64:
00519 f64 = sample;
00520 if (endian>0) endian_tolittle64(&f64); else if (endian<0) endian_tobig64(&f64);
00521 ret=FBlock::set((BYTE*)&f64,sSize)/sSize;
00522 return ret;
00523 }
00524
00525 die_beep("Samp: invalid SampType (%li)",(long)tSamp);
00526 return 0;
00527 }
00528
00529
00530
00531 UINT Samp::getBlkNoCh( INT16* block, UINT len )
00532 {
00533 #ifdef __LITTLE_ENDIAN__
00534 if ((tSamp==SAMPTYPE_PCM16)&&(endian>=0))
00535 return FBlock::get((BYTE*)block,len*sSize)/sSize;
00536 #endif
00537 #ifdef __BIG_ENDIAN__
00538 if ((tSamp==SAMPTYPE_PCM16)&&(endian<=0))
00539 return FBlock::get((BYTE*)block,len*sSize)/sSize;
00540 #endif
00541
00542
00543 UINT n = 0;
00544 while (len--) n+=getNoCh(*(block++));
00545 return n;
00546 }
00547
00548
00549
00550 UINT Samp::getBlkNoCh( DOUBLE* block, UINT len )
00551 {
00552 #if (SIZEOF_DOUBLE==8)
00553 #ifdef __LITTLE_ENDIAN__
00554 if ((tSamp==SAMPTYPE_FLOAT64)&&(endian>=0))
00555 return FBlock::get((BYTE*)block,len*sSize)/sSize;
00556 #endif
00557 #ifdef __BIG_ENDIAN__
00558 if ((tSamp==SAMPTYPE_FLOAT64)&&(endian<=0))
00559 return FBlock::get((BYTE*)block,len*sSize)/sSize;
00560 #endif
00561 #endif
00562
00563 #if (SIZEOF_DOUBLE==4)
00564 #ifdef __LITTLE_ENDIAN__
00565 if ((tSamp==SAMPTYPE_FLOAT32)&&(endian>=0))
00566 return FBlock::get((BYTE*)block,len*sSize)/sSize;
00567 #endif
00568 #ifdef __BIG_ENDIAN__
00569 if ((tSamp==SAMPTYPE_FLOAT32)&&(endian<=0))
00570 return FBlock::get((BYTE*)block,len*sSize)/sSize;
00571 #endif
00572 #endif
00573
00574
00575 UINT n = 0;
00576 while (len--) n+=getNoCh(*(block++));
00577 return n;
00578 }
00579
00580
00581
00582 UINT Samp::setBlkNoCh( const INT16* block, UINT len )
00583 {
00584 #ifdef FLUSH_WHEN_WRITE
00585 nptr=-1;
00586 #endif
00587
00588 #ifdef __LITTLE_ENDIAN__
00589 if ((tSamp==SAMPTYPE_PCM16)&&(endian>=0))
00590 return FBlock::set((BYTE*)block,len*sSize)/sSize;
00591 #endif
00592 #ifdef __BIG_ENDIAN__
00593 if ((tSamp==SAMPTYPE_PCM16)&&(endian<=0))
00594 return FBlock::set((BYTE*)block,len*sSize)/sSize;
00595 #endif
00596
00597 if (!block) return FBlock::set(NULL,len*sSize)/sSize;
00598
00599 UINT n = 0;
00600 while (len--) n+=setNoCh(*(block++));
00601 return n;
00602 }
00603
00604
00605
00606 UINT Samp::setBlkNoCh( const DOUBLE* block, UINT len )
00607 {
00608 #ifdef FLUSH_WHEN_WRITE
00609 nptr=-1;
00610 #endif
00611
00612 #if (SIZEOF_DOUBLE==8)
00613 #ifdef __LITTLE_ENDIAN__
00614 if ((tSamp==SAMPTYPE_FLOAT64)&&(endian>=0))
00615 return FBlock::set((BYTE*)block,len*sSize)/sSize;
00616 #endif
00617 #ifdef __BIG_ENDIAN__
00618 if ((tSamp==SAMPTYPE_FLOAT64)&&(endian<=0))
00619 return FBlock::set((BYTE*)block,len*sSize)/sSize;
00620 #endif
00621 #endif
00622
00623 #if (SIZEOF_DOUBLE==4)
00624 #ifdef __LITTLE_ENDIAN__
00625 if ((tSamp==SAMPTYPE_FLOAT32)&&(endian>=0))
00626 return FBlock::set((BYTE*)block,len*sSize)/sSize;
00627 #endif
00628 #ifdef __BIG_ENDIAN__
00629 if ((tSamp==SAMPTYPE_FLOAT32)&&(endian<=0))
00630 return FBlock::set((BYTE*)block,len*sSize)/sSize;
00631 #endif
00632 #endif
00633
00634 if (!block) return FBlock::set(NULL,len*sSize)/sSize;
00635
00636 UINT n = 0;
00637 while (len--) n+=setNoCh(*(block++));
00638 return n;
00639 }
00640
00641
00642
00643 UINT Samp::insBlkNoCh( const INT16* block, UINT len )
00644 {
00645 #ifdef FLUSH_WHEN_WRITE
00646 nptr=-1;
00647 #endif
00648
00649 #ifdef __LITTLE_ENDIAN__
00650 if ((tSamp==SAMPTYPE_PCM16)&&(endian>=0))
00651 return FBlock::ins((BYTE*)block,len*sSize)/sSize;
00652 #endif
00653 #ifdef __BIG_ENDIAN__
00654 if ((tSamp==SAMPTYPE_PCM16)&&(endian<=0))
00655 return FBlock::ins((BYTE*)block,len*sSize)/sSize;
00656 #endif
00657
00658 if (!block) return FBlock::ins(NULL,len*sSize)/sSize;
00659
00660 UINT n = 0;
00661 while (len--)
00662 n+=insNoCh(*(block++));
00663 return n;
00664 }
00665
00666
00667
00668 UINT Samp::insBlkNoCh( const DOUBLE* block, UINT len )
00669 {
00670 #ifdef FLUSH_WHEN_WRITE
00671 nptr=-1;
00672 #endif
00673
00674 #if (SIZEOF_DOUBLE==8)
00675 #ifdef __LITTLE_ENDIAN__
00676 if ((tSamp==SAMPTYPE_FLOAT64)&&(endian>=0))
00677 return FBlock::ins((BYTE*)block,len*sSize)/sSize;
00678 #endif
00679 #ifdef __BIG_ENDIAN__
00680 if ((tSamp==SAMPTYPE_FLOAT64)&&(endian<=0))
00681 return FBlock::ins((BYTE*)block,len*sSize)/sSize;
00682 #endif
00683 #endif
00684
00685 #if (SIZEOF_DOUBLE==4)
00686 #ifdef __LITTLE_ENDIAN__
00687 if ((tSamp==SAMPTYPE_FLOAT32)&&(endian>=0))
00688 return FBlock::ins((BYTE*)block,len*sSize)/sSize;
00689 #endif
00690 #ifdef __BIG_ENDIAN__
00691 if ((tSamp==SAMPTYPE_FLOAT32)&&(endian<=0))
00692 return FBlock::ins((BYTE*)block,len*sSize)/sSize;
00693 #endif
00694 #endif
00695
00696
00697 if (!block) return FBlock::ins(NULL,len*sSize)/sSize;
00698
00699 UINT n = 0;
00700 while (len--) n+=insNoCh(*(block++));
00701 return n;
00702 }
00703
00704
00705
