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 #include <string.h>
00017 #include "kate/kate.h"
00018 #include "kate_encode_state.h"
00019
00020 static void kate_encode_state_init_helper(kate_encode_state *kes)
00021 {
00022 kes->motions=NULL;
00023 kes->destroy_motions=NULL;
00024 kes->motion_indices=NULL;
00025 kes->nmotions=0;
00026
00027 kes->bitmaps=NULL;
00028 kes->bitmap_indices=NULL;
00029 kes->nbitmaps=0;
00030
00031 kes->overrides.region_index=-1;
00032 kes->overrides.region=NULL;
00033 kes->overrides.style_index=-1;
00034 kes->overrides.style=NULL;
00035 kes->overrides.secondary_style_index=-1;
00036 kes->overrides.secondary_style=NULL;
00037
00038 kes->overrides.palette_index=-1;
00039 kes->overrides.palette=NULL;
00040 kes->overrides.bitmap_index=-1;
00041 kes->overrides.bitmap=NULL;
00042
00043 kes->overrides.language=NULL;
00044
00045 kes->overrides.font_mapping_index=-1;
00046 }
00047
00048 kate_encode_state *kate_encode_state_create(const kate_info *ki)
00049 {
00050 kate_encode_state *kes=(kate_encode_state*)kate_malloc(sizeof(kate_encode_state));
00051 if (kes) {
00052 kate_pack_writeinit(&kes->kpb);
00053
00054 kes->ki=ki;
00055
00056 kes->id=0;
00057
00058 kes->granulepos=0;
00059 kes->packetno=-1;
00060
00061 kes->furthest_granule=0;
00062
00063 kes->eos=0;
00064
00065 kes->ntimings=0;
00066 kes->timings=NULL;
00067
00068 kate_encode_state_init_helper(kes);
00069 }
00070 return kes;
00071 }
00072
00073 int kate_encode_state_clear_overrides(kate_encode_state *kes)
00074 {
00075 if (!kes) return KATE_E_INVALID_PARAMETER;
00076 if (!kes->ki) return KATE_E_INIT;
00077
00078 if (kes->motions) {
00079 kate_motion_destroy(kes->ki,kes->motions,kes->destroy_motions,kes->nmotions,0);
00080 }
00081 if (kes->destroy_motions) {
00082 kate_free(kes->destroy_motions);
00083 }
00084 if (kes->motion_indices) {
00085 kate_free(kes->motion_indices);
00086 }
00087
00088 if (kes->bitmaps) {
00089 kate_free(kes->bitmaps);
00090 }
00091 if (kes->bitmap_indices) {
00092 kate_free(kes->bitmap_indices);
00093 }
00094
00095 if (kes->overrides.language) {
00096 kate_free(kes->overrides.language);
00097 }
00098
00099 kes->overrides.text_encoding=kes->ki->text_encoding;
00100 kes->overrides.text_directionality=kes->ki->text_directionality;
00101 kes->overrides.text_markup_type=kes->ki->text_markup_type;
00102
00103 kate_encode_state_init_helper(kes);
00104
00105 return 0;
00106 }
00107
00108 static int kate_encode_state_add_motion_or_index(kate_encode_state *kes,kate_motion *km,size_t motion,int destroy)
00109 {
00110 kate_motion **motions;
00111 int *destroy_motions;
00112 size_t *motion_indices;
00113 kate_motion_semantics semantics;
00114 size_t n;
00115 int ret;
00116
00117 if (!kes) return KATE_E_INVALID_PARAMETER;
00118 if (!kes->ki) return KATE_E_INIT;
00119 if (!km && motion>=kes->ki->nmotions) return KATE_E_INVALID_PARAMETER;
00120
00121 ret=kate_check_add_overflow(kes->nmotions,1,NULL);
00122 if (ret<0) return ret;
00123
00124
00125 semantics=km?km->semantics:kes->ki->motions[motion]->semantics;
00126 for (n=0;n<kes->nmotions;++n) {
00127 const kate_motion *km2=kes->motions[n];
00128 if (!km2) km2=kes->ki->motions[kes->motion_indices[n]];
00129 if (km2->semantics==semantics) return KATE_E_LIMIT;
00130 }
00131
00132 motions=(kate_motion**)kate_checked_realloc(kes->motions,(kes->nmotions+1),sizeof(kate_motion*));
00133 if (!motions) return KATE_E_OUT_OF_MEMORY;
00134 kes->motions=motions;
00135
00136 destroy_motions=(int*)kate_checked_realloc(kes->destroy_motions,(kes->nmotions+1),sizeof(int));
00137 if (!destroy_motions) return KATE_E_OUT_OF_MEMORY;
00138 kes->destroy_motions=destroy_motions;
00139
00140 motion_indices=(size_t*)kate_checked_realloc(kes->motion_indices,(kes->nmotions+1),sizeof(size_t));
00141 if (!motion_indices) return KATE_E_OUT_OF_MEMORY;
00142 kes->motion_indices=motion_indices;
00143
00144 kes->motions[kes->nmotions]=km;
00145 kes->destroy_motions[kes->nmotions]=destroy;
00146 kes->motion_indices[kes->nmotions]=motion;
00147 ++kes->nmotions;
00148
00149 return 0;
00150 }
00151
00152 int kate_encode_state_add_motion(kate_encode_state *kes,kate_motion *km,int destroy)
00153 {
00154 if (!kes || !km) return KATE_E_INVALID_PARAMETER;
00155 return kate_encode_state_add_motion_or_index(kes,km,0,destroy);
00156 }
00157
00158 int kate_encode_state_add_motion_index(kate_encode_state *kes,size_t motion)
00159 {
00160 if (!kes) return KATE_E_INVALID_PARAMETER;
00161 return kate_encode_state_add_motion_or_index(kes,NULL,motion,0);
00162 }
00163
00164 static int kate_encode_state_add_bitmap_or_index(kate_encode_state *kes,const kate_bitmap *kb,size_t bitmap)
00165 {
00166 const kate_bitmap **bitmaps;
00167 size_t *bitmap_indices;
00168 int ret;
00169
00170 if (!kes) return KATE_E_INVALID_PARAMETER;
00171 if (!kes->ki) return KATE_E_INIT;
00172 if (!kb && bitmap>=kes->ki->nbitmaps) return KATE_E_INVALID_PARAMETER;
00173
00174 ret=kate_check_add_overflow(kes->nbitmaps,1,NULL);
00175 if (ret<0) return ret;
00176
00177 bitmaps=(const kate_bitmap**)kate_checked_realloc(kes->bitmaps,(kes->nbitmaps+1),sizeof(const kate_bitmap*));
00178 if (!bitmaps) return KATE_E_OUT_OF_MEMORY;
00179 kes->bitmaps=bitmaps;
00180
00181 bitmap_indices=(size_t*)kate_checked_realloc(kes->bitmap_indices,(kes->nbitmaps+1),sizeof(size_t));
00182 if (!bitmap_indices) return KATE_E_OUT_OF_MEMORY;
00183 kes->bitmap_indices=bitmap_indices;
00184
00185 kes->bitmaps[kes->nbitmaps]=kb;
00186 kes->bitmap_indices[kes->nbitmaps]=bitmap;
00187 ++kes->nbitmaps;
00188
00189 return 0;
00190 }
00191
00192 int kate_encode_state_add_bitmap(kate_encode_state *kes,const kate_bitmap *kb)
00193 {
00194 if (!kes || !kb) return KATE_E_INVALID_PARAMETER;
00195 return kate_encode_state_add_bitmap_or_index(kes,kb,0);
00196 }
00197
00198 int kate_encode_state_add_bitmap_index(kate_encode_state *kes,size_t bitmap)
00199 {
00200 if (!kes) return KATE_E_INVALID_PARAMETER;
00201 return kate_encode_state_add_bitmap_or_index(kes,NULL,bitmap);
00202 }
00203
00204 int kate_encode_state_destroy(kate_encode_state *kes)
00205 {
00206 size_t n;
00207
00208 if (!kes) return KATE_E_INVALID_PARAMETER;
00209
00210 kate_pack_writeclear(&kes->kpb);
00211 if (kes->timings) {
00212 for (n=0;n<kes->ntimings;++n) {
00213 if (kes->timings[n].original_data) kate_free(kes->timings[n].original_data);
00214 if (kes->timings[n].repeat_data) kate_free(kes->timings[n].repeat_data);
00215 }
00216 kate_free(kes->timings);
00217 }
00218 if (kes->motions) kate_free(kes->motions);
00219 if (kes->destroy_motions) kate_free(kes->destroy_motions);
00220 if (kes->motion_indices) kate_free(kes->motion_indices);
00221 if (kes->bitmaps) kate_free(kes->bitmaps);
00222 if (kes->bitmap_indices) kate_free(kes->bitmap_indices);
00223 if (kes->overrides.language) kate_free(kes->overrides.language);
00224 kate_free(kes);
00225
00226 return 0;
00227 }
00228
00229 int kate_encode_state_add_event(kate_encode_state *kes,kate_int64_t start,kate_int64_t end)
00230 {
00231 kate_event_timing *new_timings;
00232 int ret;
00233
00234 if (!kes) return KATE_E_INVALID_PARAMETER;
00235 if (start<0 || end<0 || end<start) return KATE_E_INVALID_PARAMETER;
00236
00237 ret=kate_check_add_overflow(kes->ntimings,1,NULL);
00238 if (ret<0) return ret;
00239
00240 new_timings=(kate_event_timing*)kate_checked_realloc(kes->timings,(kes->ntimings+1),sizeof(kate_event_timing));
00241 if (!new_timings) return KATE_E_OUT_OF_MEMORY;
00242 kes->timings=new_timings;
00243
00244 kes->timings[kes->ntimings].start=start;
00245 kes->timings[kes->ntimings].end=end;
00246 kes->timings[kes->ntimings].id=kes->id;
00247 kes->timings[kes->ntimings].repeat=start;
00248 kes->timings[kes->ntimings].original_size=0;
00249 kes->timings[kes->ntimings].original_data=NULL;
00250 kes->timings[kes->ntimings].repeat_size=0;
00251 kes->timings[kes->ntimings].repeat_data=NULL;
00252 ++kes->ntimings;
00253
00254 return 0;
00255 }
00256
00257 int kate_encode_state_get_earliest_event(kate_encode_state *kes,kate_int64_t *start,kate_int64_t *end)
00258 {
00259 size_t n;
00260
00261 if (!kes || !start) return KATE_E_INVALID_PARAMETER;
00262 if (!kes->ntimings) return KATE_E_NOT_FOUND;
00263
00264 for (n=0;n<kes->ntimings;++n) {
00265
00266 if (n==0 || kes->timings[n].repeat<*start) {
00267 *start=kes->timings[n].repeat;
00268 if (end) *end=kes->timings[n].end;
00269 }
00270 }
00271
00272 return 0;
00273 }
00274
00275 int kate_encode_state_get_latest_event(kate_encode_state *kes,kate_int64_t *start,kate_int64_t *end)
00276 {
00277 size_t n;
00278
00279 if (!kes || !end) return KATE_E_INVALID_PARAMETER;
00280 if (!kes->ntimings) return KATE_E_NOT_FOUND;
00281
00282 for (n=0;n<kes->ntimings;++n) {
00283 if (n==0 || kes->timings[n].end>*end) {
00284 if (start) *start=kes->timings[n].start;
00285 *end=kes->timings[n].end;
00286 }
00287 }
00288
00289 return 0;
00290 }
00291
00292 int kate_encode_state_trim_events(kate_encode_state *kes,kate_int64_t t)
00293 {
00294 size_t n;
00295
00296 if (!kes) return KATE_E_INVALID_PARAMETER;
00297
00298 for (n=0;n<kes->ntimings;++n) {
00299 if (kes->timings[n].end<=t) {
00300 if (kes->timings[n].original_data) kate_free(kes->timings[n].original_data);
00301 if (kes->timings[n].repeat_data) kate_free(kes->timings[n].repeat_data);
00302 kes->timings[n--]=kes->timings[--kes->ntimings];
00303 }
00304 }
00305
00306 return 0;
00307 }
00308
00309 int kate_encode_state_save_event_buffer(kate_encode_state *kes,size_t size,const void *data)
00310 {
00311 kate_event_timing *ket;
00312
00313 if (!kes) return KATE_E_INVALID_PARAMETER;
00314 if (!data || size==0) return KATE_E_INVALID_PARAMETER;
00315 if (kes->ntimings==0) return KATE_E_INIT;
00316
00317
00318 ket=&kes->timings[kes->ntimings-1];
00319
00320
00321 if (ket->original_data || ket->original_size) return KATE_E_INIT;
00322 if (ket->repeat_data || ket->repeat_size) return KATE_E_INIT;
00323
00324
00325 ++kes->id;
00326 if (kes->id<0) return KATE_E_LIMIT;
00327
00328
00329 ket->original_data=kate_malloc(size);
00330 if (!ket->original_data) return KATE_E_OUT_OF_MEMORY;
00331 memcpy(ket->original_data,data,size);
00332 ket->original_size=size;
00333
00334 return 0;
00335 }
00336
00337 int kate_encode_state_get_repeat(kate_encode_state *kes,kate_int64_t t,kate_int64_t threshold,kate_packet *kp)
00338 {
00339 size_t n;
00340 kate_event_timing *ket;
00341 unsigned char packet_type;
00342
00343 if (!kes) return KATE_E_INVALID_PARAMETER;
00344
00345 for (n=0;n<kes->ntimings;++n) {
00346 ket=kes->timings+n;
00347
00348 if (threshold==0) {
00349 if (ket->repeat>=t-threshold) continue;
00350 }
00351 else {
00352 if (ket->repeat>t-threshold) continue;
00353 }
00354
00355 if (!ket->original_data) continue;
00356
00357 if (ket->original_size<1+8*3) continue;
00358 packet_type=((const unsigned char*)ket->original_data)[0];
00359 if (packet_type!=0x00) continue;
00360
00361
00362 ket->repeat = t;
00363
00364
00365 if (!ket->repeat_data) {
00366
00367 ket->repeat_data=kate_malloc(ket->original_size);
00368 if (!ket->repeat_data) return KATE_E_OUT_OF_MEMORY;
00369 memcpy(ket->repeat_data,ket->original_data,ket->original_size);
00370 ket->repeat_size=ket->original_size;
00371
00372 ((unsigned char*)ket->repeat_data)[0]=0x02;
00373 }
00374
00375 kate_packet_init(kp,ket->repeat_size,ket->repeat_data);
00376
00377 return 1;
00378 }
00379
00380 return 0;
00381 }
00382