00001
00007 #define DKUTIL_C_STREAM_C
00008 #include "dkcOSIndependent.h"
00009 #include "dkcStream.h"
00010 #include "dkcStdio.h"
00011 #include "dkcMemoryStream.h"
00012 #include "dkcGenericFileSystem.h"
00013 #include <limits.h>
00014
00015
00016 static DKC_INLINE int SetStreamInfo(DKC_STREAM *p,UINT flag){
00017 UINT stream_mode = 0;
00018 BYTE endian_mode = 0;
00019 UINT proc_mode = 0;
00020
00021 BOOL isLittle = dkcIsLittleEndian();
00022
00023
00025 if(flag & edkcStreamInitMemory){
00026 stream_mode = edkcStreamInitMemory;
00027 }else if(flag & edkcStreamInitFile){
00028 stream_mode = edkcStreamInitFile;
00029 }else if(flag & edkcStreamInitMemoryAdapter){
00030 stream_mode = edkcStreamInitMemoryAdapter;
00031 }else if(flag & edkcStreamInitFile64){
00032 stream_mode = edkcStreamInitFile64;
00033 }else{
00034 goto Error;
00035 }
00036
00037
00038 endian_mode = FALSE;
00040 if(flag & edkcStreamBigEndian){
00041
00042 if(isLittle){
00043 endian_mode = TRUE;
00044 }
00045 }else if(flag & edkcStreamLittleEndian){
00046
00047 if(!isLittle){
00048 endian_mode = TRUE;
00049 }
00050 }else {
00051 if(isLittle){
00052
00053 }else{
00054
00055 }
00056 }
00057
00058
00059 proc_mode |= (flag & edkcStreamProcessDefault);
00060 if(0==proc_mode){
00061 proc_mode |= (flag & edkcStreamProcessAsOrdered);
00062
00063 if(0==proc_mode){
00064 proc_mode |= edkcStreamProcessAsOrdered;
00065 }
00066 }
00067 proc_mode |= (flag & edkcStreamWriteErrorWhenEndianChange );
00068
00069
00070 p->mMode = stream_mode;
00071
00072 dkcmNOT_ASSERT(proc_mode > UCHAR_MAX);
00073 p->mProcessMode = (BYTE)proc_mode;
00074
00075 p->mChangeEndian = endian_mode;
00076
00077 return edk_SUCCEEDED;
00078 Error:
00079 return edk_FAILED;
00080
00081 }
00082
00083
00084
00085
00086 DKC_STREAM *WINAPI dkcAllocStreamMemoryType(UINT flag,const void *default_data,size_t size){
00087 DKUTIL_FLAG_UP(flag,edkcStreamInitMemory);
00088 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00089 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
00090 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
00091 return dkcAllocStream(flag,default_data,size,NULL,NULL);
00092
00093 }
00094
00095 DKC_STREAM *WINAPI dkcAllocStreamFileType(UINT flag,const char *filename,const char *mode){
00096 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00097 DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00098 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
00099 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
00100 return dkcAllocStream(flag,NULL,0,filename,mode);
00101 }
00102
00103 DKC_STREAM *WINAPI dkcAllocStreamMemoryAdapterType(UINT flag,void *adapt_buffer,size_t size){
00104 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00105 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00106 DKUTIL_FLAG_UP(flag,edkcStreamInitMemoryAdapter);
00107 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile64);
00108 return dkcAllocStream(flag,adapt_buffer,size,NULL,NULL);
00109 }
00110
00111 DKC_STREAM *WINAPI dkcAllocStreamFile64Type(UINT flag,const char *filename,uint32 mode){
00112 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemory);
00113 DKUTIL_FLAG_DOWN(flag,edkcStreamInitFile);
00114 DKUTIL_FLAG_DOWN(flag,edkcStreamInitMemoryAdapter);
00115 DKUTIL_FLAG_UP(flag,edkcStreamInitFile64);
00116 return dkcAllocStream(flag,NULL,0,filename,(const char *)&mode);
00117
00118 }
00119
00120 DKC_STREAM *WINAPI dkcAllocStreamEncouragementFileType(const char *filename,const char *mode,BOOL OrderFlag)
00121 {
00122 UINT flag = 0;
00123 DKUTIL_FLAG_UP(flag,edkcStreamInitFile);
00124 DKUTIL_FLAG_UP(flag,edkcStreamLittleEndian);
00125 DKUTIL_FLAG_DOWN(flag,edkcStreamBigEndian);
00126 if(OrderFlag){
00127 DKUTIL_FLAG_UP(flag,edkcStreamProcessAsOrdered );
00128 }else{
00129 DKUTIL_FLAG_UP(flag,edkcStreamProcessDefault);
00130 }
00131 return dkcAllocStream(flag,NULL,0,filename,mode);
00132 }
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163 DKC_STREAM * WINAPI dkcAllocStream(UINT flag,
00164 const void *default_data,size_t size,
00165 const char *filename,const char *mode)
00166 {
00167
00168 DKC_STREAM *p;
00169 void *psig;
00170 const uint32 *use_flag = (const uint32 *)mode;
00171
00172 p = (DKC_STREAM *)dkcAllocate(sizeof(DKC_STREAM));
00173 if(NULL==p){
00174 return NULL;
00175 }
00176
00177 if(DKUTIL_FAILED(SetStreamInfo(p,flag))){
00178 goto Error;
00179 }
00180
00181 switch(p->mMode){
00182 case edkcStreamInitMemory:
00183 psig = (void *)dkcAllocMemoryStream(size);
00184 if(NULL==psig){
00185 goto Error;
00186 }
00187
00188 p->mSig = psig;
00189
00190 dkcStreamWrite(p,default_data,size);
00191 dkcStreamSeek(p,0,edkcStreamSeekSet);
00192 break;
00193 case edkcStreamInitFile:
00194 psig = (void *)dkcFOpen(filename,mode);
00195 if(NULL==psig){
00196 goto Error;
00197 }
00198
00199 p->mSig = psig;
00200
00201 break;
00202 case edkcStreamInitMemoryAdapter:
00203 psig = dkcAllocMemoryStreamAdapter((void *)default_data,size);
00204 if(NULL==psig){
00205 goto Error;
00206 }
00207 p->mSig = psig;
00208 case edkcStreamInitFile64:
00209 psig = dkcAllocFile64(*use_flag,filename);
00210 if(NULL==psig){
00211 goto Error;
00212 }
00213 p->mSig = psig;
00214 break;
00215 default:
00216 goto Error;
00217 }
00218
00219
00220
00221
00222 return p;
00223 Error:
00224 dkcFree((void **)&p);
00225 return NULL;
00226 }
00227
00228
00229 int WINAPI dkcFreeStream(DKC_STREAM **p){
00230 DKC_STREAM *t;
00231 if(NULL==p){
00232 return edk_FAILED;
00233 }
00234 t = *p;
00235 if(NULL==t){
00236 return edk_FAILED;
00237 }
00238
00239 switch(t->mMode){
00240 case edkcStreamInitMemory:
00241 dkcFreeMemoryStream((DKC_MEMORYSTREAM **)&(t->mSig));
00242 break;
00243 case edkcStreamInitFile:
00244 dkcFClose((FILE **)&(t->mSig));
00245 break;
00246 case edkcStreamInitMemoryAdapter:
00247 dkcFreeMemoryStreamAdapter((DKC_MEMORYSTREAM_ADAPTER **)&(t->mSig));
00248 break;
00249 case edkcStreamInitFile64:
00250 dkcFreeFile64((DKC_FILE64 **)&(t->mSig));
00251 break;
00252 #ifdef DEBUG
00253 default:
00254 dkcmNOT_ASSERT("dkcFreeStream FAILED");
00255 #endif
00256 }
00257 return dkcFree((void **)p);
00258 }
00259
00260
00261
00262
00263 int WINAPI dkcStreamSeek(DKC_STREAM *ptr,int offset,int origin){
00264 int r = edk_FAILED;
00265 switch(ptr->mMode){
00266 case edkcStreamInitMemory:
00267 r = dkcMemoryStreamSeek((DKC_MEMORYSTREAM *)ptr->mSig,offset,origin);
00268 break;
00269 case edkcStreamInitFile:
00270
00271 r = fseek((FILE *)ptr->mSig,offset,origin);
00272 break;
00273 case edkcStreamInitMemoryAdapter:
00274 r = dkcMemroyStreamAdapterSeek((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,offset,origin);
00275 break;
00276 case edkcStreamInitFile64:
00277 r = dkcFile64Seek((DKC_FILE64 *)ptr->mSig,offset,origin);
00278 break;
00279 }
00280 return r;
00281
00282 }
00283
00284
00285 int WINAPI dkcStreamTell64(DKC_STREAM *ptr,uint64 *pv){
00286 int r = edk_FAILED;
00287 switch(ptr->mMode){
00288 case edkcStreamInitMemory:
00289 r = dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
00290 *pv = r;
00291 break;
00292 case edkcStreamInitFile:
00293 r = ftell((FILE *)ptr->mSig);
00294 if(r==-1){
00295 return edk_FAILED;
00296 }
00297 *pv = r;
00298 break;
00299 case edkcStreamInitFile64:
00300 r = dkcFile64Tell((DKC_FILE64 *)ptr->mSig,pv);
00301 if(DKUTIL_FAILED(r)) return r;
00302 break;
00303 case edkcStreamInitMemoryAdapter:
00304 r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
00305 *pv = r;
00306 break;
00307 }
00308
00309 return edk_SUCCEEDED;
00310 }
00312 long WINAPI dkcStreamTell(DKC_STREAM *ptr){
00313 int r = -1;
00314 uint64 t;
00315 switch(ptr->mMode){
00316 case edkcStreamInitMemory:
00317 r = dkcMemoryStreamTell((DKC_MEMORYSTREAM *)ptr->mSig);
00318 break;
00319 case edkcStreamInitFile:
00320 r = ftell((FILE *)ptr->mSig);
00321 if(r==-1){
00322 return edk_FAILED;
00323 }
00324 break;
00325 case edkcStreamInitFile64:
00326 dkcFile64Tell((DKC_FILE64 *)ptr->mSig,&t);
00327 if(t > LONG_MAX){
00328 return -1;
00329 }
00330 r = (long)t;
00331 break;
00332 case edkcStreamInitMemoryAdapter:
00333 r = dkcMemoryStreamAdapterTell((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
00334 break;
00335 }
00336 return r;
00337
00338 }
00339
00340 int WINAPI dkcStreamFlush(DKC_STREAM *ptr){
00341 int r = edk_SUCCEEDED;
00342
00343 if(edkcStreamInitFile64==ptr->mMode){
00344 _flushall();
00345 return edk_SUCCEEDED;
00346 }
00347 if(edkcStreamInitFile!=ptr->mMode){
00348 return edk_FAILED;
00349 }
00350
00351 r = fflush((FILE *)ptr->mSig);
00352
00353 if(r==EOF){
00354 return edk_FAILED;
00355 }
00356 return edk_SUCCEEDED;
00357 }
00358
00359 BOOL WINAPI dkcStreamEOF(DKC_STREAM *ptr){
00360
00361
00362 if(edkcStreamInitFile64==ptr->mMode){
00363 return dkcFile64EOF((DKC_FILE64 *)ptr->mSig);
00364 }
00365 if(edkcStreamInitFile != ptr->mMode){
00366 goto Exit;
00367 }
00368 if(0 != feof((FILE *)ptr->mSig)){
00369 return TRUE;
00370 }
00371 Exit:
00372 return FALSE;
00373 }
00374
00375 BOOL WINAPI dkcStreamError(DKC_STREAM *ptr){
00376
00377 if(edkcStreamInitFile != ptr->mMode){
00378 goto Exit;
00379 }
00380 if(0 != ferror((FILE *)ptr->mSig)){
00381 return TRUE;
00382 }
00383 Exit:
00384 return FALSE;
00385 }
00386
00387
00388 static DKC_INLINE int dkcStreamReadObayAnOrder(
00389 DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize)
00390 {
00391 int r = edk_FAILED;
00392 size_t readsize_ = 0;
00393 size_t count;
00394 size_t tc,tsize;
00395 BYTE *tbuffer;
00396 FILE *fp = (FILE *)ptr->mSig;
00397
00398 if(NULL==readsize){
00399 readsize = &readsize_;
00400 }
00401
00402
00403
00404
00405 tsize = size;
00406
00407 tc = 0;
00408
00409 count = 0;
00410
00411 tbuffer = (BYTE *)buffer;
00412 for(;;)
00413 {
00414
00415 if(ferror(fp) ){
00416
00417 r = edk_FAILED;
00418 break;
00419 }
00420 if(feof(fp)){
00421
00422 r = edk_BufferOverFlow;
00423 break;
00424 }
00425
00426 tc = fread(&tbuffer[count],1,tsize,fp);
00427
00428 tsize -= tc;
00429 count += tc;
00430
00431 if(count == size){
00432 r = edk_SUCCEEDED;
00433 break;
00434 }
00435 # ifdef DEBUG
00436
00437 dkcmNOT_ASSERT(count > size);
00438 # else
00439 if(count > size){
00440 break;
00441 }
00442 # endif
00443 }
00444 *readsize = count;
00445 return r;
00446
00447 }
00448
00449 DKC_INLINE int WINAPI dkcStreamRead(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00450 int r = edk_FAILED;
00451 FILE *fp = (FILE *)ptr->mSig;
00452 size_t redsize = 0;
00453
00454
00455 if(NULL==readsize){
00456 readsize = &redsize;
00457 }
00458
00459
00460
00461
00462
00463
00464
00465
00466 switch(ptr->mMode){
00467 case edkcStreamInitMemory:
00468 r = dkcMemoryStreamRead((DKC_MEMORYSTREAM *)ptr->mSig,
00469 buffer,size,readsize);
00470 break;
00471 case edkcStreamInitFile:
00472
00473 if(ptr->mProcessMode & edkcStreamProcessDefault){
00474
00475 *readsize = fread(buffer,1,size,fp);
00476
00477
00478 if(feof(fp)){
00479 r = edk_BufferOverFlow;
00480 }else if(!ferror(fp)){
00481 r = edk_SUCCEEDED;
00482 }
00483
00484 }else{
00485 r = dkcStreamReadObayAnOrder(ptr,buffer,size,readsize);
00486 }
00487
00488
00489 break;
00490 case edkcStreamInitMemoryAdapter:
00491 r = dkcMemoryStreamAdapterRead((DKC_MEMORYSTREAM_ADAPTER *)
00492 ptr->mSig,buffer,size,readsize);
00493 break;
00494 case edkcStreamInitFile64:
00495 r = dkcFile64Read((DKC_FILE64*)ptr->mSig,buffer,size,readsize);
00496
00497 break;
00498 }
00499 return r;
00500 }
00501
00502 static int WINAPI StreamRead(DKC_STREAM *ptr, void *buffer,size_t size,void *hoge){
00503 return dkcStreamRead(ptr,buffer,size,(size_t *)hoge);
00504 }
00505
00507 int WINAPI dkcStreamRead8(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00508 return dkcStreamRead(ptr,buffer,size,readsize);
00509 }
00510
00511 int WINAPI dkcStreamRead16(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize)
00512 {
00513 return dkcStreamProcess16(ptr,buffer,size,StreamRead,(void *)readsize);
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559 }
00560
00561 int WINAPI dkcStreamRead32(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00562 return dkcStreamProcess32(ptr,buffer,size,StreamRead,(void *)readsize);
00563 }
00564
00565 int WINAPI dkcStreamRead64(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00566 return dkcStreamProcess64(ptr,buffer,size,StreamRead,(void *)readsize);
00567 }
00568
00569
00570 int WINAPI dkcStreamRef(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize)
00571 {
00572
00573 long t = dkcStreamTell(ptr);
00574
00575 int r = dkcStreamRead(ptr,buffer,size,readsize);
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00590 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00591 return r;
00592 }
00593
00594 int WINAPI dkcStreamRef16(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00595 long t = dkcStreamTell(ptr);
00596 int r = dkcStreamRead16(ptr,buffer,size,readsize);
00597 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00598 return r;
00599 }
00605 int WINAPI dkcStreamRef32(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00606 long t = dkcStreamTell(ptr);
00607 int r = dkcStreamRead32(ptr,buffer,size,readsize);
00608 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00609 return r;
00610 }
00615 int WINAPI dkcStreamRef64(DKC_STREAM *ptr,void *buffer,size_t size,size_t *readsize){
00616 long t = dkcStreamTell(ptr);
00617 int r = dkcStreamRead64(ptr,buffer,size,readsize);
00618 dkcStreamSeek(ptr,t,edkcStreamSeekSet);
00619 return r;
00620
00621 }
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636 static DKC_INLINE int dkcStreamWriteObayAnOrder(DKC_STREAM *ptr,const void *buffer,size_t size){
00637 int r = edk_FAILED;
00638 size_t tc,tsize;
00639 size_t count;
00640 const BYTE *tbuffer = (const BYTE *)buffer;
00641 FILE *fp;
00642
00643 tc = 0;
00644 count = 0;
00645 tsize = size;
00646 fp = (FILE *)ptr->mSig;
00647
00648 for(;;){
00649
00650 if(ferror(fp)){
00651 return edk_FAILED;
00652 }
00653 if(feof(fp)){
00654 return edk_BufferOverFlow;
00655 }
00656
00657 tc = fwrite(&tbuffer[count],1,tsize,fp);
00658
00659 tsize -= tc;
00660 count += tc;
00661
00662 if(count == size){
00663 r = edk_SUCCEEDED;
00664 break;
00665 }
00666 # ifdef DEBUG
00667
00668 dkcmNOT_ASSERT(count > size);
00669 # else
00670 if(count > size){
00671
00672 break;
00673 }
00674 # endif
00675
00676 }
00677
00678
00679 return r;
00680 }
00681
00682
00683 int WINAPI dkcStreamWriteWithWriteSize(DKC_STREAM *ptr,const void *buffer,size_t size,size_t *ws)
00684 {
00685 int r = edk_FAILED;
00686 UINT proc_flag = ptr->mProcessMode;
00688 if(proc_flag & edkcStreamWriteErrorWhenEndianChange){
00689 if(ptr->mChangeEndian){
00690 return edk_Not_Satisfactory;
00691 }
00692 }
00693
00694 switch(ptr->mMode){
00695 case edkcStreamInitMemory:
00696 r = dkcMemoryStreamWrite((DKC_MEMORYSTREAM *)ptr->mSig,buffer,size);
00697 break;
00698 case edkcStreamInitFile:
00699 r = dkcStreamWriteObayAnOrder(ptr,buffer,size);
00700 break;
00701 case edkcStreamInitMemoryAdapter:
00702 r = dkcMemoryStreamAdapterWrite((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig,buffer,size);
00703 break;
00704 case edkcStreamInitFile64:
00705 r = dkcFile64Write((DKC_FILE64*)ptr->mSig,buffer,size,ws);
00706
00707 break;
00708 }
00709
00710 return r;
00711
00712 }
00713
00714 static int WINAPI StreamWrite(DKC_STREAM *ptr, void *buffer,size_t size,void *hoge){
00715 return dkcStreamWrite(ptr,buffer,size);
00716 }
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745 int WINAPI dkcStreamWrite8(DKC_STREAM *ptr,void *buffer,size_t size){
00746 return dkcStreamWrite(ptr,buffer,size);
00747 }
00748 int WINAPI dkcStreamWrite16(DKC_STREAM *ptr, const void *buffer,size_t size){
00749 return dkcStreamProcess16(ptr,(void *)buffer,size,StreamWrite,NULL);
00750 }
00751
00752 int WINAPI dkcStreamWrite32(DKC_STREAM *ptr, const void *buffer,size_t size){
00753 return dkcStreamProcess32(ptr,(void *)buffer,size,StreamWrite,NULL);
00754
00755 }
00756
00757
00758
00759 int WINAPI dkcStreamWrite64(DKC_STREAM *ptr, const void *buffer,size_t size){
00760 return dkcStreamProcess64(ptr,(void *)buffer,size,StreamWrite,NULL);
00761 }
00762
00763
00764
00766 int WINAPI dkcStreamProcess(DKC_STREAM *ptr,void *buffer,size_t size,
00767 DKC_STREAM_PROCESS_TYPE write_t,void *data)
00768 {
00769 return write_t(ptr,buffer,size,data);
00770 }
00771
00772
00773
00774 int WINAPI dkcStreamProcess16(DKC_STREAM *ptr,void *buffer,size_t size,
00775 DKC_STREAM_PROCESS_TYPE write_t,void *data){
00776 int r;
00777 USHORT *pb;
00778 size_t elem_num,pause = 16;
00779 size_t i;
00780
00781 if(size % pause != 0){
00782 return edk_ArgumentException;
00783 }
00784 if(ptr->mChangeEndian)
00785 {
00786 pb = (USHORT *)malloc(size);
00787 if(NULL==pb){
00788
00789 return edk_OutOfMemory;
00790 }
00791
00792
00793 memcpy(pb,buffer,size);
00794 elem_num = size / pause;
00795
00796
00797 for(i=0;i<elem_num;i++){
00798 pb[i] = dkcReverseEndian16(pb[i]);
00799 }
00800
00801 r = write_t(ptr,pb,size,data);
00802
00803 free(pb);
00804 }else{
00805 r = write_t(ptr,buffer,size,data);
00806 }
00807 return r;
00808 }
00809
00810
00811 int WINAPI dkcStreamProcess32(DKC_STREAM *ptr,void *buffer,size_t size,
00812 DKC_STREAM_PROCESS_TYPE write_t,void *data){
00813 int r;
00814 ULONG *pb;
00815 size_t elem_num,pause = 32;
00816 size_t i;
00817
00818 if(size % pause != 0){
00819 return edk_ArgumentException;
00820 }
00821 if(ptr->mChangeEndian)
00822 {
00823 pb = (ULONG *)malloc(size);
00824 if(NULL==pb){
00825 return edk_OutOfMemory;
00826 }
00827
00828
00829 memcpy(pb,buffer,size);
00830 elem_num = size / pause;
00831
00832
00833 for(i=0;i<elem_num;i++){
00834 pb[i] = dkcReverseEndian32(pb[i]);
00835 }
00836
00837 r = write_t(ptr,pb,size,data);
00838
00839 free(pb);
00840 }else{
00841 r = write_t(ptr,buffer,size,data);
00842 }
00843 return r;
00844
00845 }
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856 int WINAPI dkcStreamProcess64(DKC_STREAM *ptr,void *buffer,size_t size,
00857 DKC_STREAM_PROCESS_TYPE write_t,void *data){
00858 int r;
00859 ULONGLONG *pb;
00860 size_t elem_num,pause = 64;
00861 size_t i;
00862
00863 if(size % pause != 0){
00864 return edk_ArgumentException;
00865 }
00866 if(ptr->mChangeEndian)
00867 {
00868 pb = (ULONGLONG *)malloc(size);
00869 if(NULL==pb){
00870 return edk_OutOfMemory;
00871 }
00872
00873
00874 memcpy(pb,buffer,size);
00875 elem_num = size / pause;
00876
00877
00878 for(i=0;i<elem_num;i++){
00879 pb[i] = dkcReverseEndian64(pb[i]);
00880 }
00881
00882 r = write_t(ptr,pb,size,data);
00883
00884 free(pb);
00885 }else{
00886 r = write_t(ptr,buffer,size,data);
00887 }
00888 return r;
00889 }
00890
00891
00892
00893
00894 int WINAPI dkcStreamClear(DKC_STREAM *ptr){
00895
00896 size_t fsize;
00897
00898 size_t tsize;
00899 size_t write_size;
00900 FILE *fp;
00901 int r = edk_FAILED;
00902 char null_array[1024];
00903
00904
00905 switch(ptr->mMode){
00906 case edkcStreamInitMemory:
00907 r = dkcMemoryStreamClear( (DKC_MEMORYSTREAM *)ptr->mSig );
00908 break;
00909 case edkcStreamInitFile:
00910
00911 memset(null_array,0,sizeof(null_array));
00912 fp =(FILE *) ptr->mSig;
00913
00914
00915 fseek( fp, 0, SEEK_END ) ;
00916 fsize = ftell( fp ) ;
00917 fseek( fp, 0, SEEK_SET ) ;
00918
00919 if(fsize > sizeof(null_array))
00920 {
00921
00922 tsize = 0;
00923 write_size = sizeof(null_array);
00924 for(;;){
00925
00926 r = dkcStreamWrite(ptr,null_array,write_size);
00927
00928 if(DKUTIL_FAILED(r)){
00929 return r;
00930 }
00931 if(tsize >= fsize){
00932 r = edk_SUCCEEDED;
00933 break;
00934 }
00935
00936 if(tsize + write_size > fsize){
00937 write_size = fsize - tsize;
00938 }else{
00939 tsize += write_size;
00940
00941
00942 write_size = sizeof(null_array);
00943 }
00944 }
00945 }else{
00946 r = dkcStreamWrite(ptr,null_array,fsize);
00947 }
00948
00949 break;
00950 case edkcStreamInitMemoryAdapter:
00951 r = dkcMemoryStreamAdapterClear((DKC_MEMORYSTREAM_ADAPTER *)ptr->mSig);
00952 break;
00953
00954
00955 }
00956 return r;
00957 }
00958