メインページ | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcRLE.c

#include "dkcRLE.h"

dkcRLE.cのインクルード依存関係図

Include dependency graph

ソースコードを見る。

構成

struct  ABSResult

マクロ定義

#define DKUTIL_C_RLE_C
#define DKC_MSA_PUSH(a, d, s)   dkcMemoryStreamAdapterPushBack(a,d,s)

列挙型

enum  { rleABS_FINDRUN = -2, rleABS_FAILED = -1, rleABS_SUCCEEDED = 0 }

関数

DKC_RLE *WINAPI dkcAllocRLE ()
int WINAPI dkcFreeRLE (DKC_RLE **pp)
BYTEsetPack (BYTE *dest, char count, BYTE data)
int WINAPI dkcRLEPackBitsEncode (DKC_RLE_PACKBITS_HEADER *p, BYTE *dest, size_t dsize, const BYTE *src, size_t ssize, BYTE a_count)
DKC_EXTERN int WINAPI dkcRLEPackBitsDecode (DKC_RLE_PACKBITS_HEADER *p, BYTE *dest, size_t dsize, const BYTE *src, size_t ssize)


マクロ定義

#define DKC_MSA_PUSH a,
d,
 )     dkcMemoryStreamAdapterPushBack(a,d,s)
 

参照元 dkcRLEPackBitsEncode().

#define DKUTIL_C_RLE_C
 

dkcRLE.c7 行で定義されています。


列挙型

anonymous enum
 

列挙型の値:
rleABS_FINDRUN  RLE圧縮出来そうなのが見つかった.
rleABS_FAILED  失敗
rleABS_SUCCEEDED  成功

dkcRLE.c27 行で定義されています。

00027     {
00029     rleABS_FINDRUN = -2,
00031     rleABS_FAILED = -1,
00033     rleABS_SUCCEEDED = 0,
00034 };


関数

DKC_RLE* WINAPI dkcAllocRLE  ) 
 

dkcRLE.c12 行で定義されています。

00012                              {
00013     DKC_RLE *p = (DKC_RLE *)dkcAllocate(sizeof(DKC_RLE));
00014     return p;
00015 }

int WINAPI dkcFreeRLE DKC_RLE **  pp  ) 
 

dkcRLE.c17 行で定義されています。

00017                                    {
00018     if(NULL==pp){
00019         return edk_FAILED;
00020     }
00021     return dkcFree((void **)pp);
00022 }

DKC_EXTERN int WINAPI dkcRLEPackBitsDecode DKC_RLE_PACKBITS_HEADER p,
BYTE dest,
size_t  dsize,
const BYTE src,
size_t  ssize
 

dkcRLE.c177 行で定義されています。

参照先 BYTE, DKC_EXTERN, DKC_RLE_PACKBITS_HEADER, dkcmNOT_ASSERT, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, dkc_RLEPackBits_Header::mCount, と dkc_RLEPackBits_Header::mOriginSize.

00180 {
00181     const char *pt;
00182     int a_count = p->mCount;
00183     BYTE *po = dest,*sentinel = dest + dsize;
00184     size_t temp;
00185     size_t i = 0;
00186     int r = edk_FAILED;
00187 
00188     //DKC_MEMORYSTREAM_ADAPTER ad,bd;
00189 
00190     //dkcMemoryStreamAdapterInit(&ad,dest,dsize);
00191 
00192     if(dsize < p->mOriginSize){
00193         return edk_ArgumentException;
00194     }
00195     for(;;){
00196         pt = (const char *)&src[i];
00197         i++;
00198         if(*pt <= -a_count){
00199             temp = (size_t)(-(*pt));
00200             memset(po,src[i],temp);
00201             
00202             po += temp;
00203             i++;
00204         }else{
00205             //dkcmNOT_ASSERT(*pt == 0);
00206             dkcmNOT_ASSERT(*pt <= 0);
00207             temp = (size_t)(*pt);
00208             memcpy(po,&src[i],temp);
00209             i += temp;
00210             po += temp;
00211         }
00212         if(!(i < ssize)){
00213             r = edk_SUCCEEDED;
00214             break;
00215         }
00216         if(po == sentinel){
00217             break;
00218         }
00219     }//end of for
00220     return r;
00221 }

int WINAPI dkcRLEPackBitsEncode DKC_RLE_PACKBITS_HEADER p,
BYTE dest,
size_t  dsize,
const BYTE src,
size_t  ssize,
BYTE  a_count
 

dkcRLE.c56 行で定義されています。

