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_encode_state.h"
00021 #include "kate_fp.h"
00022 #include "kate_rle.h"
00023
00024 #define NUM_HEADERS 9
00025
00035 int kate_encode_init(kate_state *k,kate_info *ki)
00036 {
00037 if (!k || !ki) return KATE_E_INVALID_PARAMETER;
00038
00039 k->ki=ki;
00040 k->kds=NULL;
00041 k->ki->num_headers=NUM_HEADERS;
00042 k->kes=kate_encode_state_create(ki);
00043 if (!k->kes) return KATE_E_OUT_OF_MEMORY;
00044
00045 return 0;
00046 }
00047
00048 static inline void kate_pack_write1(kate_pack_buffer *kpb,long value)
00049 {
00050 kate_pack_write(kpb,value,1);
00051 }
00052
00053 static void kate_writebuf(kate_pack_buffer *kpb,const char *s,int len)
00054 {
00055 while (len--) kate_pack_write(kpb,*s++,8);
00056 }
00057
00058 static void kate_write32(kate_pack_buffer *kpb,kate_int32_t v)
00059 {
00060 kate_pack_write(kpb,v&0xff,8);
00061 v>>=8;
00062 kate_pack_write(kpb,v&0xff,8);
00063 v>>=8;
00064 kate_pack_write(kpb,v&0xff,8);
00065 v>>=8;
00066 kate_pack_write(kpb,v&0xff,8);
00067 }
00068
00069 static void kate_write32v(kate_pack_buffer *kpb,kate_int32_t v)
00070 {
00071 if (v>=0 && v<=14) {
00072 kate_pack_write(kpb,v,4);
00073 }
00074 else {
00075 int bits=0;
00076 kate_int32_t tmp;
00077 kate_pack_write(kpb,15,4);
00078 if (v&0x80000000) {
00079 kate_pack_write1(kpb,1);
00080 v=-v;
00081 }
00082 else {
00083 kate_pack_write1(kpb,0);
00084 }
00085 tmp=v;
00086 while (tmp) {
00087 ++bits;
00088 tmp>>=1;
00089 }
00090 if (bits==0) bits=1;
00091 kate_pack_write(kpb,bits-1,5);
00092 kate_pack_write(kpb,v,bits);
00093 }
00094 }
00095
00096 static void kate_write64(kate_pack_buffer *kpb,kate_int64_t v)
00097 {
00098 kate_write32(kpb,(kate_int32_t)v);
00099 v>>=32;
00100 kate_write32(kpb,(kate_int32_t)v);
00101 }
00102
00103 static void kate_open_warp(kate_pack_buffer *warp)
00104 {
00105 kate_pack_writeinit(warp);
00106 }
00107
00108 static void kate_close_warp(kate_pack_buffer *warp,kate_pack_buffer *kpb)
00109 {
00110 int bits=kate_pack_bits(warp);
00111 unsigned char *buffer=kate_pack_get_buffer(warp);
00112 kate_write32v(kpb,bits);
00113 while (bits>0) {
00114 kate_pack_writecopy(kpb,buffer,bits>32?32:bits);
00115 buffer+=32/8;
00116 bits-=32;
00117 }
00118 kate_pack_writeclear(warp);
00119 }
00120
00121 static void kate_warp(kate_pack_buffer *kpb)
00122 {
00123 kate_pack_buffer warp;
00124 kate_open_warp(&warp);
00125 kate_close_warp(&warp,kpb);
00126 }
00127
00128 static int kate_finalize_packet_buffer(kate_pack_buffer *kpb,kate_packet *kp,kate_state *k)
00129 {
00130 if (!kpb || !kp || !k) return KATE_E_INVALID_PARAMETER;
00131 if (!k->kes) return KATE_E_INIT;
00132
00133
00134 kate_pack_writealign(kpb);
00135
00136 kp->nbytes=kate_pack_bytes(kpb);
00137 kp->data=kate_malloc(kp->nbytes);
00138 if (!kp->data) return KATE_E_OUT_OF_MEMORY;
00139
00140 memcpy(kp->data,kate_pack_get_buffer(kpb),kp->nbytes);
00141
00142
00143 kate_pack_writeclear(kpb);
00144 kate_pack_writeinit(kpb);
00145
00146 ++k->kes->packetno;
00147
00148
00149 return kate_encode_state_clear_overrides(k->kes);
00150 }
00151
00152 static int kate_encode_start_header(kate_pack_buffer *kpb,int headerid)
00153 {
00154 if (!kpb || !(headerid&0x80)) return KATE_E_INVALID_PARAMETER;
00155
00156 kate_pack_write(kpb,headerid,8);
00157 kate_writebuf(kpb,"kate\0\0\0",7);
00158 kate_pack_write(kpb,0,8);
00159
00160 return 0;
00161 }
00162
00163 static int kate_encode_write_canvas_size(kate_pack_buffer *kpb,size_t size)
00164 {
00165 size_t base=size;
00166 size_t shift=0;
00167
00168 if (!kpb) return KATE_E_INVALID_PARAMETER;
00169
00170 while (base&~((1<<12)-1)) {
00171
00172 if ((size>>shift)&1) return KATE_E_LIMIT;
00173 ++shift;
00174 base>>=1;
00175 }
00176 if (shift>=16) return KATE_E_LIMIT;
00177
00178
00179 kate_pack_write(kpb,shift,4);
00180 kate_pack_write(kpb,base&0x0f,4);
00181 kate_pack_write(kpb,base>>4,8);
00182
00183 return 0;
00184 }
00185
00186 static int kate_encode_info(kate_state *k,kate_packet *kp)
00187 {
00188 kate_pack_buffer *kpb;
00189 kate_info *ki;
00190 size_t len;
00191 int ret;
00192
00193 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00194 if (!k->kes) return KATE_E_INIT;
00195
00196 kpb=&k->kes->kpb;
00197
00198 ret=kate_encode_start_header(kpb,0x80);
00199 if (ret<0) return ret;
00200
00201 ki=k->ki;
00202 kate_pack_write(kpb,KATE_BITSTREAM_VERSION_MAJOR,8);
00203 kate_pack_write(kpb,KATE_BITSTREAM_VERSION_MINOR,8);
00204 kate_pack_write(kpb,ki->num_headers,8);
00205 kate_pack_write(kpb,ki->text_encoding,8);
00206 kate_pack_write(kpb,ki->text_directionality,8);
00207 kate_pack_write(kpb,0,8);
00208 kate_pack_write(kpb,kate_granule_shift(k->ki),8);
00209 ret=kate_encode_write_canvas_size(kpb,ki->original_canvas_width);
00210 if (ret<0) return ret;
00211 ret=kate_encode_write_canvas_size(kpb,ki->original_canvas_height);
00212 if (ret<0) return ret;
00213 kate_write32(kpb,0);
00214 kate_write32(kpb,ki->gps_numerator);
00215 kate_write32(kpb,ki->gps_denominator);
00216
00217
00218 if (ki->language) {
00219 len=strlen(ki->language);
00220 if (len>15) return KATE_E_LIMIT;
00221 kate_writebuf(kpb,ki->language,len);
00222 }
00223 else len=0;
00224 while (len++<16) kate_pack_write(kpb,0,8);
00225
00226
00227 if (ki->category) {
00228 len=strlen(ki->category);
00229 if (len>15) return KATE_E_LIMIT;
00230 kate_writebuf(kpb,ki->category,len);
00231 }
00232 else len=0;
00233 while (len++<16) kate_pack_write(kpb,0,8);
00234
00235 return kate_finalize_packet_buffer(kpb,kp,k);
00236 }
00237
00238 static int kate_encode_comment(kate_state *k,kate_comment *kc,kate_packet *kp)
00239 {
00240 kate_pack_buffer *kpb;
00241 const char *vendor;
00242 int vendor_len;
00243 int ret;
00244
00245 if (!k || !kc || !kp) return KATE_E_INVALID_PARAMETER;
00246 if (!k->kes) return KATE_E_INIT;
00247
00248 kpb=&k->kes->kpb;
00249
00250 ret=kate_encode_start_header(kpb,0x81);
00251 if (ret<0) return ret;
00252
00253 vendor=kate_get_version_string();
00254 if (!vendor) return KATE_E_INIT;
00255 vendor_len=strlen(vendor);
00256
00257
00258 kate_write32(kpb,vendor_len);
00259 kate_writebuf(kpb,vendor,vendor_len);
00260
00261 if (kc->comments<0) return KATE_E_INIT;
00262 kate_write32(kpb,kc->comments);
00263 if (kc->comments) {
00264 int i;
00265 for(i=0;i<kc->comments;++i) {
00266 if (kc->user_comments[i]) {
00267 if (kc->comment_lengths[i]<0) return KATE_E_INIT;
00268 kate_write32(kpb,kc->comment_lengths[i]);
00269 ret=kate_text_validate(kate_utf8,kc->user_comments[i],kc->comment_lengths[i]);
00270 if (ret<0) return ret;
00271 kate_writebuf(kpb,kc->user_comments[i],kc->comment_lengths[i]);
00272 }
00273 else {
00274 kate_write32(kpb,0);
00275 }
00276 }
00277 }
00278
00279 return kate_finalize_packet_buffer(kpb,kp,k);
00280 }
00281
00282 static int kate_encode_region(const kate_region *kr,kate_pack_buffer *kpb)
00283 {
00284 if (!kr || !kpb) return KATE_E_INVALID_PARAMETER;
00285
00286 kate_pack_write(kpb,kr->metric,8);
00287 kate_write32v(kpb,kr->x);
00288 kate_write32v(kpb,kr->y);
00289 kate_write32v(kpb,kr->w);
00290 kate_write32v(kpb,kr->h);
00291 kate_write32v(kpb,kr->style);
00292
00293 {
00294
00295 kate_pack_buffer warp;
00296 kate_open_warp(&warp);
00297 kate_pack_write1(&warp,kr->clip);
00298 kate_close_warp(&warp,kpb);
00299 }
00300
00301 kate_warp(kpb);
00302
00303 return 0;
00304 }
00305
00306 static int kate_encode_regions(kate_state *k,kate_packet *kp)
00307 {
00308 kate_pack_buffer *kpb;
00309 kate_info *ki;
00310 size_t n;
00311 int ret;
00312
00313 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00314 if (!k->kes) return KATE_E_INIT;
00315
00316 kpb=&k->kes->kpb;
00317
00318 ret=kate_encode_start_header(kpb,0x82);
00319 if (ret<0) return ret;
00320
00321 ki=k->ki;
00322 if (!ki) return KATE_E_INIT;
00323
00324 kate_write32v(kpb,ki->nregions);
00325
00326 for(n=0;n<ki->nregions;++n) {
00327 ret=kate_encode_region(ki->regions[n],kpb);
00328 if (ret<0) return ret;
00329 }
00330
00331 kate_warp(kpb);
00332
00333 return kate_finalize_packet_buffer(kpb,kp,k);
00334 }
00335
00336 static int kate_encode_color(const kate_color *kc,kate_pack_buffer *kpb)
00337 {
00338 if (!kc || !kpb) return KATE_E_INVALID_PARAMETER;
00339 kate_pack_write(kpb,kc->r,8);
00340 kate_pack_write(kpb,kc->g,8);
00341 kate_pack_write(kpb,kc->b,8);
00342 kate_pack_write(kpb,kc->a,8);
00343 return 0;
00344 }
00345
00346 static int kate_encode_style(const kate_style *ks,kate_pack_buffer *kpb)
00347 {
00348 kate_float d[8];
00349 size_t idx;
00350
00351 if (!ks || !kpb) return KATE_E_INVALID_PARAMETER;
00352
00353 idx=0;
00354 d[idx++]=ks->halign;
00355 d[idx++]=ks->valign;
00356 d[idx++]=ks->font_width;
00357 d[idx++]=ks->font_height;
00358 d[idx++]=ks->left_margin;
00359 d[idx++]=ks->top_margin;
00360 d[idx++]=ks->right_margin;
00361 d[idx++]=ks->bottom_margin;
00362 kate_fp_encode_kate_float(sizeof(d)/sizeof(d[0]),d,1,kpb);
00363 kate_encode_color(&ks->text_color,kpb);
00364 kate_encode_color(&ks->background_color,kpb);
00365 kate_encode_color(&ks->draw_color,kpb);
00366 kate_pack_write(kpb,ks->font_metric,8);
00367 kate_pack_write(kpb,ks->margin_metric,8);
00368 kate_pack_write1(kpb,ks->bold);
00369 kate_pack_write1(kpb,ks->italics);
00370 kate_pack_write1(kpb,ks->underline);
00371 kate_pack_write1(kpb,ks->strike);
00372
00373 {
00374
00375 kate_pack_buffer warp;
00376 kate_open_warp(&warp);
00377 kate_pack_write1(&warp,ks->justify);
00378 if (ks->font) {
00379 size_t len=strlen(ks->font);
00380 kate_write32v(&warp,len);
00381 kate_writebuf(&warp,ks->font,len);
00382 }
00383 else {
00384 kate_write32v(&warp,0);
00385 }
00386 kate_close_warp(&warp,kpb);
00387 }
00388
00389 {
00390
00391 kate_pack_buffer warp;
00392 kate_open_warp(&warp);
00393 kate_write32v(&warp,ks->wrap_mode);
00394 kate_close_warp(&warp,kpb);
00395 }
00396
00397 kate_warp(kpb);
00398
00399 return 0;
00400 }
00401
00402 static int kate_encode_styles(kate_state *k,kate_packet *kp)
00403 {
00404 kate_pack_buffer *kpb;
00405 kate_info *ki;
00406 size_t n;
00407 int ret;
00408
00409 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00410 if (!k->kes) return KATE_E_INIT;
00411
00412 kpb=&k->kes->kpb;
00413
00414 ret=kate_encode_start_header(kpb,0x83);
00415 if (ret<0) return ret;
00416
00417 ki=k->ki;
00418 if (!ki) return KATE_E_INIT;
00419
00420 kate_write32v(kpb,ki->nstyles);
00421
00422 for(n=0;n<ki->nstyles;++n) {
00423 ret=kate_encode_style(ki->styles[n],kpb);
00424 if (ret<0) return ret;
00425 }
00426
00427 kate_warp(kpb);
00428
00429 return kate_finalize_packet_buffer(kpb,kp,k);
00430 }
00431
00432 static int kate_encode_curve(const kate_curve *kc,kate_pack_buffer *kpb)
00433 {
00434 if (!kc || !kpb) return KATE_E_INVALID_PARAMETER;
00435
00436 kate_pack_write(kpb,kc->type,8);
00437 kate_write32v(kpb,kc->npts);
00438 kate_warp(kpb);
00439 if (kc->npts) kate_fp_encode_kate_float(kc->npts,kc->pts,2,kpb);
00440
00441 return 0;
00442 }
00443
00444 static int kate_encode_curves(kate_state *k,kate_packet *kp)
00445 {
00446 kate_pack_buffer *kpb;
00447 kate_info *ki;
00448 size_t n;
00449 int ret;
00450
00451 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00452 if (!k->kes) return KATE_E_INIT;
00453
00454 kpb=&k->kes->kpb;
00455
00456 ret=kate_encode_start_header(kpb,0x84);
00457 if (ret<0) return ret;
00458
00459 ki=k->ki;
00460 if (!ki) return KATE_E_INIT;
00461
00462 kate_write32v(kpb,ki->ncurves);
00463
00464 for(n=0;n<ki->ncurves;++n) {
00465 ret=kate_encode_curve(ki->curves[n],kpb);
00466 if (ret<0) return ret;
00467 }
00468
00469 kate_warp(kpb);
00470
00471 return kate_finalize_packet_buffer(kpb,kp,k);
00472 }
00473
00474 static int kate_encode_motion(const kate_info *ki,const kate_motion *km,kate_pack_buffer *kpb)
00475 {
00476 size_t n;
00477 int ret;
00478
00479 if (!ki || !km || !kpb) return KATE_E_INVALID_PARAMETER;
00480
00481 kate_write32v(kpb,km->ncurves);
00482 for (n=0;n<km->ncurves;++n) {
00483 int idx=kate_find_curve(ki,km->curves[n]);
00484 if (idx<0) {
00485 kate_pack_write1(kpb,0);
00486 ret=kate_encode_curve(km->curves[n],kpb);
00487 if (ret<0) return ret;
00488 }
00489 else {
00490 kate_pack_write1(kpb,1);
00491 kate_write32v(kpb,idx);
00492 }
00493 }
00494 kate_fp_encode_kate_float(km->ncurves,km->durations,1,kpb);
00495 kate_pack_write(kpb,km->x_mapping,8);
00496 kate_pack_write(kpb,km->y_mapping,8);
00497 kate_pack_write(kpb,km->semantics,8);
00498 kate_pack_write1(kpb,km->periodic);
00499 kate_warp(kpb);
00500
00501 return 0;
00502 }
00503
00504 static int kate_encode_motions(kate_state *k,kate_packet *kp)
00505 {
00506 kate_pack_buffer *kpb;
00507 kate_info *ki;
00508 size_t n;
00509 int ret;
00510
00511 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00512 if (!k->kes) return KATE_E_INIT;
00513
00514 kpb=&k->kes->kpb;
00515
00516 ret=kate_encode_start_header(kpb,0x85);
00517 if (ret<0) return ret;
00518
00519 ki=k->ki;
00520 if (!ki) return KATE_E_INIT;
00521
00522 kate_write32v(kpb,ki->nmotions);
00523
00524 for(n=0;n<ki->nmotions;++n) {
00525 ret=kate_encode_motion(ki,ki->motions[n],kpb);
00526 if (ret<0) return ret;
00527 }
00528
00529 kate_warp(kpb);
00530
00531 return kate_finalize_packet_buffer(kpb,kp,k);
00532 }
00533
00534 static int kate_encode_palette(const kate_palette *kp,kate_pack_buffer *kpb)
00535 {
00536 size_t n;
00537
00538 if (!kp || !kpb) return KATE_E_INVALID_PARAMETER;
00539 if (kp->ncolors<=0 || kp->ncolors>256) return KATE_E_LIMIT;
00540
00541 kate_pack_write(kpb,kp->ncolors-1,8);
00542 for (n=0;n<kp->ncolors;++n) {
00543 int ret=kate_encode_color(kp->colors+n,kpb);
00544 if (ret<0) return ret;
00545 }
00546 kate_warp(kpb);
00547
00548 return 0;
00549 }
00550
00551 static int kate_encode_palettes(kate_state *k,kate_packet *kp)
00552 {
00553 kate_pack_buffer *kpb;
00554 kate_info *ki;
00555 size_t n;
00556 int ret;
00557
00558 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00559 if (!k->kes) return KATE_E_INIT;
00560
00561 kpb=&k->kes->kpb;
00562
00563 ret=kate_encode_start_header(kpb,0x86);
00564 if (ret<0) return ret;
00565
00566 ki=k->ki;
00567 if (!ki) return KATE_E_INIT;
00568
00569 kate_write32v(kpb,ki->npalettes);
00570
00571 for(n=0;n<ki->npalettes;++n) {
00572 ret=kate_encode_palette(ki->palettes[n],kpb);
00573 if (ret<0) return ret;
00574 }
00575
00576 kate_warp(kpb);
00577
00578 return kate_finalize_packet_buffer(kpb,kp,k);
00579 }
00580
00581 #if 0
00582 static int kate_encode_paletted_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
00583 {
00584 size_t w,h,n;
00585 unsigned int maxpixel;
00586
00587 if (kb->bpp>8) return KATE_E_LIMIT;
00588
00589 kate_write32v(kpb,kb->palette);
00590 n=0;
00591 maxpixel=(1<<kb->bpp)-1;
00592 for (h=0;h<kb->height;++h) {
00593 for (w=0;w<kb->width;++w) {
00594 unsigned int pixel=kb->pixels[n++];
00595 if (pixel>maxpixel) return KATE_E_LIMIT;
00596 kate_pack_write(kpb,pixel,kb->bpp);
00597 }
00598 }
00599
00600 return 0;
00601 }
00602 #endif
00603
00604 static int kate_encode_rle_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
00605 {
00606 if (kb->bpp>8) return KATE_E_LIMIT;
00607
00608 kate_pack_write(kpb,kate_bitmap_type_paletted,8);
00609 kate_pack_write(kpb,1,8);
00610 kate_write32v(kpb,kb->bpp);
00611 kate_write32v(kpb,kb->palette);
00612
00613 return kate_rle_encode(kb->width,kb->height,kb->pixels,kb->bpp,kpb);
00614 }
00615
00616 static int kate_encode_png_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
00617 {
00618 kate_pack_write(kpb,kate_bitmap_type_png,8);
00619 kate_write32(kpb,kb->size);
00620 kate_writebuf(kpb,(const char*)kb->pixels,kb->size);
00621
00622 return 0;
00623 }
00624
00625 static int kate_encode_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
00626 {
00627 int ret;
00628
00629 if (!kb || !kpb) return KATE_E_INVALID_PARAMETER;
00630
00631 kate_write32v(kpb,kb->width);
00632 kate_write32v(kpb,kb->height);
00633 #if 0
00634
00635 kate_pack_write(kpb,kb->bpp,8);
00636 #else
00637 kate_pack_write(kpb,0,8);
00638 #endif
00639
00640 switch (kb->type) {
00641 case kate_bitmap_type_paletted:
00642 ret=kate_encode_rle_bitmap(kb,kpb);
00643 break;
00644 case kate_bitmap_type_png:
00645 ret=kate_encode_png_bitmap(kb,kpb);
00646 break;
00647 default:
00648 ret=KATE_E_INVALID_PARAMETER;
00649 break;
00650 }
00651
00652 if (ret<0) return ret;
00653
00654 {
00655
00656 kate_pack_buffer warp;
00657 kate_open_warp(&warp);
00658 kate_write32v(&warp,kb->x_offset);
00659 kate_write32v(&warp,kb->y_offset);
00660 kate_close_warp(&warp,kpb);
00661 }
00662
00663 kate_warp(kpb);
00664
00665 return 0;
00666 }
00667
00668 static int kate_encode_bitmaps(kate_state *k,kate_packet *kp)
00669 {
00670 kate_pack_buffer *kpb;
00671 kate_info *ki;
00672 size_t n;
00673 int ret;
00674
00675 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00676 if (!k->kes) return KATE_E_INIT;
00677
00678 kpb=&k->kes->kpb;
00679
00680 ret=kate_encode_start_header(kpb,0x87);
00681 if (ret<0) return ret;
00682
00683 ki=k->ki;
00684 if (!ki) return KATE_E_INIT;
00685
00686 kate_write32v(kpb,ki->nbitmaps);
00687
00688 for(n=0;n<ki->nbitmaps;++n) {
00689 ret=kate_encode_bitmap(ki->bitmaps[n],kpb);
00690 if (ret<0) return ret;
00691 }
00692
00693 kate_warp(kpb);
00694
00695 return kate_finalize_packet_buffer(kpb,kp,k);
00696 }
00697
00698 static int kate_encode_font_range(const kate_info *ki,const kate_font_range *kfr,kate_pack_buffer *kpb)
00699 {
00700 if (!ki || !kfr || !kpb) return KATE_E_INVALID_PARAMETER;
00701
00702 if (!kate_is_valid_code_point(kfr->first_code_point)) return KATE_E_TEXT;
00703 if (!kate_is_valid_code_point(kfr->last_code_point)) return KATE_E_TEXT;
00704 if (kfr->first_bitmap<0) return KATE_E_LIMIT;
00705 if ((size_t)(kfr->first_bitmap+(kfr->last_code_point-kfr->first_code_point))>=ki->nbitmaps) return KATE_E_LIMIT;
00706
00707 kate_write32v(kpb,kfr->first_code_point);
00708 kate_write32v(kpb,kfr->last_code_point);
00709 kate_write32v(kpb,kfr->first_bitmap);
00710 kate_warp(kpb);
00711
00712 return 0;
00713 }
00714
00715 static int kate_encode_font_ranges(kate_state *k,kate_packet *kp)
00716 {
00717 kate_pack_buffer *kpb;
00718 kate_info *ki;
00719 size_t n,l;
00720 int ret;
00721
00722 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
00723 if (!k->kes) return KATE_E_INIT;
00724
00725 kpb=&k->kes->kpb;
00726
00727 ret=kate_encode_start_header(kpb,0x88);
00728 if (ret<0) return ret;
00729
00730 ki=k->ki;
00731 if (!ki) return KATE_E_INIT;
00732
00733 kate_write32v(kpb,ki->nfont_ranges);
00734 for(n=0;n<ki->nfont_ranges;++n) {
00735 ret=kate_encode_font_range(ki,ki->font_ranges[n],kpb);
00736 if (ret<0) return ret;
00737 }
00738
00739 kate_write32v(kpb,ki->nfont_mappings);
00740 for(n=0;n<ki->nfont_mappings;++n) {
00741 const kate_font_mapping *kfm=ki->font_mappings[n];
00742 kate_write32v(kpb,kfm->nranges);
00743 for (l=0;l<kfm->nranges;++l) {
00744 const kate_font_range *kfr=kfm->ranges[l];
00745 int idx=kate_find_font_range(ki,kfr);
00746 if (idx>=0) {
00747 kate_pack_write1(kpb,1);
00748 kate_write32v(kpb,idx);
00749 }
00750 else {
00751 kate_pack_write1(kpb,0);
00752 ret=kate_encode_font_range(ki,kfr,kpb);
00753 if (ret<0) return ret;
00754 }
00755 }
00756 }
00757
00758 kate_warp(kpb);
00759
00760 return kate_finalize_packet_buffer(kpb,kp,k);
00761 }
00762
00763 static inline int kate_check_granule(kate_state *k,kate_int64_t *granulepos)
00764 {
00765 if (*granulepos<k->kes->granulepos) return -1;
00766 return 0;
00767 }
00768
00769 #define WRITE_OVERRIDE(kpb,var,def,write) \
00770 do \
00771 if (ret==0 && (kes->overrides.var!=(def))) { \
00772 kate_pack_write1(kpb,1); \
00773 write; \
00774 } \
00775 else kate_pack_write1(kpb,0); \
00776 while(0)
00777
00778 static int kate_encode_overrides(kate_state *k,kate_pack_buffer *kpb)
00779 {
00780 kate_encode_state *kes;
00781 size_t n;
00782 int ret=0;
00783
00784 if (!k || !kpb) return KATE_E_INVALID_PARAMETER;
00785 kes=k->kes;
00786 if (!kes) return KATE_E_INIT;
00787
00788 if (kes->overrides.language
00789 || kes->overrides.text_encoding!=k->ki->text_encoding
00790 || kes->overrides.text_directionality!=k->ki->text_directionality
00791 || kes->overrides.region_index>=0
00792 || kes->overrides.region
00793 || kes->overrides.style_index>=0
00794 || kes->overrides.style
00795 || kes->overrides.secondary_style_index>=0
00796 || kes->overrides.secondary_style
00797 || kes->overrides.font_mapping_index>=0
00798 ) {
00799 kate_pack_write1(kpb,1);
00800 WRITE_OVERRIDE(kpb,text_encoding,k->ki->text_encoding,kate_pack_write(kpb,kes->overrides.text_encoding,8));
00801 WRITE_OVERRIDE(kpb,text_directionality,k->ki->text_directionality,kate_pack_write(kpb,kes->overrides.text_directionality,8));
00802 WRITE_OVERRIDE(kpb,language,NULL,
00803 do {
00804 size_t len=strlen(kes->overrides.language);
00805 kate_write32v(kpb,len);
00806 kate_writebuf(kpb,kes->overrides.language,len);
00807 } while(0));
00808 WRITE_OVERRIDE(kpb,region_index,-1,kate_write32v(kpb,kes->overrides.region_index));
00809 WRITE_OVERRIDE(kpb,region,NULL,ret=kate_encode_region(kes->overrides.region,kpb));
00810 WRITE_OVERRIDE(kpb,style_index,-1,kate_write32v(kpb,kes->overrides.style_index));
00811 WRITE_OVERRIDE(kpb,style,NULL,ret=kate_encode_style(kes->overrides.style,kpb));
00812 WRITE_OVERRIDE(kpb,secondary_style_index,-1,kate_write32v(kpb,kes->overrides.secondary_style_index));
00813 WRITE_OVERRIDE(kpb,secondary_style,NULL,ret=kate_encode_style(kes->overrides.secondary_style,kpb));
00814 WRITE_OVERRIDE(kpb,font_mapping_index,-1,kate_write32v(kpb,kes->overrides.font_mapping_index));
00815 }
00816 else kate_pack_write1(kpb,0);
00817
00818 if (ret==0) {
00819
00820 kate_pack_buffer warp;
00821 kate_open_warp(&warp);
00822 if (kes->overrides.palette_index>=0
00823 || kes->overrides.palette
00824 || kes->overrides.bitmap_index>=0
00825 || kes->overrides.bitmap
00826 || kes->overrides.text_markup_type!=k->ki->text_markup_type) {
00827 kate_pack_write1(&warp,1);
00828 WRITE_OVERRIDE(&warp,palette_index,-1,kate_write32v(&warp,kes->overrides.palette_index));
00829 WRITE_OVERRIDE(&warp,palette,NULL,ret=kate_encode_palette(kes->overrides.palette,&warp));
00830 WRITE_OVERRIDE(&warp,bitmap_index,-1,kate_write32v(&warp,kes->overrides.bitmap_index));
00831 WRITE_OVERRIDE(&warp,bitmap,NULL,ret=kate_encode_bitmap(kes->overrides.bitmap,&warp));
00832 WRITE_OVERRIDE(&warp,text_markup_type,k->ki->text_markup_type,kate_pack_write(&warp,kes->overrides.text_markup_type,8));
00833 }
00834 else kate_pack_write1(&warp,0);
00835 kate_close_warp(&warp,kpb);
00836 }
00837
00838 if (ret==0) {
00839
00840 kate_pack_buffer warp;
00841 kate_open_warp(&warp);
00842 kate_write32v(&warp,kes->nbitmaps);
00843 for(n=0;n<kes->nbitmaps;++n) {
00844 if (kes->bitmaps[n]==NULL) {
00845
00846 kate_pack_write1(&warp,1);
00847 kate_write32v(&warp,kes->bitmap_indices[n]);
00848 }
00849 else {
00850
00851 kate_pack_write1(&warp,0);
00852 ret=kate_encode_bitmap(kes->bitmaps[n],&warp);
00853 if (ret<0) break;
00854 }
00855 }
00856 kate_close_warp(&warp,kpb);
00857 }
00858
00859 kate_warp(kpb);
00860
00861 return ret;
00862 }
00863
00878 int kate_encode_text_raw_times(kate_state *k,kate_int64_t t0,kate_int64_t t1,const char *text,size_t sz,kate_packet *kp)
00879 {
00880 kate_pack_buffer *kpb;
00881 kate_int64_t start_granulepos;
00882 kate_int64_t start;
00883 kate_int64_t duration;
00884 kate_int64_t backlink;
00885 kate_int64_t earliest_t;
00886 int ret;
00887 size_t n;
00888
00889 if (!k || !text || !kp) return KATE_E_INVALID_PARAMETER;
00890 if (t0<0 || t1<t0) return KATE_E_INVALID_PARAMETER;
00891 if (!k->kes) return KATE_E_INIT;
00892 if (k->kes->eos) return KATE_E_INIT;
00893
00894 ret=kate_text_validate(k->kes->overrides.text_encoding,text,sz);
00895 if (ret<0) return ret;
00896
00897 ret=kate_encode_state_trim_events(k->kes,t0);
00898 if (ret<0) return ret;
00899 ret=kate_encode_state_add_event(k->kes,t0,t1);
00900 if (ret<0) return ret;
00901 ret=kate_encode_state_get_earliest_event(k->kes,&earliest_t,NULL);
00902 if (ret<0) return ret;
00903
00904 start_granulepos=(earliest_t<<k->ki->granule_shift)|(t0-earliest_t);
00905 if (start_granulepos<0) return KATE_E_BAD_GRANULE;
00906 if (kate_check_granule(k,&start_granulepos)<0) return KATE_E_BAD_GRANULE;
00907
00908 start=t0;
00909 if (start<0) return KATE_E_BAD_GRANULE;
00910 duration=t1-t0;
00911 if (duration<0) return KATE_E_BAD_GRANULE;
00912 backlink=t0-earliest_t;
00913 if (backlink<0) return KATE_E_BAD_GRANULE;
00914
00915 kpb=&k->kes->kpb;
00916 kate_pack_write(kpb,0x00,8);
00917
00918 kate_write64(kpb,start);
00919 kate_write64(kpb,duration);
00920 kate_write64(kpb,backlink);
00921
00922 kate_write32(kpb,sz);
00923 kate_writebuf(kpb,text,sz);
00924
00925 if (k->kes->id>=0) {
00926 kate_pack_write1(kpb,1);
00927 kate_write32v(kpb,k->kes->id);
00928 }
00929 else {
00930 kate_pack_write1(kpb,0);
00931 }
00932
00933 if (k->kes->nmotions) {
00934 kate_pack_write1(kpb,1);
00935 kate_write32v(kpb,k->kes->nmotions);
00936 for (n=0;n<k->kes->nmotions;++n) {
00937 if (k->kes->motions[n]==NULL) {
00938
00939 kate_pack_write1(kpb,1);
00940 kate_write32v(kpb,k->kes->motion_indices[n]);
00941 }
00942 else {
00943
00944 kate_pack_write1(kpb,0);
00945 ret=kate_encode_motion(k->ki,k->kes->motions[n],kpb);
00946 if (ret<0) return ret;
00947 }
00948 }
00949 }
00950 else kate_pack_write1(kpb,0);
00951
00952 kate_encode_overrides(k,kpb);
00953
00954 if (start_granulepos>k->kes->furthest_granule) k->kes->furthest_granule=start_granulepos;
00955
00956 k->kes->granulepos=start_granulepos;
00957 ret=kate_finalize_packet_buffer(kpb,kp,k);
00958 if (ret<0) return ret;
00959
00960
00961 ret=kate_encode_state_save_event_buffer(k->kes,kp->nbytes,kp->data);
00962 if (ret<0) return ret;
00963
00964 return 0;
00965 }
00966
00981 int kate_encode_text(kate_state *k,kate_float t0,kate_float t1,const char *text,size_t sz,kate_packet *kp)
00982 {
00983 if (!k) return KATE_E_INVALID_PARAMETER;
00984 return kate_encode_text_raw_times(k,kate_duration_granule(k->ki,t0),kate_duration_granule(k->ki,t1),text,sz,kp);
00985 }
00986
00996 int kate_encode_keepalive_raw_times(kate_state *k,kate_int64_t t,kate_packet *kp)
00997 {
00998 kate_pack_buffer *kpb;
00999 kate_int64_t granulepos;
01000 kate_int64_t earliest_t;
01001 int ret;
01002
01003 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
01004 if (!k->kes) return KATE_E_INIT;
01005 if (k->kes->eos) return KATE_E_INIT;
01006
01007 ret=kate_encode_state_trim_events(k->kes,t);
01008 if (ret<0) return ret;
01009
01010 ret=kate_encode_state_get_earliest_event(k->kes,&earliest_t,NULL);
01011 if (ret==KATE_E_NOT_FOUND) {
01012
01013 earliest_t=t;
01014 ret=0;
01015 }
01016 if (ret<0) return ret;
01017
01018 granulepos=(earliest_t<<k->ki->granule_shift)|(t-earliest_t);
01019 if (granulepos<0) return KATE_E_BAD_GRANULE;
01020
01021 if (kate_check_granule(k,&granulepos)<0) return KATE_E_BAD_GRANULE;
01022 k->kes->granulepos=granulepos;
01023
01024 ret=kate_encode_state_add_event(k->kes,t,t);
01025 if (ret<0) return ret;
01026
01027 kpb=&k->kes->kpb;
01028 kate_pack_write(kpb,0x01,8);
01029
01030 return kate_finalize_packet_buffer(kpb,kp,k);
01031 }
01032
01042 int kate_encode_keepalive(kate_state *k,kate_float t,kate_packet *kp)
01043 {
01044 if (!k) return KATE_E_INVALID_PARAMETER;
01045 return kate_encode_keepalive_raw_times(k,kate_duration_granule(k->ki,t),kp);
01046 }
01047
01066 int kate_encode_repeat_raw_times(kate_state *k,kate_int64_t t,kate_int64_t threshold,kate_packet *kp)
01067 {
01068 kate_int64_t earliest_t;
01069 kate_int64_t granulepos;
01070 int ret;
01071
01072 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
01073 if (threshold<0) return KATE_E_INVALID_PARAMETER;
01074 if (!k->kes) return KATE_E_INIT;
01075 if (k->kes->eos) return KATE_E_INIT;
01076
01077 ret=kate_encode_state_trim_events(k->kes,t);
01078 if (ret<0) return ret;
01079 ret=kate_encode_state_get_earliest_event(k->kes,&earliest_t,NULL);
01080 if (ret==KATE_E_NOT_FOUND) {
01081
01082 earliest_t=t;
01083 }
01084 else if (ret<0) {
01085 return ret;
01086 }
01087 granulepos=(earliest_t<<k->ki->granule_shift)|(t-earliest_t);
01088 if (granulepos<0) return KATE_E_BAD_GRANULE;
01089
01090 if (kate_check_granule(k,&granulepos)<0) return KATE_E_BAD_GRANULE;
01091
01092 ret=kate_encode_state_get_repeat(k->kes,t,threshold,kp);
01093 if (ret>0) {
01094
01095 k->kes->granulepos=granulepos;
01096 }
01097 return ret;
01098 }
01099
01117 int kate_encode_repeat(kate_state *k,kate_float t,kate_float threshold,kate_packet *kp)
01118 {
01119 if (!k) return KATE_E_INVALID_PARAMETER;
01120 return kate_encode_repeat_raw_times(k,kate_duration_granule(k->ki,t),kate_duration_granule(k->ki,threshold),kp);
01121 }
01122
01134 int kate_encode_finish_raw_times(kate_state *k,kate_int64_t t,kate_packet *kp)
01135 {
01136 kate_pack_buffer *kpb;
01137 kate_int64_t granulepos;
01138 int ret;
01139
01140 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
01141 if (!k->kes) return KATE_E_INIT;
01142 if (k->kes->eos) return KATE_E_INIT;
01143
01144 ret=kate_encode_state_trim_events(k->kes,t);
01145 if (ret<0) return ret;
01146
01147 if (t<0) {
01148 ret=kate_encode_state_get_latest_event(k->kes,NULL,&t);
01149 if (ret==KATE_E_NOT_FOUND) {
01150
01151 t=0;
01152 ret=0;
01153 }
01154 if (ret<0) return ret;
01155 }
01156
01157 granulepos=t<<k->ki->granule_shift;
01158 if (granulepos<0) return KATE_E_BAD_GRANULE;
01159
01160 if (kate_check_granule(k,&granulepos)<0) return KATE_E_BAD_GRANULE;
01161 k->kes->granulepos=granulepos;
01162
01163 kpb=&k->kes->kpb;
01164 kate_pack_write(kpb,0x7f,8);
01165
01166 k->kes->eos=1;
01167
01168 return kate_finalize_packet_buffer(kpb,kp,k);
01169 }
01170
01181 int kate_encode_finish(kate_state *k,kate_float t,kate_packet *kp)
01182 {
01183 if (!k) return KATE_E_INVALID_PARAMETER;
01184 return kate_encode_finish_raw_times(k,kate_duration_granule(k->ki,t),kp);
01185 }
01186
01199 int kate_encode_headers(kate_state *k,kate_comment *kc,kate_packet *kp)
01200 {
01201 if (!k || !kc || !kp) return KATE_E_INVALID_PARAMETER;
01202 if (!k->kes) return KATE_E_INIT;
01203 if (k->kes->eos) return KATE_E_INIT;
01204
01205 switch (k->kes->packetno+1) {
01206 case 0: return kate_encode_info(k,kp);
01207 case 1: return kate_encode_comment(k,kc,kp);
01208 case 2: return kate_encode_regions(k,kp);
01209 case 3: return kate_encode_styles(k,kp);
01210 case 4: return kate_encode_curves(k,kp);
01211 case 5: return kate_encode_motions(k,kp);
01212 case 6: return kate_encode_palettes(k,kp);
01213 case 7: return kate_encode_bitmaps(k,kp);
01214 case 8: return kate_encode_font_ranges(k,kp);
01215 case 9: return 1;
01216 default: return KATE_E_INVALID_PARAMETER;
01217 }
01218 }
01219
01231 int kate_encode_add_motion(kate_state *k,kate_motion *km,int destroy)
01232 {
01233 if (!k || !km) return KATE_E_INVALID_PARAMETER;
01234 if (!k->kes) return KATE_E_INIT;
01235
01236 return kate_encode_state_add_motion(k->kes,km,destroy);
01237 }
01238
01247 int kate_encode_add_motion_index(kate_state *k,size_t motion)
01248 {
01249 if (!k) return KATE_E_INVALID_PARAMETER;
01250 if (!k->ki) return KATE_E_INIT;
01251 if (motion>=k->ki->nmotions) return KATE_E_INVALID_PARAMETER;
01252 if (!k->kes) return KATE_E_INIT;
01253
01254 return kate_encode_state_add_motion_index(k->kes,motion);
01255 }
01256
01265 int kate_encode_add_bitmap(kate_state *k,const kate_bitmap *kb)
01266 {
01267 if (!k || !kb) return KATE_E_INVALID_PARAMETER;
01268 if (!k->kes) return KATE_E_INIT;
01269
01270 return kate_encode_state_add_bitmap(k->kes,kb);
01271 }
01272
01281 int kate_encode_add_bitmap_index(kate_state *k,size_t bitmap)
01282 {
01283 if (!k) return KATE_E_INVALID_PARAMETER;
01284 if (!k->ki) return KATE_E_INIT;
01285 if (bitmap>=k->ki->nbitmaps) return KATE_E_INVALID_PARAMETER;
01286 if (!k->kes) return KATE_E_INIT;
01287
01288 return kate_encode_state_add_bitmap_index(k->kes,bitmap);
01289 }
01290
01299 int kate_encode_set_region_index(kate_state *k,size_t region)
01300 {
01301 if (!k) return KATE_E_INVALID_PARAMETER;
01302 if (!k->kes) return KATE_E_INIT;
01303 if (!k->ki) return KATE_E_INIT;
01304 if (region>=k->ki->nregions) return KATE_E_INVALID_PARAMETER;
01305 if (k->kes->overrides.region) return KATE_E_INIT;
01306 k->kes->overrides.region_index=region;
01307 return 0;
01308 }
01309
01318 int kate_encode_set_region(kate_state *k,const kate_region *kr)
01319 {
01320 if (!k || !kr) return KATE_E_INVALID_PARAMETER;
01321 if (!k->kes) return KATE_E_INIT;
01322 if (!k->ki) return KATE_E_INIT;
01323 if (k->kes->overrides.region_index>=0) return KATE_E_INIT;
01324 k->kes->overrides.region=kr;
01325 return 0;
01326 }
01327
01336 int kate_encode_set_style_index(kate_state *k,size_t style)
01337 {
01338 if (!k) return KATE_E_INVALID_PARAMETER;
01339 if (!k->kes) return KATE_E_INIT;
01340 if (!k->ki) return KATE_E_INIT;
01341 if (style>=k->ki->nstyles) return KATE_E_INVALID_PARAMETER;
01342 if (k->kes->overrides.style) return KATE_E_INIT;
01343 k->kes->overrides.style_index=style;
01344 return 0;
01345 }
01346
01355 int kate_encode_set_style(kate_state *k,const kate_style *ks)
01356 {
01357 if (!k || !ks) return KATE_E_INVALID_PARAMETER;
01358 if (!k->kes) return KATE_E_INIT;
01359 if (!k->ki) return KATE_E_INIT;
01360 if (k->kes->overrides.style_index>=0) return KATE_E_INIT;
01361 k->kes->overrides.style=ks;
01362 return 0;
01363 }
01364
01373 int kate_encode_set_secondary_style_index(kate_state *k,size_t style)
01374 {
01375 if (!k) return KATE_E_INVALID_PARAMETER;
01376 if (!k->kes) return KATE_E_INIT;
01377 if (!k->ki) return KATE_E_INIT;
01378 if (style>=k->ki->nstyles) return KATE_E_INVALID_PARAMETER;
01379 if (k->kes->overrides.secondary_style) return KATE_E_INIT;
01380 k->kes->overrides.secondary_style_index=style;
01381 return 0;
01382 }
01383
01392 int kate_encode_set_secondary_style(kate_state *k,const kate_style *ks)
01393 {
01394 if (!k || !ks) return KATE_E_INVALID_PARAMETER;
01395 if (!k->kes) return KATE_E_INIT;
01396 if (!k->ki) return KATE_E_INIT;
01397 if (k->kes->overrides.secondary_style_index>=0) return KATE_E_INIT;
01398 k->kes->overrides.secondary_style=ks;
01399 return 0;
01400 }
01401
01410 int kate_encode_set_palette_index(kate_state *k,size_t palette)
01411 {
01412 if (!k) return KATE_E_INVALID_PARAMETER;
01413 if (!k->kes) return KATE_E_INIT;
01414 if (!k->ki) return KATE_E_INIT;
01415 if (palette>=k->ki->npalettes) return KATE_E_INVALID_PARAMETER;
01416 if (k->kes->overrides.palette) return KATE_E_INIT;
01417 k->kes->overrides.palette_index=palette;
01418 return 0;
01419 }
01420
01429 int kate_encode_set_palette(kate_state *k,const kate_palette *kp)
01430 {
01431 if (!k || !kp) return KATE_E_INVALID_PARAMETER;
01432 if (!k->kes) return KATE_E_INIT;
01433 if (!k->ki) return KATE_E_INIT;
01434 if (k->kes->overrides.palette_index>=0) return KATE_E_INIT;
01435 k->kes->overrides.palette=kp;
01436 return 0;
01437 }
01438
01447 int kate_encode_set_bitmap_index(kate_state *k,size_t bitmap)
01448 {
01449 if (!k) return KATE_E_INVALID_PARAMETER;
01450 if (!k->kes) return KATE_E_INIT;
01451 if (!k->ki) return KATE_E_INIT;
01452 if (bitmap>=k->ki->nbitmaps) return KATE_E_INVALID_PARAMETER;
01453 if (k->kes->overrides.bitmap) return KATE_E_INIT;
01454 k->kes->overrides.bitmap_index=bitmap;
01455 return 0;
01456 }
01457
01466 int kate_encode_set_bitmap(kate_state *k,const kate_bitmap *kb)
01467 {
01468 if (!k || !kb) return KATE_E_INVALID_PARAMETER;
01469 if (!k->kes) return KATE_E_INIT;
01470 if (!k->ki) return KATE_E_INIT;
01471 if (k->kes->overrides.bitmap_index>=0) return KATE_E_INIT;
01472 k->kes->overrides.bitmap=kb;
01473 return 0;
01474 }
01475
01485 int kate_encode_set_font_mapping_index(kate_state *k,size_t font_mapping)
01486 {
01487 if (!k) return KATE_E_INVALID_PARAMETER;
01488 if (!k->kes) return KATE_E_INIT;
01489 if (!k->ki) return KATE_E_INIT;
01490 if (font_mapping>=k->ki->nfont_mappings) return KATE_E_INVALID_PARAMETER;
01491 k->kes->overrides.font_mapping_index=font_mapping;
01492 return 0;
01493 }
01494
01503 int kate_encode_set_text_encoding(kate_state *k,kate_text_encoding text_encoding)
01504 {
01505 if (!k) return KATE_E_INVALID_PARAMETER;
01506 if (!k->kes) return KATE_E_INIT;
01507 k->kes->overrides.text_encoding=text_encoding;
01508 return 0;
01509 }
01510
01519 int kate_encode_set_text_directionality(kate_state *k,kate_text_directionality text_directionality)
01520 {
01521 if (!k) return KATE_E_INVALID_PARAMETER;
01522 if (!k->kes) return KATE_E_INIT;
01523 k->kes->overrides.text_directionality=text_directionality;
01524 return 0;
01525 }
01526
01537 int kate_encode_set_id(kate_state *k,kate_int32_t id)
01538 {
01539 if (!k) return KATE_E_INVALID_PARAMETER;
01540 if (!k->kes) return KATE_E_INIT;
01541
01542 (void)id;
01543
01544 return KATE_E_IMPL;
01545 }
01546
01555 int kate_encode_set_language(kate_state *k,const char *language)
01556 {
01557 size_t len;
01558 char *l=NULL;
01559
01560 if (!k) return KATE_E_INVALID_PARAMETER;
01561 if (!k->kes) return KATE_E_INIT;
01562
01563 if (language) {
01564 len=strlen(language);
01565 l=(char*)kate_malloc(len+1);
01566 if (!l) return KATE_E_OUT_OF_MEMORY;
01567 memcpy(l,language,len+1);
01568 }
01569
01570 if (k->kes->overrides.language) kate_free(k->kes->overrides.language);
01571 k->kes->overrides.language=l;
01572
01573 return 0;
01574 }
01575
01584 int kate_encode_set_markup_type(kate_state *k,int text_markup_type)
01585 {
01586 if (!k) return KATE_E_INVALID_PARAMETER;
01587 if (!k->kes) return KATE_E_INIT;
01588
01589 k->kes->overrides.text_markup_type=text_markup_type;
01590
01591 return 0;
01592 }
01593
01601 kate_int64_t kate_encode_get_granule(const kate_state *k)
01602 {
01603 if (!k) return KATE_E_INVALID_PARAMETER;
01604 if (!k->kes) return KATE_E_INIT;
01605
01606 return k->kes->granulepos;
01607 }
01608