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

dkcRLE.h

#include "dkcOSIndependent.h"
#include "dkcMemoryStream.h"

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

Include dependency graph

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

Included by dependency graph

ソースコードを見る。

構成

struct  dkc_RLE
struct  dkc_RLE_Header
struct  dkc_RLE_Comp
struct  dkc_RLE_NoComp
struct  dkc_RLEPackBits_Header

マクロ定義

#define dkcdRLE_EOF_ID   0x01
#define dkcdRLE_NOCOMPRESS_ID   0x00
#define dkcdRLE_SIGNATURE   'RLE\0'
 RLEのシグネチャ(変更しても大丈夫だよ〜(多分)).


型定義

typedef dkc_RLE DKC_RLE
typedef dkc_RLE_Header DKC_RLE_HEADER
typedef dkc_RLE_Comp DKC_RLE_COMP
typedef dkc_RLE_NoComp DKC_RLE_NOCOMP
typedef dkc_RLEPackBits_Header DKC_RLE_PACKBITS_HEADER

関数

DKC_EXTERN DKC_RLE *WINAPI dkcAllocRLE ()
DKC_EXTERN int WINAPI dkcFreeRLE (DKC_RLE **)
DKC_EXTERN int WINAPI dkcRLEEncode (DKC_RLE *ptr, DKC_MEMORYSTREAM *pms, DKC_RLE_HEADER *ph, BYTE *dest, size_t dsize, const BYTE *src, USHORT ssize, size_t CloseProcessSize, ULONG sig, BYTE aEOF_ID, BYTE aABS_ID)
DKC_EXTERN int WINAPI dkcRLEDecode (DKC_RLE *p, DKC_MEMORYSTREAM *pms, const DKC_RLE_HEADER *ph, const BYTE *src, USHORT ssize, ULONG sig)
DKC_EXTERN int WINAPI dkcRLEPackBitsEncode (DKC_RLE_PACKBITS_HEADER *p, BYTE *dest, size_t dsize, const BYTE *src, size_t ssize, BYTE count)
DKC_EXTERN int WINAPI dkcRLEPackBitsDecode (DKC_RLE_PACKBITS_HEADER *p, BYTE *dest, size_t dsize, const BYTE *src, size_t ssize)


マクロ定義

#define dkcdRLE_EOF_ID   0x01
 

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

#define dkcdRLE_NOCOMPRESS_ID   0x00
 

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

#define dkcdRLE_SIGNATURE   'RLE\0'
 

RLEのシグネチャ(変更しても大丈夫だよ〜(多分)).

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


型定義

typedef struct dkc_RLE DKC_RLE
 

参照元 dkcAllocRLE(), dkcFreeRLE(), dkcRLEDecode(), と dkcRLEEncode().

typedef struct dkc_RLE_Comp DKC_RLE_COMP
 

参照元 getRLE().

typedef struct dkc_RLE_Header DKC_RLE_HEADER
 

参照元 dkcRLEDecode(), と dkcRLEEncode().

typedef struct dkc_RLE_NoComp DKC_RLE_NOCOMP
 

参照元 dkcRLEDecode(), と getABS().

typedef struct dkc_RLEPackBits_Header DKC_RLE_PACKBITS_HEADER
 

参照元 dkcRLEPackBitsDecode(), と dkcRLEPackBitsEncode().


関数

DKC_EXTERN DKC_RLE* WINAPI dkcAllocRLE  ) 
 

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

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

DKC_EXTERN int WINAPI dkcFreeRLE DKC_RLE **   ) 
 

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

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

DKC_EXTERN int WINAPI dkcRLEDecode DKC_RLE p,
DKC_MEMORYSTREAM pms,
const DKC_RLE_HEADER ph,
const BYTE src,
USHORT  ssize,
ULONG  sig
 

引数:
ptr[in][out] dkcAllocRLE()で取得したポインタ
pms[in][out] dkcAllocMemoryStream()で取得したMemory Stream Objectへのポインタ
ph[out] DKC_RLE_HEADERへのポインタ
src[in] バッファへのポインタ
ssize[in] srcのサイズ
sig[in] RLEだと証明するシグネチャ
戻り値:
edk_Resultのどれかが返る。圧縮する価値の無い場合はedk_NoValueToProcessが返る。

trash/dkcRLE.c251 行で定義されています。

00254 {
00255 
00256     size_t i=0;
00257     BYTE t;
00258     //DKC_RLE_COMP co;
00259     DKC_RLE_NOCOMP nco;
00260     //今のオフセット
00261     size_t old_mem_offset = dkcMemoryStreamTell(pms);
00262     
00263     if(ph->mSignature != sig){
00264         return edk_SignatureException;
00265     }
00266 
00267     for(;i<ssize;i++)
00268     {
00269         t = src[i];
00270         if(t==ph->mABS){
00271             memcpy(&nco,&src[i],sizeof(nco));
00272             dkcMemoryStreamWrite(pms,&src[i],nco.length);
00273         }
00274         else if(t == ph->mEOF)
00275         {
00276             break;
00277         }else{//compressed
00278             if(t <= 1){
00279                 goto BACK;
00280             }
00281             memset(p->mTemp,src[i + 1],t);
00282             dkcMemoryStreamWrite(pms,&(p->mTemp),t);
00283 
00284             //一つ分update
00285             i++;
00286         }
00287     }//end of for
00288     
00289     return edk_SUCCEEDED;
00290 BACK:
00291 
00292     dkcMemoryStreamSeek(pms,old_mem_offset,edkcMemoryStreamSeekSet);
00293 
00294     return edk_FAILED;
00295 
00296 
00297 }

DKC_EXTERN int WINAPI dkcRLEEncode DKC_RLE ptr,
DKC_MEMORYSTREAM pms,
DKC_RLE_HEADER ph,
BYTE dest,
size_t  dsize,
const BYTE src,
USHORT  ssize,
size_t  CloseProcessSize,
ULONG  sig,
BYTE  aEOF_ID,
BYTE  aABS_ID
 

引数:
ptr[in][out] dkcAllocRLE()で取得したポインタ
ph[out] DKC_RLE_HEADERへのポインタ
dest[out] デコードされたデータの書き出しバッファへのポインタ
dsize[in] destのサイズ (srcの2倍用意してください。)
src[in] バッファへのポインタ
ssize[in] srcのサイズ
sig[in] dkcRLEEncode()の時、指定したシグネチャID
CloseProcessSize[in] 処理を打ち切りにするサイズ
aEOF_ID[in] RLEのEOFを示す値≠指定する事を奨励する
aABS_ID[in] RLEの非圧縮を示す値 dkcdRLE_NOCOMPRESS_IDを指定する事を奨励する
戻り値:
戻り値はedk_SUCCEEDEDで成功。 どちらの条件でも処理を打ち切りにするサイズを超えたらedk_NoValueToProcessが返る。 それ以外はその戻り値によって各自判断。
覚え書き:
DKC_RLE_HEADERのメンバのmOriginSizeよりdsizeが小さいとこの関数は失敗します。 チョットしたネタ: dkcRLEEncodeって命名なんか変じゃない? Run Length Encode Encode ... ?? まぁ、仕様って事で・・・

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 }

DKC_EXTERN int WINAPI dkcRLEPackBitsEncode DKC_RLE_PACKBITS_HEADER p,
BYTE dest,
size_t  dsize,
const BYTE src,
size_t  ssize,
BYTE  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 }


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