00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 #define KATE_INTERNAL
00011 #include "kate_internal.h"
00012 
00013 #ifdef HAVE_STDLIB_H
00014 #include <stdlib.h>
00015 #endif
00016 #ifdef HAVE_STRING_H
00017 #include <string.h>
00018 #endif
00019 #include "kate/kate.h"
00020 #include "kate_decode_state.h"
00021 #include "kate_fp.h"
00022 #include "kate_rle.h"
00023 
00025 typedef struct kate_memory_guard {
00026   size_t size;
00027   void **pointers;
00028 } kate_memory_guard;
00029 
00030 static void *kate_memory_guard_malloc(kate_memory_guard *kmg,size_t size)
00031 {
00032   void **new_pointers;
00033   void *ptr;
00034   int ret;
00035 
00036   ret=kate_check_add_overflow(kmg->size,1,NULL);
00037   if (ret<0) return NULL;
00038 
00039   ptr=kate_malloc(size);
00040   if (!ptr) return NULL;
00041   new_pointers=(void**)kate_checked_realloc(kmg->pointers,(kmg->size+1),sizeof(void*));
00042   if (!new_pointers) {
00043     kate_free(ptr);
00044     return NULL;
00045   }
00046   kmg->pointers=new_pointers;
00047   kmg->pointers[kmg->size++]=ptr;
00048   return ptr;
00049 }
00050 
00051 static void *kate_memory_guard_checked_malloc(kate_memory_guard *kmg,size_t size1,size_t size2)
00052 {
00053   size_t size;
00054   int ret=kate_check_mul_overflow(size1,size2,&size);
00055   if (ret<0) return NULL;
00056   return kate_memory_guard_malloc(kmg,size);
00057 }
00058 
00059 static void kate_memory_guard_destroy(kate_memory_guard *kmg,int free_pointers)
00060 {
00061   size_t n;
00062   if (free_pointers) {
00063     for (n=0;n<kmg->size;++n) kate_free(kmg->pointers[n]);
00064   }
00065   if (kmg->pointers) kate_free(kmg->pointers);
00066 }
00067 
00068 static int kate_memory_guard_merge(kate_memory_guard *kmg,kate_memory_guard *parent_kmg)
00069 {
00070   void **new_pointers;
00071   int ret;
00072   size_t new_size;
00073 
00074   ret=kate_check_add_overflow(parent_kmg->size,kmg->size,&new_size);
00075   if (ret<0) return ret;
00076 
00077   new_pointers=(void**)kate_checked_realloc(parent_kmg->pointers,new_size,sizeof(void*));
00078   if (!new_pointers) {
00079     kate_memory_guard_destroy(kmg,1);
00080     return KATE_E_OUT_OF_MEMORY;
00081   }
00082   parent_kmg->pointers=new_pointers;
00083   memcpy(parent_kmg->pointers+parent_kmg->size,kmg->pointers,kmg->size*sizeof(void*));
00084   parent_kmg->size=new_size;
00085   kate_memory_guard_destroy(kmg,0);
00086   return 0;
00087 }
00088 
00089 #define KMG_GUARD() kate_memory_guard kmg={0,NULL}
00090 #define KMG_MALLOC(size) kate_memory_guard_malloc(&kmg,size)
00091 #define KMG_CHECKED_MALLOC(size1,size2) kate_memory_guard_checked_malloc(&kmg,size1,size2)
00092 #define KMG_MERGE(parent_kmg) kate_memory_guard_merge(&kmg,parent_kmg)
00093 #define KMG_ERROR(ret) (kate_memory_guard_destroy(&kmg,1),ret)
00094 #define KMG_OK() (kate_memory_guard_destroy(&kmg,0),0)
00095 
00096 
00097 
00098 static int kate_readbuf(kate_pack_buffer *kpb,char *s,int len)
00099 {
00100   if (len<0) return KATE_E_INVALID_PARAMETER;
00101   if ((kate_pack_readable_bits(kpb)+7)/8<len) return KATE_E_BAD_PACKET;
00102   while (len--) *s++=kate_pack_read(kpb,8);
00103   return 0;
00104 }
00105 
00106 static kate_int32_t kate_read32(kate_pack_buffer *kpb)
00107 {
00108   kate_int32_t v=0;
00109   v|=kate_pack_read(kpb,8);
00110   v|=(kate_pack_read(kpb,8)<<8);
00111   v|=(kate_pack_read(kpb,8)<<16);
00112   v|=(kate_pack_read(kpb,8)<<24);
00113   return v;
00114 }
00115 
00116 static kate_int32_t kate_read32v(kate_pack_buffer *kpb)
00117 {
00118   
00119 
00120   int smallv=kate_pack_read(kpb,4);
00121   if (smallv==15) {
00122     int sign=kate_pack_read1(kpb);
00123     int bits=kate_pack_read(kpb,5)+1;
00124     kate_int32_t v=kate_pack_read(kpb,bits);
00125     if (sign) v=-v;
00126     return v;
00127   }
00128   else return smallv;
00129 }
00130 
00131 static kate_int64_t kate_read64(kate_pack_buffer *kpb)
00132 {
00133   kate_int32_t vl=kate_read32(kpb);
00134   kate_int32_t vh=kate_read32(kpb);
00135   return (0xffffffff&(kate_int64_t)vl)|(((kate_int64_t)vh)<<32);
00136 }
00137 
00138 static int kate_overread(kate_pack_buffer *kpb)
00139 {
00140   return kate_pack_look(kpb,0)<0;
00141 }
00142 
00143 static int kate_warp(kate_pack_buffer *kpb)
00144 {
00145   while (1) {
00146     kate_int32_t bits=kate_read32v(kpb);
00147     if (!bits) break;
00148     if (bits<0) return KATE_E_BAD_PACKET;
00149     kate_pack_adv(kpb,bits);
00150   }
00151   return 0;
00152 }
00153 
00154 static int kate_decode_check_magic(kate_pack_buffer *kpb)
00155 {
00156   char magic[8];
00157   int ret;
00158 
00159   if (!kpb) return KATE_E_INVALID_PARAMETER;
00160 
00161   ret=kate_readbuf(kpb,magic,7);
00162   if (ret<0) return KATE_E_NOT_KATE;
00163   if (memcmp(magic,"kate\0\0\0",7)) return KATE_E_NOT_KATE;
00164 
00165   return 0;
00166 }
00167 
00175 int kate_decode_is_idheader(const kate_packet *kp)
00176 {
00177   kate_pack_buffer kpb;
00178   unsigned char headerid;
00179 
00180   if (!kp) return 0;
00181 
00182   kate_pack_readinit(&kpb,kp->data,kp->nbytes);
00183   headerid=kate_pack_read(&kpb,8);
00184   if (headerid!=0x80) return 0;
00185 
00186   return !kate_decode_check_magic(&kpb);
00187 }
00188 
00189 static int kate_check_eop(kate_pack_buffer *kpb)
00190 {
00191   int bits;
00192 
00193   if (!kpb) return KATE_E_INVALID_PARAMETER;
00194 
00195   
00196   bits=7&(8-(kate_pack_bits(kpb)&7));
00197   if (bits>0) {
00198     if (kate_pack_read(kpb,bits)) return KATE_E_BAD_PACKET;
00199   }
00200   if (kate_pack_look1(kpb)>=0) return KATE_E_BAD_PACKET; 
00201 
00202   return 0;
00203 }
00204 
00205 static int kate_decode_read_canvas_size(kate_pack_buffer *kpb)
00206 {
00207   size_t base,shift;
00208 
00209   if (!kpb) return KATE_E_INVALID_PARAMETER;
00210 
00211   shift=kate_pack_read(kpb,4);
00212   base=kate_pack_read(kpb,4);
00213   base|=(kate_pack_read(kpb,8)<<4);
00214 
00215   return base<<shift;
00216 }
00217 
00218 #define KATE_IS_BITSTREAM_LOE(major,minor) (major)
00219 
00220 static int kate_decode_info_header(kate_info *ki,kate_pack_buffer *kpb)
00221 {
00222   KMG_GUARD();
00223   int len;
00224   int ret;
00225   char *language,*category;
00226   int reserved;
00227 
00228   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00229 
00230   ki->bitstream_version_major=kate_pack_read(kpb,8);
00231   ki->bitstream_version_minor=kate_pack_read(kpb,8);
00232   if (ki->bitstream_version_major>KATE_BITSTREAM_VERSION_MAJOR) return KMG_ERROR(KATE_E_VERSION);
00233 
00234   ki->num_headers=kate_pack_read(kpb,8);
00235   if (ki->num_headers<1) return KMG_ERROR(KATE_E_BAD_PACKET);
00236   ki->text_encoding=kate_pack_read(kpb,8);
00237   ki->text_directionality=kate_pack_read(kpb,8);
00238   reserved=kate_pack_read(kpb,8);
00239   if (ki->bitstream_version_major==0 && ki->bitstream_version_minor<3) {
00240     if (reserved!=0) return KMG_ERROR(KATE_E_BAD_PACKET); 
00241   }
00242   ki->granule_shift=kate_pack_read(kpb,8);
00243 
00244   ret=kate_decode_read_canvas_size(kpb);
00245   if (ret<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00246   ki->original_canvas_width=ret;
00247   ret=kate_decode_read_canvas_size(kpb);
00248   if (ret<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00249   ki->original_canvas_height=ret;
00250 
00251   reserved=kate_read32(kpb);
00252   if (ki->bitstream_version_major==0 && ki->bitstream_version_minor<3) {
00253     if (reserved!=0) return KMG_ERROR(KATE_E_BAD_PACKET); 
00254   }
00255 
00256   ki->gps_numerator=kate_read32(kpb);
00257   ki->gps_denominator=kate_read32(kpb);
00258 
00259   if (ki->granule_shift>=64) return KMG_ERROR(KATE_E_BAD_PACKET);
00260   if (ki->gps_numerator==0) return KMG_ERROR(KATE_E_BAD_PACKET);
00261   if (ki->gps_denominator==0) return KMG_ERROR(KATE_E_BAD_PACKET);
00262   
00263 
00264 
00265 
00266 
00267   len=16;
00268   language=(char*)KMG_MALLOC(len);
00269   if (!language) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00270   ret=kate_readbuf(kpb,language,len); 
00271   if (ret<0) return KMG_ERROR(ret);
00272   if (language[len-1]) return KMG_ERROR(KATE_E_BAD_PACKET); 
00273 
00274   len=16;
00275   category=(char*)KMG_MALLOC(len);
00276   if (!category) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00277   ret=kate_readbuf(kpb,category,len); 
00278   if (ret<0) return KMG_ERROR(ret);
00279   if (category[len-1]) return KMG_ERROR(KATE_E_BAD_PACKET); 
00280 
00281   ret=kate_check_eop(kpb);
00282   if (ret<0) return KMG_ERROR(ret);
00283 
00284   ki->language=language;
00285   ki->category=category;
00286 
00287   return KMG_OK();
00288 }
00289 
00290 static int kate_decode_comment_packet(const kate_info *ki,kate_comment *kc,kate_pack_buffer *kpb)
00291 {
00292   KMG_GUARD();
00293   int ret,len,nc;
00294   char **user_comments,*vendor;
00295   int comments,*comment_lengths;
00296 
00297   if (!ki || !kc || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00298 
00299   len=kate_read32(kpb);
00300   if (len<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00301   if (!ki->no_limits && len>KATE_LIMIT_COMMENT_LENGTH) return KMG_ERROR(KATE_E_LIMIT);
00302   vendor=(char*)KMG_MALLOC(len+1);
00303   if (!vendor) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00304   ret=kate_readbuf(kpb,vendor,len);
00305   if (ret<0) return KMG_ERROR(ret);
00306   vendor[len]=0;
00307 
00308   comments=kate_read32(kpb);
00309   if (comments<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00310   if (!ki->no_limits && len>KATE_LIMIT_COMMENTS) return KMG_ERROR(KATE_E_LIMIT);
00311   user_comments=(char**)KMG_CHECKED_MALLOC(comments,sizeof(char*));
00312   comment_lengths=(int*)KMG_CHECKED_MALLOC(comments,sizeof(int));
00313   if (!user_comments || !comment_lengths) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00314 
00315   for (nc=0;nc<comments;++nc) user_comments[nc]=NULL;
00316   for (nc=0;nc<comments;++nc) {
00317     len=kate_read32(kpb);
00318     if (len<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00319     if (!ki->no_limits && len>KATE_LIMIT_COMMENT_LENGTH) return KMG_ERROR(KATE_E_LIMIT);
00320     user_comments[nc]=(char*)KMG_MALLOC(len+1);
00321     if (!user_comments[nc]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00322     if (len) {
00323       ret=kate_readbuf(kpb,user_comments[nc],len);
00324       if (ret<0) return KMG_ERROR(ret);
00325     }
00326     user_comments[nc][len]=0;
00327     comment_lengths[nc]=len;
00328   }
00329 
00330   ret=kate_check_eop(kpb);
00331   if (ret<0) return KMG_ERROR(ret);
00332 
00333   kc->user_comments=user_comments;
00334   kc->comment_lengths=comment_lengths;
00335   kc->comments=comments;
00336   kc->vendor=vendor;
00337 
00338   return KMG_OK();
00339 }
00340 
00341 static int kate_decode_region(const kate_info *ki,kate_region *kr,kate_pack_buffer *kpb)
00342 {
00343   if (!kr || !kpb) return KATE_E_INVALID_PARAMETER;
00344   kr->metric=kate_pack_read(kpb,8);
00345   kr->x=kate_read32v(kpb);
00346   kr->y=kate_read32v(kpb);
00347   kr->w=kate_read32v(kpb);
00348   kr->h=kate_read32v(kpb);
00349   kr->style=kate_read32v(kpb);
00350 
00351   if (((ki->bitstream_version_major<<8)|ki->bitstream_version_minor)>=0x0002) {
00352     
00353     kate_read32v(kpb); 
00354     kr->clip=kate_pack_read1(kpb);
00355   }
00356   else {
00357     kr->clip=0;
00358   }
00359 
00360   return kate_warp(kpb);
00361 }
00362 
00363 static int kate_decode_regions_packet(kate_info *ki,kate_pack_buffer *kpb)
00364 {
00365   KMG_GUARD();
00366   int ret,n,nregions;
00367   kate_region **regions;
00368 
00369   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00370 
00371   nregions=kate_read32v(kpb);
00372   if (nregions<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00373   if (!ki->no_limits && nregions>KATE_LIMIT_REGIONS) return KMG_ERROR(KATE_E_LIMIT);
00374   regions=(kate_region**)KMG_CHECKED_MALLOC(nregions,sizeof(kate_region*));
00375   if (!regions) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00376   for (n=0;n<nregions;++n) {
00377     regions[n]=(kate_region*)KMG_MALLOC(sizeof(kate_region));
00378     if (!regions[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00379     ret=kate_decode_region(ki,regions[n],kpb);
00380     if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00381     if (ret<0) return KMG_ERROR(ret);
00382   }
00383 
00384   ret=kate_warp(kpb);
00385   if (ret<0) return KMG_ERROR(ret);
00386 
00387   ret=kate_check_eop(kpb);
00388   if (ret<0) return KMG_ERROR(ret);
00389 
00390   ki->nregions=nregions;
00391   ki->regions=regions;
00392 
00393   return KMG_OK();
00394 }
00395 
00396 static int kate_decode_color(kate_color *kc,kate_pack_buffer *kpb)
00397 {
00398   if (!kc || !kpb) return KATE_E_INVALID_PARAMETER;
00399   kc->r=kate_pack_read(kpb,8);
00400   kc->g=kate_pack_read(kpb,8);
00401   kc->b=kate_pack_read(kpb,8);
00402   kc->a=kate_pack_read(kpb,8);
00403   return 0;
00404 }
00405 
00406 static int kate_decode_style(const kate_info *ki,kate_style *ks,kate_pack_buffer *kpb,kate_memory_guard *parent_kmg)
00407 {
00408   KMG_GUARD();
00409   int ret;
00410   kate_float d[8];
00411   size_t idx;
00412   int len;
00413 
00414   if (!ks || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00415 
00416   ret=kate_fp_decode_kate_float(sizeof(d)/sizeof(d[0]),d,1,kpb);
00417   if (ret<0) return KMG_ERROR(ret);
00418 
00419   idx=0;
00420   ks->halign=d[idx++];
00421   ks->valign=d[idx++];
00422   ks->font_width=d[idx++];
00423   ks->font_height=d[idx++];
00424   ks->left_margin=d[idx++];
00425   ks->top_margin=d[idx++];
00426   ks->right_margin=d[idx++];
00427   ks->bottom_margin=d[idx++];
00428   ret=kate_decode_color(&ks->text_color,kpb);
00429   if (ret<0) return KMG_ERROR(ret);
00430   ret=kate_decode_color(&ks->background_color,kpb);
00431   if (ret<0) return KMG_ERROR(ret);
00432   ret=kate_decode_color(&ks->draw_color,kpb);
00433   if (ret<0) return KMG_ERROR(ret);
00434   ks->font_metric=kate_pack_read(kpb,8);
00435   ks->margin_metric=kate_pack_read(kpb,8);
00436   ks->bold=kate_pack_read1(kpb);
00437   ks->italics=kate_pack_read1(kpb);
00438   ks->underline=kate_pack_read1(kpb);
00439   ks->strike=kate_pack_read1(kpb);
00440 
00441   if (((ki->bitstream_version_major<<8)|ki->bitstream_version_minor)>=0x0002) {
00442     
00443     kate_read32v(kpb); 
00444     ks->justify=kate_pack_read1(kpb);
00445     len=kate_read32v(kpb);
00446     if (len<0) {
00447       return KMG_ERROR(KATE_E_BAD_PACKET);
00448     }
00449     else if (len>0) {
00450       ks->font=(char*)KMG_MALLOC(len+1);
00451       if (!ks->font) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00452       ret=kate_readbuf(kpb,ks->font,len);
00453       if (ret<0) return KMG_ERROR(ret);
00454       ks->font[len]=0;
00455     }
00456     else {
00457       ks->font=NULL;
00458     }
00459   }
00460   else {
00461     ks->justify=0;
00462     ks->font=NULL;
00463   }
00464 
00465   if (((ki->bitstream_version_major<<8)|ki->bitstream_version_minor)>=0x0004) {
00466     
00467     kate_read32v(kpb); 
00468     ks->wrap_mode=kate_read32v(kpb);
00469   }
00470   else {
00471     ks->wrap_mode=kate_wrap_word;
00472   }
00473 
00474   ret=kate_warp(kpb);
00475   if (ret<0) return KMG_ERROR(ret);
00476 
00477   return KMG_MERGE(parent_kmg);
00478 }
00479 
00480 static int kate_decode_styles_packet(kate_info *ki,kate_pack_buffer *kpb)
00481 {
00482   KMG_GUARD();
00483   int ret,n,nstyles;
00484   kate_style **styles;
00485 
00486   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00487 
00488   nstyles=kate_read32v(kpb);
00489   if (nstyles<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00490   if (!ki->no_limits && nstyles>KATE_LIMIT_STYLES) return KMG_ERROR(KATE_E_LIMIT);
00491   styles=(kate_style**)KMG_CHECKED_MALLOC(nstyles,sizeof(kate_style*));
00492   if (!styles) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00493   for (n=0;n<nstyles;++n) {
00494     styles[n]=(kate_style*)KMG_MALLOC(sizeof(kate_style));
00495     if (!styles[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00496     ret=kate_decode_style(ki,styles[n],kpb,&kmg);
00497     if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00498     if (ret<0) return KMG_ERROR(ret);
00499   }
00500 
00501   ret=kate_warp(kpb);
00502   if (ret<0) return KMG_ERROR(ret);
00503 
00504   ret=kate_check_eop(kpb);
00505   if (ret<0) return KMG_ERROR(ret);
00506 
00507   ki->nstyles=nstyles;
00508   ki->styles=styles;
00509 
00510   return KMG_OK();
00511 }
00512 
00513 static int kate_decode_curve(const kate_info *ki,kate_curve *kc,kate_pack_buffer *kpb,kate_memory_guard *parent_kmg)
00514 {
00515   KMG_GUARD();
00516   int ret;
00517 
00518   if (!ki || !kc || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00519 
00520   kc->type=kate_pack_read(kpb,8);
00521   kc->npts=kate_read32v(kpb);
00522   ret=kate_warp(kpb);
00523   if (ret<0) return KMG_ERROR(ret);
00524   if (!ki->no_limits && kc->npts>KATE_LIMIT_CURVE_POINTS) return KMG_ERROR(KATE_E_LIMIT);
00525   kc->pts=(kate_float*)KMG_CHECKED_MALLOC(kc->npts,2*sizeof(kate_float));
00526   if (!kc->pts) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00527 
00528   ret=kate_fp_decode_kate_float(kc->npts,kc->pts,2,kpb);
00529   if (ret<0) return KMG_ERROR(ret);
00530 
00531   
00532   return KMG_MERGE(parent_kmg);
00533 }
00534 
00535 static int kate_decode_curves_packet(kate_info *ki,kate_pack_buffer *kpb)
00536 {
00537   KMG_GUARD();
00538   int ret,n,ncurves;
00539   kate_curve **curves=NULL;
00540 
00541   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00542 
00543   ncurves=kate_read32v(kpb);
00544   if (ncurves<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00545   if (!ki->no_limits && ncurves>KATE_LIMIT_CURVES) return KMG_ERROR(KATE_E_LIMIT);
00546 
00547   if (ncurves>0) {
00548     curves=(kate_curve**)KMG_CHECKED_MALLOC(ncurves,sizeof(kate_curve*));
00549     if (!curves) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00550     for (n=0;n<ncurves;++n) {
00551       curves[n]=(kate_curve*)KMG_MALLOC(sizeof(kate_curve));
00552       if (!curves[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00553       ret=kate_decode_curve(ki,curves[n],kpb,&kmg);
00554       if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00555       if (ret<0) return KMG_ERROR(ret);
00556     }
00557   }
00558 
00559   ret=kate_warp(kpb);
00560   if (ret<0) return KMG_ERROR(ret);
00561 
00562   ret=kate_check_eop(kpb);
00563   if (ret<0) return KMG_ERROR(ret);
00564 
00565   ki->ncurves=ncurves;
00566   ki->curves=curves;
00567 
00568   return KMG_OK();
00569 }
00570 
00571 static int kate_decode_motion(const kate_info *ki,kate_motion *km,kate_pack_buffer *kpb,kate_memory_guard *parent_kmg)
00572 {
00573   KMG_GUARD();
00574   size_t n;
00575   int ret;
00576 
00577   if (!ki || !km || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00578 
00579   km->ncurves=kate_read32v(kpb);
00580   if (!ki->no_limits && km->ncurves>KATE_LIMIT_MOTION_CURVES) return KMG_ERROR(KATE_E_LIMIT);
00581   km->curves=(kate_curve**)KMG_CHECKED_MALLOC(km->ncurves,sizeof(kate_curve*));
00582   if (!km->curves) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00583   km->durations=(kate_float*)KMG_CHECKED_MALLOC(km->ncurves,sizeof(kate_float));
00584   if (!km->durations) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00585 
00586   for (n=0;n<km->ncurves;++n) {
00587     if (kate_pack_read1(kpb)) {
00588       size_t idx=kate_read32v(kpb);
00589       if (idx>=ki->ncurves) return KMG_ERROR(KATE_E_BAD_PACKET);
00590       km->curves[n]=ki->curves[idx];
00591     }
00592     else {
00593       km->curves[n]=(kate_curve*)KMG_MALLOC(sizeof(kate_curve));
00594       if (!km->curves[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00595       ret=kate_decode_curve(ki,km->curves[n],kpb,&kmg);
00596       if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00597       if (ret<0) return KMG_ERROR(ret);
00598     }
00599   }
00600   ret=kate_fp_decode_kate_float(km->ncurves,km->durations,1,kpb);
00601   if (ret<0) return KMG_ERROR(ret);
00602   km->x_mapping=kate_pack_read(kpb,8);
00603   km->y_mapping=kate_pack_read(kpb,8);
00604   km->semantics=kate_pack_read(kpb,8);
00605   km->periodic=kate_pack_read1(kpb);
00606   ret=kate_warp(kpb);
00607   if (ret<0) return KMG_ERROR(ret);
00608 
00609   return KMG_MERGE(parent_kmg);
00610 }
00611 
00612 static int kate_decode_motions_packet(kate_info *ki,kate_pack_buffer *kpb)
00613 {
00614   KMG_GUARD();
00615   int ret,n,nmotions;
00616   kate_motion **motions=NULL;
00617 
00618   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00619 
00620   nmotions=kate_read32v(kpb);
00621   if (nmotions<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00622   if (!ki->no_limits && nmotions>KATE_LIMIT_MOTIONS) return KMG_ERROR(KATE_E_LIMIT);
00623 
00624   if (nmotions>0) {
00625     motions=(kate_motion**)KMG_CHECKED_MALLOC(nmotions,sizeof(kate_motion*));
00626     if (!motions) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00627     for (n=0;n<nmotions;++n) {
00628       motions[n]=(kate_motion*)KMG_MALLOC(sizeof(kate_motion));
00629       if (!motions[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00630       ret=kate_decode_motion(ki,motions[n],kpb,&kmg);
00631       if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00632       if (ret<0) return KMG_ERROR(ret);
00633     }
00634   }
00635 
00636   ret=kate_warp(kpb);
00637   if (ret<0) return KMG_ERROR(ret);
00638 
00639   ret=kate_check_eop(kpb);
00640   if (ret<0) return KMG_ERROR(ret);
00641 
00642   ki->nmotions=nmotions;
00643   ki->motions=motions;
00644 
00645   return KMG_OK();
00646 }
00647 
00648 static int kate_decode_palette(const kate_info *ki,kate_palette *kp,kate_pack_buffer *kpb)
00649 {
00650   kate_color *colors;
00651   size_t n;
00652   int ret;
00653 
00654   if (!ki || !kp || !kpb) return KATE_E_INVALID_PARAMETER;
00655 
00656   kp->ncolors=kate_pack_read(kpb,8)+1;
00657 
00658   colors=(kate_color*)kate_checked_malloc(kp->ncolors,sizeof(kate_color));
00659   if (!colors) return KATE_E_OUT_OF_MEMORY;
00660 
00661   for (n=0;n<kp->ncolors;++n) {
00662     ret=kate_decode_color(colors+n,kpb);
00663     if (kate_overread(kpb)) {
00664       kate_free(colors);
00665       return ret;
00666     }
00667     if (ret<0) {
00668       kate_free(colors);
00669       return ret;
00670     }
00671   }
00672   ret=kate_warp(kpb);
00673   if (ret<0) return ret;
00674 
00675   kp->colors=colors;
00676 
00677   return 0;
00678 }
00679 
00680 static int kate_decode_palettes_packet(kate_info *ki,kate_pack_buffer *kpb)
00681 {
00682   KMG_GUARD();
00683   int ret,n,npalettes;
00684   kate_palette **palettes=NULL;
00685 
00686   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00687 
00688   npalettes=kate_read32v(kpb);
00689   if (npalettes<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00690   if (!ki->no_limits && npalettes>KATE_LIMIT_PALETTES) return KMG_ERROR(KATE_E_LIMIT);
00691 
00692   if (npalettes>0) {
00693     palettes=(kate_palette**)KMG_CHECKED_MALLOC(npalettes,sizeof(kate_palette*));
00694     if (!palettes) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00695     for (n=0;n<npalettes;++n) {
00696       palettes[n]=(kate_palette*)KMG_MALLOC(sizeof(kate_palette));
00697       if (!palettes[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00698       ret=kate_decode_palette(ki,palettes[n],kpb);
00699       if (kate_overread(kpb)) return KMG_ERROR(ret);
00700       if (ret<0) return KMG_ERROR(ret);
00701     }
00702   }
00703 
00704   ret=kate_warp(kpb);
00705   if (ret<0) return KMG_ERROR(ret);
00706 
00707   ret=kate_check_eop(kpb);
00708   if (ret<0) return KMG_ERROR(ret);
00709 
00710   ki->npalettes=npalettes;
00711   ki->palettes=palettes;
00712 
00713   return KMG_OK();
00714 }
00715 
00716 static int kate_decode_bitmap(const kate_info *ki,kate_bitmap *kb,kate_pack_buffer *kpb)
00717 {
00718   size_t n,npixels;
00719   unsigned char *pixels;
00720   int ret,encoding;
00721 
00722   if (!ki || !kb || !kpb) return KATE_E_INVALID_PARAMETER;
00723 
00724   kb->width=kate_read32v(kpb);
00725   kb->height=kate_read32v(kpb);
00726   kb->bpp=kate_pack_read(kpb,8);
00727   if (kb->width<=0 || kb->height<=0 || kb->bpp>8) return KATE_E_BAD_PACKET;
00728   if (!ki->no_limits && (kb->width>KATE_LIMIT_BITMAP_SIZE || kb->height>KATE_LIMIT_BITMAP_SIZE)) return KATE_E_LIMIT;
00729 
00730   if (kb->bpp==0) {
00731     
00732     kb->type=kate_pack_read(kpb,8);
00733     kb->palette=-1;
00734     switch (kb->type) {
00735       case kate_bitmap_type_paletted:
00736         encoding=kate_pack_read(kpb,8);
00737         switch (encoding) {
00738           case 1: 
00739             kb->bpp=kate_read32v(kpb);
00740             kb->palette=kate_read32v(kpb);
00741             pixels=(unsigned char*)kate_checked_malloc(kb->width,kb->height);
00742             if (!pixels) return KATE_E_OUT_OF_MEMORY;
00743             ret=kate_rle_decode(kb->width,kb->height,pixels,kb->bpp,kpb);
00744             if (ret<0) return ret;
00745             break;
00746           default:
00747             return KATE_E_BAD_PACKET;
00748         }
00749         break;
00750       case kate_bitmap_type_png:
00751         kb->size=kate_read32(kpb);
00752         if (!ki->no_limits && kb->size>KATE_LIMIT_BITMAP_RAW_SIZE) return KATE_E_LIMIT;
00753         pixels=(unsigned char*)kate_malloc(kb->size);
00754         if (!pixels) return KATE_E_OUT_OF_MEMORY;
00755         ret=kate_readbuf(kpb,(char*)pixels,kb->size);
00756         if (ret<0) {
00757           kate_free(pixels);
00758           return ret;
00759         }
00760         break;
00761       default:
00762         return KATE_E_BAD_PACKET;
00763     }
00764   }
00765   else {
00766     
00767     kb->type=kate_bitmap_type_paletted;
00768     kb->palette=kate_read32v(kpb);
00769 
00770     ret=kate_check_mul_overflow(kb->width,kb->height,&npixels);
00771     if (ret<0) return ret;
00772     pixels=(unsigned char*)kate_malloc(npixels);
00773     if (!pixels) return KATE_E_OUT_OF_MEMORY;
00774     if ((size_t)kate_pack_bits(kpb)<npixels*kb->bpp) {
00775       kate_free(pixels);
00776       return KATE_E_BAD_PACKET;
00777     }
00778 
00779     for (n=0;n<npixels;++n) {
00780       pixels[n]=kate_pack_read(kpb,kb->bpp);
00781     }
00782     if (kate_overread(kpb)) {
00783       kate_free(pixels);
00784       return KATE_E_BAD_PACKET;
00785     }
00786   }
00787 
00788   if (((ki->bitstream_version_major<<8)|ki->bitstream_version_minor)>=0x0004) {
00789     
00790     kate_read32v(kpb); 
00791     kb->x_offset=kate_read32v(kpb);
00792     kb->y_offset=kate_read32v(kpb);
00793   }
00794   else {
00795     kb->x_offset=0;
00796     kb->y_offset=0;
00797   }
00798 
00799   ret=kate_warp(kpb);
00800   if (ret<0) return ret;
00801 
00802   kb->pixels=pixels;
00803 
00804   return 0;
00805 }
00806 
00807 static int kate_decode_bitmaps_packet(kate_info *ki,kate_pack_buffer *kpb)
00808 {
00809   KMG_GUARD();
00810   int ret,n,nbitmaps;
00811   kate_bitmap **bitmaps=NULL;
00812 
00813   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00814 
00815   nbitmaps=kate_read32v(kpb);
00816   if (nbitmaps<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00817   if (!ki->no_limits && nbitmaps>KATE_LIMIT_BITMAPS) return KMG_ERROR(KATE_E_LIMIT);
00818 
00819   if (nbitmaps>0) {
00820     bitmaps=(kate_bitmap**)KMG_CHECKED_MALLOC(nbitmaps,sizeof(kate_bitmap*));
00821     if (!bitmaps) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00822     for (n=0;n<nbitmaps;++n) {
00823       bitmaps[n]=(kate_bitmap*)KMG_MALLOC(sizeof(kate_bitmap));
00824       if (!bitmaps[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00825       ret=kate_decode_bitmap(ki,bitmaps[n],kpb);
00826       if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00827       if (ret<0) return KMG_ERROR(ret);
00828     }
00829   }
00830 
00831   ret=kate_warp(kpb);
00832   if (ret<0) return KMG_ERROR(ret);
00833 
00834   ret=kate_check_eop(kpb);
00835   if (ret<0) return KMG_ERROR(ret);
00836 
00837   ki->nbitmaps=nbitmaps;
00838   ki->bitmaps=bitmaps;
00839 
00840   return KMG_OK();
00841 }
00842 
00843 static int kate_decode_font_range(const kate_info *ki,kate_font_range *kfr,kate_pack_buffer *kpb)
00844 {
00845   if (!ki || !kfr || !kpb) return KATE_E_INVALID_PARAMETER;
00846 
00847   kfr->first_code_point=kate_read32v(kpb);
00848   kfr->last_code_point=kate_read32v(kpb);
00849   kfr->first_bitmap=kate_read32v(kpb);
00850 
00851   return kate_warp(kpb);
00852 }
00853 
00854 static int kate_decode_font_ranges_packet(kate_info *ki,kate_pack_buffer *kpb)
00855 {
00856   KMG_GUARD();
00857   int l,n,ret;
00858   int nfont_ranges,nfont_mappings;
00859   kate_font_range **font_ranges=NULL;
00860   kate_font_mapping **font_mappings=NULL;
00861 
00862   if (!ki || !kpb) return KMG_ERROR(KATE_E_INVALID_PARAMETER);
00863 
00864   nfont_ranges=kate_read32v(kpb);
00865   if (nfont_ranges<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00866   if (!ki->no_limits && nfont_ranges>KATE_LIMIT_FONT_RANGES) return KMG_ERROR(KATE_E_LIMIT);
00867 
00868   if (nfont_ranges>0) {
00869     font_ranges=(kate_font_range**)KMG_CHECKED_MALLOC(nfont_ranges,sizeof(kate_font_range*));
00870     if (!font_ranges) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00871     for (n=0;n<nfont_ranges;++n) {
00872       font_ranges[n]=(kate_font_range*)KMG_MALLOC(sizeof(kate_font_range));
00873       if (!font_ranges[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00874       ret=kate_decode_font_range(ki,font_ranges[n],kpb);
00875       if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00876       if (ret<0) return KMG_ERROR(ret);
00877     }
00878   }
00879 
00880   
00881   ki->nfont_ranges=nfont_ranges;
00882   ki->font_ranges=font_ranges;
00883 
00884   
00885   nfont_mappings=kate_read32v(kpb);
00886   if (nfont_mappings<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00887   if (!ki->no_limits && nfont_mappings>KATE_LIMIT_FONT_MAPPINGS) return KMG_ERROR(KATE_E_LIMIT);
00888 
00889   if (nfont_mappings>0) {
00890     font_mappings=(kate_font_mapping**)KMG_CHECKED_MALLOC(nfont_mappings,sizeof(kate_font_mapping*));
00891     if (!font_mappings) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00892     for (n=0;n<nfont_mappings;++n) {
00893       font_mappings[n]=(kate_font_mapping*)KMG_MALLOC(sizeof(kate_font_mapping));
00894       if (!font_mappings[n]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00895 
00896       nfont_ranges=kate_read32v(kpb);
00897       if (nfont_ranges<0) return KMG_ERROR(KATE_E_BAD_PACKET);
00898       if (!ki->no_limits && nfont_ranges>KATE_LIMIT_FONT_MAPPING_RANGES) return KMG_ERROR(KATE_E_LIMIT);
00899 
00900       if (nfont_ranges>0) {
00901         font_ranges=(kate_font_range**)KMG_CHECKED_MALLOC(nfont_ranges,sizeof(kate_font_range*));
00902         if (!font_ranges) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00903 
00904         for (l=0;l<nfont_ranges;++l) {
00905           if (kate_pack_read1(kpb)) {
00906             size_t idx=kate_read32v(kpb);
00907             if (idx>=ki->nfont_ranges) return KMG_ERROR(KATE_E_BAD_PACKET);
00908             font_ranges[l]=ki->font_ranges[idx];
00909           }
00910           else {
00911             font_ranges[l]=(kate_font_range*)KMG_MALLOC(sizeof(kate_font_range));
00912             if (!font_ranges[l]) return KMG_ERROR(KATE_E_OUT_OF_MEMORY);
00913             ret=kate_decode_font_range(ki,font_ranges[l],kpb);
00914             if (kate_overread(kpb)) return KMG_ERROR(KATE_E_BAD_PACKET);
00915             if (ret<0) return KMG_ERROR(ret);
00916           }
00917         }
00918         font_mappings[n]->nranges=nfont_ranges;
00919         font_mappings[n]->ranges=font_ranges;
00920       }
00921       else {
00922         font_mappings[n]->nranges=0;
00923         font_mappings[n]->ranges=NULL;
00924       }
00925     }
00926   }
00927 
00928   ret=kate_warp(kpb);
00929   if (ret<0) return KMG_ERROR(ret);
00930 
00931   ret=kate_check_eop(kpb);
00932   if (ret<0) return KMG_ERROR(ret);
00933 
00934   ki->nfont_mappings=nfont_mappings;
00935   ki->font_mappings=font_mappings;
00936 
00937   return KMG_OK();
00938 }
00939 
00951 int kate_decode_headerin(kate_info *ki,kate_comment *kc,kate_packet *kp)
00952 {
00953   kate_pack_buffer kpb;
00954   unsigned char headerid;
00955   int ret;
00956   int packetno;
00957 
00958   if (!ki || !kc || !kp) return KATE_E_INVALID_PARAMETER;
00959 
00960   kate_pack_readinit(&kpb,kp->data,kp->nbytes);
00961   headerid=kate_pack_read(&kpb,8);
00962 
00963   ret=kate_decode_check_magic(&kpb);
00964   if (ret<0) return ret;
00965 
00966   if (!(headerid&0x80)) return KATE_E_BAD_PACKET;
00967   packetno=headerid&~0x80;
00968   if (packetno<ki->num_headers) {
00969     if (ki->probe!=packetno) return KATE_E_BAD_PACKET;
00970   }
00971 
00972   
00973 
00974 
00975 
00976 
00977 
00978 
00979   if (kate_pack_read(&kpb,8)!=0) return KATE_E_BAD_PACKET;
00980 
00981   switch (packetno) {
00982     case 0: 
00983       ret=kate_decode_info_header(ki,&kpb);
00984       break;
00985 
00986     case 1: 
00987       ret=kate_decode_comment_packet(ki,kc,&kpb);
00988       break;
00989 
00990     case 2: 
00991       ret=kate_decode_regions_packet(ki,&kpb);
00992       break;
00993 
00994     case 3: 
00995       ret=kate_decode_styles_packet(ki,&kpb);
00996       break;
00997 
00998     case 4: 
00999       ret=kate_decode_curves_packet(ki,&kpb);
01000       break;
01001 
01002     case 5: 
01003       ret=kate_decode_motions_packet(ki,&kpb);
01004       break;
01005 
01006     case 6: 
01007       ret=kate_decode_palettes_packet(ki,&kpb);
01008       break;
01009 
01010     case 7: 
01011       ret=kate_decode_bitmaps_packet(ki,&kpb);
01012       break;
01013 
01014     case 8: 
01015       ret=kate_decode_font_ranges_packet(ki,&kpb);
01016       if (ret==0) ret=1; 
01017       break;
01018 
01019     default:
01020       
01021       ret=0;
01022       break;
01023   }
01024 
01025   if (ret>=0) {
01026     
01027     ki->probe++;
01028   }
01029 
01030   return ret;
01031 }
01032 
01042 int kate_decode_init(kate_state *k,kate_info *ki)
01043 {
01044   if (!k || !ki) return KATE_E_INVALID_PARAMETER;
01045 
01046   k->ki=ki;
01047   k->kes=NULL;
01048   k->kds=kate_decode_state_create();
01049   if (!k->kds) return KATE_E_OUT_OF_MEMORY;
01050 
01051   return 0;
01052 }
01053 
01054 #define READ_OVERRIDE(read) \
01055   do { \
01056     if (kate_pack_read1(kpb)) { read; } \
01057   } while(0)
01058 
01059 #if 0 && defined DEBUG
01060 #include <unistd.h>
01061 #include <sys/types.h>
01062 #include <time.h>
01063 #include <stdlib.h>
01064 #define RNDERR(label) \
01065   do { \
01066     static int seed=0; \
01067     if (!seed) { \
01068       const char *env=getenv("KATE_RAND_SEED"); \
01069       if (env) srand(atoi(env)); else srand(time(NULL)^getpid()); \
01070       seed=1; \
01071     } \
01072     if (((rand()>>8)&0xff)==0) { \
01073       ret=KATE_E_OUT_OF_MEMORY; \
01074       goto label; \
01075     } \
01076   } while(0)
01077 #else
01078 #define RNDERR(label) ((void)0)
01079 #endif
01080 
01081 static int kate_decode_text_packet(kate_state *k,kate_pack_buffer *kpb,int repeat)
01082 {
01083   KMG_GUARD();
01084   int ret,n;
01085   int len;
01086   char *text;
01087   kate_decode_state *kds;
01088   kate_event *ev;
01089 
01090   if (!k || !kpb) return KATE_E_INVALID_PARAMETER;
01091   if (!k->kds) return KATE_E_INIT;
01092 
01093   ret=kate_decode_state_clear(k->kds,k->ki,1);
01094   if (ret<0) return ret;
01095 
01096   kds=k->kds;
01097   ev=kds->event;
01098 
01099   ev->start=kate_read64(kpb);
01100   ev->duration=kate_read64(kpb);
01101   ev->backlink=kate_read64(kpb);
01102   if (ev->start<0 || ev->duration<0) goto error_bad_packet;
01103   if (ev->backlink<0 || ev->backlink>ev->start) goto error_bad_packet;
01104   RNDERR(error_bad_packet);
01105 
01106   ev->start_time=kate_granule_duration(k->ki,ev->start);
01107   ev->end_time=ev->start_time+kate_granule_duration(k->ki,ev->duration);
01108 
01109   len=kate_read32(kpb);
01110   if (len<0) goto error_bad_packet;
01111   RNDERR(error_bad_packet);
01112   if (!k->ki->no_limits && len>KATE_LIMIT_TEXT_LENGTH) goto error_limit;
01113   RNDERR(error_limit);
01114 
01115   
01116   if (kate_check_add_overflow(len,4,NULL)) goto error_out_of_memory;
01117   text=(char*)KMG_MALLOC(len+4);
01118   if (!text) goto error_out_of_memory;
01119   RNDERR(error_out_of_memory);
01120   ret=kate_readbuf(kpb,text,len);
01121   if (ret<0) goto error_bad_packet;
01122   text[len]=0;
01123   text[len+1]=0;
01124   text[len+2]=0;
01125   text[len+3]=0;
01126   
01127 
01128 
01129   ev->text=text;
01130   ev->len=len;
01131   ev->len0=len+4;
01132 
01133   if (kate_pack_read1(kpb)) {
01134     ev->id=kate_read32v(kpb);
01135   }
01136 
01137   if (repeat && ev->id>=0) {
01138     
01139     ret=kate_decode_state_find_event(k->kds,ev->id);
01140     if (ret<0 && ret!=KATE_E_NOT_FOUND) goto error;
01141     if (ret>=0) goto ignore;
01142   }
01143 
01144   if (kate_pack_read1(kpb)) {
01145     kate_motion **motions=NULL;
01146     size_t nmotions=0;
01147 
01148     len=kate_read32v(kpb);
01149     if (len<=0) goto error_bad_packet; 
01150     if (!k->ki->no_limits && len>KATE_LIMIT_TEXT_MOTIONS) goto error_limit;
01151     RNDERR(error_limit);
01152     motions=(kate_motion**)KMG_CHECKED_MALLOC(len,sizeof(kate_motion*));
01153     if (!motions) goto error_out_of_memory;
01154     RNDERR(error_out_of_memory);
01155     nmotions=0;
01156     for (n=0;n<len;++n) {
01157       if (kate_pack_read1(kpb)) {
01158         size_t idx=kate_read32v(kpb);
01159         if (idx>=k->ki->nmotions) goto error_bad_packet;
01160         RNDERR(error_bad_packet);
01161         motions[n]=k->ki->motions[idx];
01162       }
01163       else {
01164         motions[n]=KMG_MALLOC(sizeof(kate_motion));
01165         if (!motions[n]) goto error_out_of_memory;
01166         RNDERR(error_out_of_memory);
01167         ret=kate_decode_motion(k->ki,motions[n],kpb,&kmg);
01168         if (kate_overread(kpb)) goto error_bad_packet;
01169         if (ret<0) goto error;
01170         RNDERR(error);
01171       }
01172       ++nmotions;
01173     }
01174 
01175     ev->motions=motions;
01176     ev->nmotions=nmotions;
01177   }
01178 
01179   if (kate_pack_read1(kpb)) {
01180     READ_OVERRIDE(ev->text_encoding=kate_pack_read(kpb,8));
01181     READ_OVERRIDE(ev->text_directionality=kate_pack_read(kpb,8));
01182     READ_OVERRIDE(
01183       do {
01184         len=kate_read32v(kpb);
01185         if (len<0) goto error_bad_packet;
01186         RNDERR(error_bad_packet);
01187         if (!k->ki->no_limits && len>KATE_LIMIT_LANGUAGE_LENGTH) goto error_limit;
01188         RNDERR(error_limit);
01189         if (len>0) {
01190           ev->language=(char*)KMG_MALLOC(len+1);
01191           if (!ev->language) goto error_out_of_memory;
01192         RNDERR(error_out_of_memory);
01193           ret=kate_readbuf(kpb,ev->language,len);
01194           if (ret<0) goto error_bad_packet;
01195           ev->language[len]=0;
01196         }
01197       } while(0)
01198     );
01199     READ_OVERRIDE(
01200       size_t idx=kate_read32v(kpb);
01201       if (idx>=k->ki->nregions) goto error_bad_packet;
01202       RNDERR(error_bad_packet);
01203       ev->region=k->ki->regions[idx];
01204     );
01205     READ_OVERRIDE(
01206       ev->region=KMG_MALLOC(sizeof(kate_region));
01207       if (!ev->region) goto error_out_of_memory;
01208       RNDERR(error_out_of_memory);
01209       ret=kate_decode_region(k->ki,ev->region,kpb);
01210       if (ret<0) goto error;
01211     );
01212     READ_OVERRIDE(
01213       size_t idx=kate_read32v(kpb);
01214       if (idx>=k->ki->nstyles) goto error_bad_packet;
01215       RNDERR(error_bad_packet);
01216       ev->style=k->ki->styles[idx]
01217     );
01218     READ_OVERRIDE(
01219       ev->style=KMG_MALLOC(sizeof(kate_style));
01220       if (!ev->style) goto error_out_of_memory;
01221       RNDERR(error_out_of_memory);
01222       ret=kate_decode_style(k->ki,ev->style,kpb,&kmg);
01223       if (ret<0) goto error;
01224     );
01225     READ_OVERRIDE(
01226       size_t idx=kate_read32v(kpb);
01227       if (idx>=k->ki->nstyles) goto error_bad_packet;
01228       RNDERR(error_bad_packet);
01229       ev->secondary_style=k->ki->styles[idx]
01230     );
01231     READ_OVERRIDE(
01232       ev->secondary_style=KMG_MALLOC(sizeof(kate_style));
01233       if (!ev->secondary_style) goto error_out_of_memory;
01234       RNDERR(error_out_of_memory);
01235       ret=kate_decode_style(k->ki,ev->secondary_style,kpb,&kmg);
01236       if (ret<0) goto error;
01237       RNDERR(error);
01238     );
01239     READ_OVERRIDE(
01240       size_t idx=kate_read32v(kpb);
01241       if (idx>=k->ki->nfont_mappings) goto error_bad_packet;
01242       RNDERR(error_bad_packet);
01243       ev->font_mapping=k->ki->font_mappings[idx]
01244     );
01245   }
01246 
01247   if (((k->ki->bitstream_version_major<<8)|k->ki->bitstream_version_minor)>=0x0002) {
01248     
01249     kate_read32v(kpb); 
01250     if (kate_pack_read1(kpb)) {
01251       READ_OVERRIDE(
01252         size_t idx=kate_read32v(kpb);
01253         if (idx>=k->ki->npalettes) goto error_bad_packet;
01254         RNDERR(error_bad_packet);
01255         ev->palette=k->ki->palettes[idx];
01256       );
01257       READ_OVERRIDE(
01258         ev->palette=KMG_MALLOC(sizeof(kate_palette));
01259         if (!ev->palette) goto error_out_of_memory;
01260         ret=kate_decode_palette(k->ki,ev->palette,kpb);
01261         if (ret<0) goto error;
01262         RNDERR(error);
01263       );
01264       READ_OVERRIDE(
01265         size_t idx=kate_read32v(kpb);
01266         if (idx>=k->ki->nbitmaps) goto error_bad_packet;
01267         ev->bitmap=k->ki->bitmaps[idx];
01268       );
01269       READ_OVERRIDE(
01270         ev->bitmap=KMG_MALLOC(sizeof(kate_bitmap));
01271         if (!ev->bitmap) goto error_out_of_memory;
01272         RNDERR(error_out_of_memory);
01273         ret=kate_decode_bitmap(k->ki,ev->bitmap,kpb);
01274         if (ret<0) goto error;
01275         RNDERR(error);
01276       );
01277       READ_OVERRIDE(ev->text_markup_type=kate_pack_read(kpb,8));
01278     }
01279   }
01280 
01281   if (((k->ki->bitstream_version_major<<8)|k->ki->bitstream_version_minor)>=0x0004) {
01282     
01283     kate_bitmap **bitmaps=NULL;
01284     size_t nbitmaps=0;
01285 
01286     kate_read32v(kpb); 
01287 
01288     len=kate_read32v(kpb);
01289     if (len<0) goto error_bad_packet;
01290     RNDERR(error_bad_packet);
01291     if (len>0) {
01292       if (!k->ki->no_limits && len>KATE_LIMIT_BITMAPS) goto error_limit;
01293       bitmaps=(kate_bitmap**)KMG_CHECKED_MALLOC(len,sizeof(kate_bitmap*));
01294       if (!bitmaps) goto error_out_of_memory;
01295       RNDERR(error_out_of_memory);
01296       nbitmaps=0;
01297       for (n=0;n<len;++n) {
01298         if (kate_pack_read1(kpb)) {
01299           size_t idx=kate_read32v(kpb);
01300           if (idx>=k->ki->nbitmaps) goto error_bad_packet;
01301           RNDERR(error_bad_packet);
01302           bitmaps[n]=k->ki->bitmaps[idx];
01303         }
01304         else {
01305           bitmaps[n]=KMG_MALLOC(sizeof(kate_bitmap));
01306           if (!bitmaps[n]) goto error_out_of_memory;
01307           RNDERR(error_out_of_memory);
01308           ret=kate_decode_bitmap(k->ki,bitmaps[n],kpb);
01309           if (kate_overread(kpb)) goto error_bad_packet;
01310           if (ret<0) goto error;
01311         }
01312         ++nbitmaps;
01313       }
01314     }
01315 
01316     ev->bitmaps=bitmaps;
01317     ev->nbitmaps=nbitmaps;
01318   }
01319   else {
01320     ev->bitmaps=NULL;
01321     ev->nbitmaps=0;
01322   }
01323 
01324   ret=kate_warp(kpb);
01325   if (ret<0) goto error;
01326   RNDERR(error);
01327 
01328   
01329   ret=kate_text_validate(ev->text_encoding,ev->text,ev->len0);
01330   RNDERR(error);
01331   if (ret<0) goto error;
01332 
01333   if (ev->text_markup_type!=kate_markup_none && k->ki->remove_markup) {
01334     size_t zero_size=ev->len0-ev->len;
01335     ret=kate_text_remove_markup(ev->text_encoding,ev->text,&ev->len0);
01336     if (ret<0) goto error;
01337     if (ev->len0<zero_size) goto error_bad_packet; 
01338     ev->len=ev->len0-zero_size;
01339     RNDERR(error);
01340     ev->text_markup_type=kate_markup_none;
01341   }
01342 
01343   
01344   if (!ev->style && ev->region) {
01345     if (ev->region->style>=0) {
01346       size_t idx=ev->region->style;
01347       if (idx<k->ki->nstyles) {
01348         ev->style=k->ki->styles[idx];
01349       }
01350     }
01351   }
01352 
01353   if (ev->id>=0) {
01354     
01355     ret=kate_decode_state_add_event(k->kds,ev);
01356     RNDERR(error);
01357     if (ret<0) goto error;
01358   }
01359 
01360   ret=kate_decode_state_flush_events(k->kds,ev->start);
01361   RNDERR(error);
01362   if (ret<0) goto error;
01363 
01364   return KMG_OK();
01365 
01366 error_limit:
01367   ret=KATE_E_LIMIT;
01368   goto error;
01369 
01370 error_bad_packet:
01371   ret=KATE_E_BAD_PACKET;
01372   goto error;
01373 
01374 error_out_of_memory:
01375   ret=KATE_E_OUT_OF_MEMORY;
01376   goto error;
01377 
01378 ignore:
01379   
01380 
01381   ret=0;
01382   goto error;
01383 
01384 error:
01385   
01386 
01387   kate_free(kds->event);
01388   kds->event=NULL;
01389   return KMG_ERROR(ret);
01390 }
01391 
01392 static int kate_decode_repeat_packet(kate_state *k,kate_pack_buffer *kpb)
01393 {
01394   return kate_decode_text_packet(k,kpb,1);
01395 }
01396 
01397 static int kate_decode_keepalive_packet(kate_state *k,kate_pack_buffer *kpb)
01398 {
01399   if (!k || !kpb) return KATE_E_INVALID_PARAMETER;
01400   if (!k->kds) return KATE_E_INIT;
01401 
01402   return 0;
01403 }
01404 
01405 static int kate_decode_end_packet(kate_state *k,kate_pack_buffer *kpb)
01406 {
01407   if (!k || !kpb) return KATE_E_INVALID_PARAMETER;
01408   if (!k->kds) return KATE_E_INIT;
01409 
01410   return 1;
01411 }
01412 
01422 int kate_decode_packetin(kate_state *k,kate_packet *kp)
01423 {
01424   kate_pack_buffer kpb;
01425   int ret,id;
01426 
01427   if (!k || !kp) return KATE_E_INVALID_PARAMETER;
01428   if (!k->ki) return KATE_E_INIT;
01429   if (!k->kds) return KATE_E_INIT;
01430 
01431   ret=kate_decode_state_clear(k->kds,k->ki,0);
01432   if (ret<0) return ret;
01433 
01434   kate_pack_readinit(&kpb,kp->data,kp->nbytes);
01435   id=kate_pack_read(&kpb,8);
01436   if (id&0x80) {
01437     
01438 
01439 
01440     return 0;
01441   }
01442 
01443   switch (id) {
01444     case 0x00: return kate_decode_text_packet(k,&kpb,0);
01445     case 0x01: return kate_decode_keepalive_packet(k,&kpb);
01446     case 0x02: return kate_decode_repeat_packet(k,&kpb);
01447     case 0x7f: return kate_decode_end_packet(k,&kpb);
01448     default: return 0; 
01449   }
01450 
01451   return 0;
01452 }
01453 
01463 int kate_decode_eventout(kate_state *k,kate_const kate_event **event)
01464 {
01465   if (!k) return KATE_E_INVALID_PARAMETER;
01466   if (!k->kds) return KATE_E_INIT;
01467 
01468   if (!k->kds->event) return 1;
01469 
01470   if (event) *event=k->kds->event;
01471 
01472   return 0;
01473 }
01474 
01485 int kate_decode_seek(kate_state *k)
01486 {
01487   if (!k) return KATE_E_INVALID_PARAMETER;
01488   if (!k->kds) return KATE_E_INIT;
01489 
01490   return kate_decode_state_flush_events(k->kds,-1);
01491 }
01492