00001
00007 #include "dkcCircularMemoryStream.h"
00008 #include "dkcStdio.h"
00009
00010
00011 DKC_CIRCULAR_MEMORYSTREAM * WINAPI dkcAllocCircularMemoryStream(size_t size)
00012 {
00013 DKC_CIRCULAR_MEMORYSTREAM *p = NULL;
00014
00015 p = (DKC_CIRCULAR_MEMORYSTREAM *)dkcAllocate(sizeof(DKC_CIRCULAR_MEMORYSTREAM));
00016 if(NULL==p) return NULL;
00017
00018 p->mBuffer = dkcAllocate(size);
00019 if(NULL==p->mBuffer) goto Error;
00020
00021 p->mStart = 0;
00022 p->mEnd = 0;
00023 p->mEnableLength = 0;
00024 p->mSize = size;
00025
00026 return p;
00027 Error:
00028 dkcFree(&p);
00029 return NULL;
00030 }
00031
00032 int WINAPI dkcFreeCircularMemoryStream(DKC_CIRCULAR_MEMORYSTREAM **ptr){
00033 if(NULL==ptr){return edk_ArgumentException;}
00034 dkcFree(&(*ptr)->mBuffer);
00035 return dkcFree(ptr);
00036 }
00037
00038
00039 static DKC_INLINE BOOL isDoubleProcess(size_t start,size_t data_length,size_t border_size)
00040 {
00041 return (start + data_length > border_size);
00042 }
00043
00044
00045
00046 static int WINAPI dkcCircularMemoryStreamReadLogic(
00047 DKC_CIRCULAR_MEMORYSTREAM *RingBuf,void *Buf , size_t Len,size_t *readsize,BOOL PeekFlag)
00048 {
00049 if(NULL==RingBuf || NULL==RingBuf->mBuffer || NULL==readsize)
00050 return edk_ArgumentException;
00051
00052 if( RingBuf->mEnableLength==0) return edk_FAILED;
00053
00054 if( RingBuf->mEnableLength < Len )
00055 {
00056
00057
00058 Len = RingBuf->mEnableLength;
00059
00060 }else{
00061
00062
00063 }
00064
00065 *readsize = Len;
00066
00067
00068 if( isDoubleProcess(RingBuf->mStart, Len, RingBuf->mSize) )
00069 {
00070
00071 memcpy( Buf,
00072 (char *)RingBuf->mBuffer + RingBuf->mStart,
00073 RingBuf->mSize - RingBuf->mStart ) ;
00074 memcpy( (char *)Buf + ( RingBuf->mSize - RingBuf->mStart ),
00075 RingBuf->mBuffer,
00076 Len - ( RingBuf->mSize - RingBuf->mStart ) ) ;
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086 if( PeekFlag == FALSE ) RingBuf->mStart = Len - ( RingBuf->mSize - RingBuf->mStart ) ;
00087 }
00088 else
00089 {
00090
00091 memcpy( Buf, (char *)RingBuf->mBuffer + RingBuf->mStart, Len ) ;
00092
00093
00094
00095
00096 if( PeekFlag == FALSE ) RingBuf->mStart += Len ;
00097 }
00098
00099
00100 if( PeekFlag == FALSE ) RingBuf->mEnableLength -= Len ;
00101 return edk_SUCCEEDED;
00102 }
00103
00104
00105 int WINAPI dkcCircularMemoryStreamRead(DKC_CIRCULAR_MEMORYSTREAM *ptr,void *buffer,size_t size,size_t *readsize)
00106 {
00107 return dkcCircularMemoryStreamReadLogic(ptr,buffer,size,readsize,FALSE);
00108 }
00109
00110 int WINAPI dkcCircularMemoryStreamReference(DKC_CIRCULAR_MEMORYSTREAM *ptr,void *buffer,size_t size,size_t *readsize)
00111 {
00112 return dkcCircularMemoryStreamReadLogic(ptr,buffer,size,readsize,TRUE);
00113 }
00114
00115
00116
00117 int WINAPI dkcCircularMemoryStreamWrite(DKC_CIRCULAR_MEMORYSTREAM *ptr,const void *buffer,size_t size){
00118 if(NULL==ptr || NULL==buffer || 0==size ) return edk_ArgumentException;
00119
00120
00121
00122 if(ptr->mSize - ptr->mEnableLength < size) return edk_FAILED;
00123
00124
00125 if(isDoubleProcess(ptr->mEnd,size,ptr->mSize))
00126 {
00127
00128 memcpy( (char *)ptr->mBuffer + ptr->mEnd, buffer, ptr->mSize - ptr->mEnd ) ;
00129 memcpy( ptr->mBuffer, (char *)buffer + ( ptr->mSize - ptr->mEnd ), size - ( ptr->mSize - ptr->mEnd ) ) ;
00130
00131
00132
00133 ptr->mEnd = size - ( ptr->mSize - ptr->mEnd ) ;
00134 }else{
00135
00136 memcpy( (char *)ptr->mBuffer + ptr->mEnd, buffer, size ) ;
00137
00138 ptr->mEnd += size ;
00139 }
00140
00141
00142
00143 ptr->mEnableLength += size;
00144 return edk_SUCCEEDED;
00145 }
00146
00147
00148 int WINAPI dkcCircularMemoryStreamClear(DKC_CIRCULAR_MEMORYSTREAM *ptr){
00149
00150 if(NULL==ptr || NULL==ptr->mBuffer){return edk_ArgumentException;}
00151
00152 ptr->mEnableLength = 0;
00153 ptr->mEnd = 0;
00154
00155 ptr->mStart = 0;
00156
00157
00158 return edk_SUCCEEDED;
00159 }
00160
00161
00162 int WINAPI dkcCircularMemoryStreamToBuffer(
00163 const DKC_CIRCULAR_MEMORYSTREAM *ptr,char *buff,size_t size,size_t want_size)
00164 {
00165
00166 return edk_SUCCEEDED;
00167 }
00168
00169 DKC_CIRCULAR_MEMORYSTREAM *WINAPI
00170 dkcAllocCircularMemoryStreamCopy(const DKC_CIRCULAR_MEMORYSTREAM *ptr)
00171 {
00172 DKC_CIRCULAR_MEMORYSTREAM *p;
00173
00174 dkcmNOT_ASSERT(NULL==ptr);
00175
00176 p = dkcAllocCircularMemoryStream(ptr->mSize);
00177
00178
00179 if(NULL==p) return NULL;
00180
00181 dkcmNOT_ASSERT(DKUTIL_FAILED(
00182 dkc_memcpy(p->mBuffer,p->mSize,ptr->mBuffer,ptr->mSize)
00183 ));
00184
00185 p->mEnableLength = ptr->mEnableLength;
00186 p->mEnd = p->mEnd;
00187 p->mStart = p->mStart;
00188
00189
00190 return p;
00191 }
00192
00193
00194