00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 #define KATE_INTERNAL
00011 #include "kate_internal.h"
00012 
00013 #ifdef HAVE_STRING_H
00014 #include <string.h>
00015 #endif
00016 #include "kate/kate.h"
00017 #include "kate_rle.h"
00018 
00019 
00020 
00021 
00022 #define KATE_RLE_RUN_LENGTH_BITS_BASIC 4
00023 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_IN_DELTA 3
00024 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND 3
00025 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP 6
00026 #define KATE_RLE_RUN_LENGTH_BITS_DELTA 6
00027 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_START 9
00028 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_END 8
00029 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP_START 8
00030 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_IN_DELTA_STOP 3
00031 #define KATE_RLE_RUN_LENGTH_BITS_DELTA_STOP 5
00032 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_ZERO 8
00033 #define KATE_RLE_RUN_LENGTH_BITS_BASIC_NON_ZERO 3
00034 
00035 #define KATE_RLE_TYPE_EMPTY 0
00036 #define KATE_RLE_TYPE_BASIC 1
00037 #define KATE_RLE_TYPE_DELTA 2
00038 #define KATE_RLE_TYPE_BASIC_STOP 3
00039 #define KATE_RLE_TYPE_BASIC_STARTEND 4
00040 #define KATE_RLE_TYPE_DELTA_STOP 5
00041 #define KATE_RLE_TYPE_BASIC_ZERO 6
00042 
00043 #define KATE_RLE_TYPE_BITS 3
00044 
00045 #define kate_unused __attribute__((unused))
00046 
00047 static size_t get_run_length(size_t max_run_length,size_t count,const unsigned char *values)
00048 {
00049   const size_t limit=max_run_length>count?count:max_run_length;
00050   size_t run_length=1;
00051   while (run_length<limit && values[run_length]==values[0])
00052     ++run_length;
00053   return run_length;
00054 }
00055 
00056 static size_t get_run_length_identical(size_t max_run_length,size_t count,const unsigned char *values,const unsigned char *previous,unsigned char zero)
00057 {
00058   const size_t limit=max_run_length>count?count:max_run_length;
00059   size_t run_length=0;
00060   if (previous) {
00061     while (run_length<limit && values[run_length]==previous[run_length])
00062       ++run_length;
00063   }
00064   else {
00065     while (run_length<limit && values[run_length]==zero)
00066       ++run_length;
00067   }
00068   return run_length;
00069 }
00070 
00071 static size_t get_run_length_zero(size_t max_run_length,size_t count,const unsigned char *values,unsigned char zero)
00072 {
00073   const size_t limit=max_run_length>count?count:max_run_length;
00074   size_t run_length=1;
00075   while (run_length<limit && values[run_length]==zero)
00076     ++run_length;
00077   return run_length;
00078 }
00079 
00080 static size_t get_run_length_zero_back(size_t max_run_length,size_t count,const unsigned char *values,size_t nvalues,unsigned char zero)
00081 {
00082   const size_t limit=max_run_length>count?count:max_run_length;
00083   size_t run_length=0;
00084   while (run_length<limit && values[nvalues-1-run_length]==zero)
00085     ++run_length;
00086   return run_length;
00087 }
00088 
00089 static int kate_rle_encode_line_basic(size_t count,const unsigned char *values,size_t bits,unsigned char zero kate_unused,const unsigned char *previous kate_unused,kate_pack_buffer *kpb)
00090 {
00091   const size_t run_length_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC;
00092   const size_t run_length_cutoff=1<<run_length_bits;
00093   size_t run_length,max_run_length;
00094 
00095   while (count>0) {
00096     max_run_length=run_length_cutoff;
00097     run_length=get_run_length(max_run_length,count,values);
00098     kate_pack_write(kpb,run_length-1,run_length_bits);
00099     kate_pack_write(kpb,values[0],bits);
00100     values+=run_length;
00101     count-=run_length;
00102   }
00103 
00104   return 0;
00105 }
00106 
00107 static int kate_rle_encode_line_basic_zero(size_t count,const unsigned char *values,size_t bits,unsigned char zero kate_unused,const unsigned char *previous kate_unused,kate_pack_buffer *kpb)
00108 {
00109   const size_t run_length_bits_zero=KATE_RLE_RUN_LENGTH_BITS_BASIC_ZERO;
00110   const size_t run_length_bits_non_zero=KATE_RLE_RUN_LENGTH_BITS_BASIC_NON_ZERO;
00111   const size_t run_length_zero_cutoff=1<<run_length_bits_zero;
00112   const size_t run_length_non_zero_cutoff=1<<run_length_bits_non_zero;
00113   size_t run_length,max_run_length,run_length_bits;
00114 
00115   while (count>0) {
00116     if (values[0]==zero) {
00117       max_run_length=run_length_zero_cutoff;
00118       run_length_bits=run_length_bits_zero;
00119     }
00120     else {
00121       max_run_length=run_length_non_zero_cutoff;
00122       run_length_bits=run_length_bits_non_zero;
00123     }
00124     run_length=get_run_length(max_run_length,count,values);
00125     kate_pack_write(kpb,values[0],bits);
00126     kate_pack_write(kpb,run_length-1,run_length_bits);
00127     values+=run_length;
00128     count-=run_length;
00129   }
00130 
00131   return 0;
00132 }
00133 
00134 static int kate_rle_encode_line_basic_startend(size_t count,const unsigned char *values,size_t bits,unsigned char zero,const unsigned char *previous kate_unused,kate_pack_buffer *kpb)
00135 {
00136   const size_t run_length_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND;
00137   const size_t run_length_cutoff=1<<run_length_bits;
00138   size_t run_length,run_length_start,run_length_end,max_run_length;
00139 
00140   max_run_length=(1<<KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_START)-1;
00141   run_length_start=get_run_length_zero(max_run_length,count,values,zero);
00142   kate_pack_write(kpb,run_length_start,KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_START);
00143   values+=run_length_start;
00144   count-=run_length_start;
00145 
00146   max_run_length=(1<<KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_END)-1;
00147   run_length_end=get_run_length_zero_back(max_run_length,count,values,count,zero);
00148   kate_pack_write(kpb,run_length_end,KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_END);
00149   count-=run_length_end;
00150 
00151   while (count>0) {
00152     max_run_length=run_length_cutoff;
00153     run_length=get_run_length(max_run_length,count,values);
00154     kate_pack_write(kpb,run_length-1,run_length_bits);
00155     kate_pack_write(kpb,values[0],bits);
00156     values+=run_length;
00157     count-=run_length;
00158   }
00159 
00160   return 0;
00161 }
00162 
00163 static int kate_rle_encode_line_basic_stop(size_t count,const unsigned char *values,size_t bits,unsigned char zero,const unsigned char *previous kate_unused,kate_pack_buffer *kpb)
00164 {
00165   const size_t run_length_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP;
00166   const size_t run_length_cutoff=(1<<run_length_bits)-1;
00167   size_t run_length,run_length_start,max_run_length;
00168 
00169   max_run_length=(1<<KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP_START)-1;
00170   run_length_start=get_run_length_zero(max_run_length,count,values,zero);
00171   kate_pack_write(kpb,run_length_start,KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP_START);
00172   values+=run_length_start;
00173   count-=run_length_start;
00174 
00175   while (count>0) {
00176     if (values[0]==zero) {
00177       run_length=get_run_length(count,count,values);
00178       if (run_length==count) {
00179         kate_pack_write(kpb,0,run_length_bits);
00180         break;
00181       }
00182     }
00183     max_run_length=run_length_cutoff;
00184     run_length=get_run_length(max_run_length,count,values);
00185     kate_pack_write(kpb,run_length,run_length_bits);
00186     kate_pack_write(kpb,values[0],bits);
00187     values+=run_length;
00188     count-=run_length;
00189   }
00190 
00191   return 0;
00192 }
00193 
00194 static int kate_rle_encode_line_empty(size_t count,const unsigned char *values,size_t bits kate_unused,unsigned char zero,const unsigned char *previous kate_unused,kate_pack_buffer *kpb kate_unused)
00195 {
00196   size_t run_length=get_run_length_zero(count,count,values,zero);
00197   if (run_length<count) return -1;
00198   return 0;
00199 }
00200 
00201 static int kate_rle_encode_line_delta(size_t count,const unsigned char *values,size_t bits,unsigned char zero kate_unused,const unsigned char *previous,kate_pack_buffer *kpb)
00202 {
00203   const size_t run_length_delta_bits=KATE_RLE_RUN_LENGTH_BITS_DELTA;
00204   const size_t run_length_delta_cutoff=(1<<run_length_delta_bits);
00205   const size_t run_length_basic_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_IN_DELTA;
00206   const size_t run_length_basic_cutoff=(1<<run_length_basic_bits);
00207   size_t max_run_length_delta,max_run_length_basic;
00208   size_t run_length_delta,run_length_basic;
00209 
00210   while (count>0) {
00211     max_run_length_delta=run_length_delta_cutoff;
00212     run_length_delta=get_run_length_identical(max_run_length_delta,count,values,previous,zero);
00213 
00214     max_run_length_basic=run_length_basic_cutoff;
00215     run_length_basic=get_run_length(max_run_length_basic,count,values);
00216 
00217     if (run_length_delta>run_length_basic) {
00218       kate_pack_write(kpb,1,1);
00219       kate_pack_write(kpb,run_length_delta-1,run_length_delta_bits);
00220       values+=run_length_delta;
00221       if (previous) previous+=run_length_delta;
00222       count-=run_length_delta;
00223     }
00224     else {
00225       kate_pack_write(kpb,0,1);
00226       kate_pack_write(kpb,run_length_basic-1,run_length_basic_bits);
00227       kate_pack_write(kpb,values[0],bits);
00228       values+=run_length_basic;
00229       if (previous) previous+=run_length_basic;
00230       count-=run_length_basic;
00231     }
00232   }
00233 
00234   return 0;
00235 }
00236 
00237 static int kate_rle_encode_line_delta_stop(size_t count,const unsigned char *values,size_t bits,unsigned char zero,const unsigned char *previous,kate_pack_buffer *kpb)
00238 {
00239   const size_t run_length_delta_bits=KATE_RLE_RUN_LENGTH_BITS_DELTA_STOP;
00240   const size_t run_length_delta_cutoff=(1<<run_length_delta_bits);
00241   const size_t run_length_basic_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_IN_DELTA_STOP;
00242   const size_t run_length_basic_cutoff=(1<<run_length_basic_bits)-1;
00243   size_t max_run_length_delta,max_run_length_basic;
00244   size_t run_length_delta,run_length_basic,run_length;
00245 
00246   while (count>0) {
00247     if (values[0]==zero) {
00248       run_length=get_run_length(count,count,values);
00249       if (run_length==count) {
00250         kate_pack_write(kpb,0,1);
00251         kate_pack_write(kpb,0,run_length_basic_bits);
00252         break;
00253       }
00254     }
00255 
00256     max_run_length_delta=run_length_delta_cutoff;
00257     run_length_delta=get_run_length_identical(max_run_length_delta,count,values,previous,zero);
00258 
00259     max_run_length_basic=run_length_basic_cutoff;
00260     run_length_basic=get_run_length(max_run_length_basic,count,values);
00261 
00262     if (run_length_delta>run_length_basic) {
00263       kate_pack_write(kpb,1,1);
00264       run_length=run_length_delta;
00265       kate_pack_write(kpb,run_length-1,run_length_delta_bits);
00266     }
00267     else {
00268       kate_pack_write(kpb,0,1);
00269       run_length=run_length_basic;
00270       kate_pack_write(kpb,run_length,run_length_basic_bits);
00271       kate_pack_write(kpb,values[0],bits);
00272     }
00273     values+=run_length;
00274     if (previous) previous+=run_length;
00275     count-=run_length;
00276   }
00277 
00278   return 0;
00279 }
00280 
00281 #ifdef DEBUG
00282 int kate_rle_stats[8]={0};
00283 int kate_rle_stats_overall[8]={0};
00284 #endif
00285 
00286 static int kate_rle_try_encoding(kate_pack_buffer *kpb,int (*encoder)(size_t,const unsigned char*,size_t,unsigned char,const unsigned char*,kate_pack_buffer*),size_t width,const unsigned char *values,size_t bits,unsigned char zero,const unsigned char *previous,int kpb_type,int type)
00287 {
00288   kate_pack_buffer tmp;
00289   kate_pack_writeinit(&tmp);
00290   if ((*encoder)(width,values,bits,zero,previous,&tmp)==0) {
00291     long kpb_size=kate_pack_bits(kpb);
00292     long tmp_size=kate_pack_bits(&tmp);
00293     if (kpb_type<0 || tmp_size<kpb_size) {
00294       kate_pack_writeclear(kpb);
00295       memcpy(kpb,&tmp,sizeof(tmp));
00296       return type;
00297     }
00298   }
00299   kate_pack_writeclear(&tmp);
00300   return kpb_type;
00301 }
00302 
00303 static unsigned char get_zero(size_t count,const unsigned char *values)
00304 {
00305   int counts[256],n,best=0;
00306   memset(counts,0,sizeof(counts));
00307   while (count-->0) ++counts[*values++];
00308   for (n=0;n<256;++n) if (counts[n]>counts[best]) best=n;
00309   return best;
00310 }
00311 
00312 static int kate_rle_encode_best(size_t width,size_t height,const unsigned char *values,size_t bits,kate_pack_buffer *kpb)
00313 {
00314   const unsigned char *previous=NULL;
00315   const unsigned char zero=get_zero(width*height,values);
00316 
00317 #ifdef DEBUG
00318   memset(kate_rle_stats,0,sizeof(kate_rle_stats));
00319 #endif
00320 
00321   kate_pack_write(kpb,zero,bits);
00322   while (height>0) {
00323     int best_type=-1;
00324     kate_pack_buffer best_buffer;
00325     kate_pack_writeinit(&best_buffer);
00326 
00327     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_empty,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_EMPTY);
00328     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_delta,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_DELTA);
00329     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_basic,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_BASIC);
00330     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_basic_startend,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_BASIC_STARTEND);
00331     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_basic_stop,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_BASIC_STOP);
00332     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_delta_stop,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_DELTA_STOP);
00333     best_type=kate_rle_try_encoding(&best_buffer,&kate_rle_encode_line_basic_zero,width,values,bits,zero,previous,best_type,KATE_RLE_TYPE_BASIC_ZERO);
00334 
00335 #ifdef DEBUG
00336     ++kate_rle_stats[best_type];
00337     ++kate_rle_stats_overall[best_type];
00338 #endif
00339 
00340     kate_pack_write(kpb,best_type,KATE_RLE_TYPE_BITS);
00341     kate_pack_writecopy(kpb,kate_pack_get_buffer(&best_buffer),kate_pack_bits(&best_buffer));
00342 
00343     kate_pack_writeclear(&best_buffer);
00344 
00345     previous=values;
00346 
00347     values+=width;
00348     --height;
00349   }
00350 
00351   return 0;
00352 }
00353 
00354 int kate_rle_encode(size_t width,size_t height,const unsigned char *values,size_t bits,kate_pack_buffer *kpb)
00355 {
00356   return kate_rle_encode_best(width,height,values,bits,kpb);
00357 }
00358 
00359 static int kate_rle_decode_line_empty(size_t count,unsigned char *values,size_t bits kate_unused,unsigned char zero,kate_pack_buffer *kpb kate_unused)
00360 {
00361   memset(values,zero,count);
00362   return 0;
00363 }
00364 
00365 static int kate_rle_decode_line_basic(size_t count,unsigned char *values,size_t bits,kate_pack_buffer *kpb)
00366 {
00367   const size_t run_length_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC;
00368   size_t run_length;
00369   int value;
00370 
00371   while (count>0) {
00372     run_length=1+kate_pack_read(kpb,run_length_bits);
00373     if (run_length==0 || run_length>count) return KATE_E_BAD_PACKET;
00374     value=kate_pack_read(kpb,bits);
00375     memset(values,value,run_length);
00376     values+=run_length;
00377     count-=run_length;
00378   }
00379 
00380   return 0;
00381 }
00382 
00383 static int kate_rle_decode_line_basic_zero(size_t count,unsigned char *values,size_t bits,unsigned char zero,kate_pack_buffer *kpb)
00384 {
00385   const size_t run_length_bits_zero=KATE_RLE_RUN_LENGTH_BITS_BASIC_ZERO;
00386   const size_t run_length_bits_non_zero=KATE_RLE_RUN_LENGTH_BITS_BASIC_NON_ZERO;
00387   size_t run_length;
00388   int value;
00389 
00390   while (count>0) {
00391     value=kate_pack_read(kpb,bits);
00392     if (value==zero) {
00393       run_length=1+kate_pack_read(kpb,run_length_bits_zero);
00394     }
00395     else {
00396       run_length=1+kate_pack_read(kpb,run_length_bits_non_zero);
00397     }
00398     if (run_length==0 || run_length>count) return KATE_E_BAD_PACKET;
00399     memset(values,value,run_length);
00400     values+=run_length;
00401     count-=run_length;
00402   }
00403 
00404   return 0;
00405 }
00406 
00407 static int kate_rle_decode_line_basic_stop(size_t count,unsigned char *values,size_t bits,unsigned char zero,kate_pack_buffer *kpb)
00408 {
00409   const size_t run_length_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP;
00410   size_t run_length;
00411   int value;
00412 
00413   run_length=kate_pack_read(kpb,KATE_RLE_RUN_LENGTH_BITS_BASIC_STOP_START);
00414   if (run_length>0) {
00415     if (run_length>count) return KATE_E_BAD_PACKET;
00416     memset(values,zero,run_length);
00417     values+=run_length;
00418     count-=run_length;
00419   }
00420 
00421   while (count>0) {
00422     run_length=kate_pack_read(kpb,run_length_bits);
00423     if (run_length>count) return KATE_E_BAD_PACKET;
00424     if (run_length==0) {
00425       memset(values,zero,count);
00426       break;
00427     }
00428     value=kate_pack_read(kpb,bits);
00429     memset(values,value,run_length);
00430     values+=run_length;
00431     count-=run_length;
00432   }
00433 
00434   return 0;
00435 }
00436 
00437 static int kate_rle_decode_line_basic_startend(size_t count,unsigned char *values,size_t bits,unsigned char zero,kate_pack_buffer *kpb)
00438 {
00439   const size_t run_length_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND;
00440   size_t run_length;
00441   int value;
00442 
00443   run_length=kate_pack_read(kpb,KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_START);
00444   if (run_length>0) {
00445     if (run_length>count) return KATE_E_BAD_PACKET;
00446     memset(values,zero,run_length);
00447     values+=run_length;
00448     count-=run_length;
00449   }
00450 
00451   run_length=kate_pack_read(kpb,KATE_RLE_RUN_LENGTH_BITS_BASIC_STARTEND_END);
00452   if (run_length>0) {
00453     if (run_length>count) return KATE_E_BAD_PACKET;
00454     memset(values+count-run_length,zero,run_length);
00455     count-=run_length;
00456   }
00457 
00458   while (count>0) {
00459     run_length=1+kate_pack_read(kpb,run_length_bits);
00460     if (run_length_bits==0 || run_length>count) return KATE_E_BAD_PACKET;
00461     value=kate_pack_read(kpb,bits);
00462     memset(values,value,run_length);
00463     values+=run_length;
00464     count-=run_length;
00465   }
00466 
00467   return 0;
00468 }
00469 
00470 static int kate_rle_decode_line_delta(size_t count,unsigned char *values,const unsigned char *previous,size_t bits,unsigned char zero,kate_pack_buffer *kpb)
00471 {
00472   const size_t run_length_delta_bits=KATE_RLE_RUN_LENGTH_BITS_DELTA;
00473   const size_t run_length_basic_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_IN_DELTA;
00474   int value;
00475 
00476   while (count>0) {
00477     int type=kate_pack_read1(kpb);
00478     if (type) {
00479       size_t run_length=1+kate_pack_read(kpb,run_length_delta_bits);
00480       if (run_length==0 || run_length>count) return KATE_E_BAD_PACKET;
00481       if (previous) {
00482         memcpy(values,previous,run_length);
00483         previous+=run_length;
00484       }
00485       else {
00486         memset(values,zero,run_length);
00487       }
00488       values+=run_length;
00489       count-=run_length;
00490     }
00491     else {
00492       size_t run_length=1+kate_pack_read(kpb,run_length_basic_bits);
00493       if (run_length==0 || run_length>count) return KATE_E_BAD_PACKET;
00494       value=kate_pack_read(kpb,bits);
00495       memset(values,value,run_length);
00496       values+=run_length;
00497       if (previous) previous+=run_length;
00498       count-=run_length;
00499     }
00500   }
00501   return 0;
00502 }
00503 
00504 static int kate_rle_decode_line_delta_stop(size_t count,unsigned char *values,const unsigned char *previous,size_t bits,unsigned char zero,kate_pack_buffer *kpb)
00505 {
00506   const size_t run_length_delta_bits=KATE_RLE_RUN_LENGTH_BITS_DELTA_STOP;
00507   const size_t run_length_basic_bits=KATE_RLE_RUN_LENGTH_BITS_BASIC_IN_DELTA_STOP;
00508   size_t run_length;
00509   int value,type;
00510 
00511   while (count>0) {
00512     type=kate_pack_read1(kpb);
00513     if (type) {
00514       run_length=1+kate_pack_read(kpb,run_length_delta_bits);
00515       if (run_length==0 || run_length>count) return KATE_E_BAD_PACKET;
00516       if (previous) {
00517         memcpy(values,previous,run_length);
00518       }
00519       else {
00520         memset(values,zero,run_length);
00521       }
00522     }
00523     else {
00524       run_length=kate_pack_read(kpb,run_length_basic_bits);
00525       if (run_length==0) {
00526         memset(values,zero,count);
00527         break;
00528       }
00529       if (run_length>count) return KATE_E_BAD_PACKET;
00530       value=kate_pack_read(kpb,bits);
00531       memset(values,value,run_length);
00532     }
00533     values+=run_length;
00534     if (previous) previous+=run_length;
00535     count-=run_length;
00536   }
00537   return 0;
00538 }
00539 
00540 static int kate_rle_decode_best(size_t width,size_t height,unsigned char *values,size_t bits,kate_pack_buffer *kpb)
00541 {
00542   const unsigned char *previous=NULL;
00543   int ret;
00544 
00545   const unsigned char zero=kate_pack_read(kpb,bits);
00546   while (height>0) {
00547     int type=kate_pack_read(kpb,KATE_RLE_TYPE_BITS);
00548     switch (type) {
00549       case KATE_RLE_TYPE_EMPTY:
00550         ret=kate_rle_decode_line_empty(width,values,bits,zero,kpb);
00551         break;
00552       case KATE_RLE_TYPE_DELTA:
00553         ret=kate_rle_decode_line_delta(width,values,previous,bits,zero,kpb);
00554         break;
00555       case KATE_RLE_TYPE_BASIC:
00556         ret=kate_rle_decode_line_basic(width,values,bits,kpb);
00557         break;
00558       case KATE_RLE_TYPE_BASIC_STARTEND:
00559         ret=kate_rle_decode_line_basic_startend(width,values,bits,zero,kpb);
00560         break;
00561       case KATE_RLE_TYPE_BASIC_STOP:
00562         ret=kate_rle_decode_line_basic_stop(width,values,bits,zero,kpb);
00563         break;
00564       case KATE_RLE_TYPE_DELTA_STOP:
00565         ret=kate_rle_decode_line_delta_stop(width,values,previous,bits,zero,kpb);
00566         break;
00567       case KATE_RLE_TYPE_BASIC_ZERO:
00568         ret=kate_rle_decode_line_basic_zero(width,values,bits,zero,kpb);
00569         break;
00570       default:
00571         ret=KATE_E_BAD_PACKET;
00572         break;
00573     }
00574     if (ret<0) return ret;
00575 
00576     previous=values;
00577     values+=width;
00578     --height;
00579   }
00580 
00581   return 0;
00582 }
00583 
00584 int kate_rle_decode(size_t width,size_t height,unsigned char *values,size_t bits,kate_pack_buffer *kpb)
00585 {
00586   return kate_rle_decode_best(width,height,values,bits,kpb);
00587 }
00588