参照先 BYTE, DKC_MEMORYSTREAM_ADAPTER, DKC_MSA_PUSH, DKC_RLE_PACKBITS_HEADER, dkcCheckOverflowULONG(), dkcMemoryStreamAdapterGetOffset(), dkcMemoryStreamAdapterInit(), dkcMemoryStreamAdapterPointer(), dkcMemoryStreamAdapterPopBack(), dkcMemoryStreamAdapterPushBackMacro, edk_ArgumentException, edk_FAILED, edk_SUCCEEDED, と dkc_MemoryStreamAdapter::mNowOffset.

00058 {   
00059     int r = edk_FAILED;
00060     size_t i = 0;
00061     int count = 0;
00062     size_t ti = 0;
00063     size_t break_c = 0;
00064     DKC_MEMORYSTREAM_ADAPTER ad,bd;
00065     BYTE buff[128 + 2];
00066     //size_t bc = 0;
00067     BYTE t;
00068     
00069     dkcMemoryStreamAdapterInit(&ad,dest,dsize);
00070     dkcMemoryStreamAdapterInit(&bd,buff,sizeof(buff));
00071 
00072 
00073 
00074 #   define DKC_MSA_PUSH(a,d,s) dkcMemoryStreamAdapterPushBack(a,d,s)
00075     memset(p,0,sizeof(*p));
00076     if(dkcCheckOverflowULONG((ULONG)dest,dsize)){
00077         return edk_FAILED;
00078     }
00079     if(dsize < ssize * 2){
00080         return edk_ArgumentException;
00081     }
00082     if(CHAR_MAX < a_count || a_count <= 1){
00083         return edk_ArgumentException;
00084     }
00085 
00086     for(;;){
00087         count = 1;
00088         
00089         t = src[i];
00090         ti = i;
00091         i++;
00092         for(;;){
00093             
00094             if(t != src[i]){
00095                 break;
00096             }
00097             
00098             count++;
00099             if(count >= -CHAR_MIN){
00100                 break;
00101             }
00102             i++;
00103             if(!(i < ssize)){
00104                 r = edk_SUCCEEDED;
00105                 break;
00106             }
00107         }
00108 
00109         if((size_t)count >= a_count){
00110             dkcMemoryStreamAdapterPushBackMacro(char,&ad,-count);
00111             dkcMemoryStreamAdapterPushBackMacro(BYTE,&ad,t);
00112         }else{
00113             i = ti;
00114             count = 0;
00115             break_c = 1;
00116             if(i != 0){
00117                 t = src[i - 1];
00118             }else{
00119                 t = (BYTE)(src[i] + 1);
00120             }
00121 
00122 
00123             for(;;){
00124                 if(t == src[i]){
00125                     if(1 == break_c){
00126                         ti = i - 1;
00127                     }
00128                     break_c++;
00129                     if(break_c >= a_count){
00130                         
00131                         count -= i - ti;
00132                         dkcMemoryStreamAdapterPopBack(&bd,i - ti);
00133                         i = ti;
00134                         break;
00135                     }
00136                     
00137                 }else{
00138                     break_c = 1;
00139                     
00140                 }
00141                 dkcMemoryStreamAdapterPushBackMacro(BYTE,&bd,src[i]);
00142 
00143                 count++;
00144                 if(count >= CHAR_MAX){
00145                     break;
00146                 }
00147                 i++;
00148                 if(!(i < ssize)){
00149                     r = edk_SUCCEEDED;
00150                     break;
00151                 }
00152                 
00153                 t = src[i - 1];
00154             }
00155             dkcMemoryStreamAdapterPushBackMacro(BYTE,&ad,count);
00156             
00157             DKC_MSA_PUSH(&ad,
00158                 dkcMemoryStreamAdapterPointer(&bd),dkcMemoryStreamAdapterGetOffset(&bd)
00159             );
00160         }
00161         
00162         bd.mNowOffset = 0;
00163 
00164         if(!(i < ssize)){
00165             r = edk_SUCCEEDED;
00166             break;
00167         }
00168     }//end of for
00169 
00170 #   undef DKC_MSA_PUSH
00171     p->mCompressedSize = dkcMemoryStreamAdapterGetOffset(&ad);
00172     p->mOriginSize = ssize;
00173     p->mCount = (int)a_count;
00174     return r;
00175 }

BYTE* setPack BYTE dest,
char  count,
BYTE  data
[static]
 

dkcRLE.c43 行で定義されています。

参照先 BYTE.

00043                                                       {
00044     char *tc;
00045     tc = (char *)dest;
00046     *tc = count;
00047     dest++;
00048     *dest = data;
00049     dest++;
00050     return dest;
00051 }


dkutil_cに対してTue Oct 19 03:36:05 2004に生成されました。 doxygen 1.3.6