/home/v/Kate/WORK_TREES/kate-sorceress-backup/v/src/kate/src/kate_encode.c

/* Copyright (C) 2008 Vincent Penquerc'h.
   This file is part of the Kate codec library.
   Written by Vincent Penquerc'h.

   Use, distribution and reproduction of this library is governed
   by a BSD style source license included with this source in the
   file 'COPYING'. Please read these terms before distributing. */


#define KATE_INTERNAL
#include "kate_internal.h"

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include "kate/kate.h"
#include "kate_encode_state.h"
#include "kate_fp.h"
#include "kate_rle.h"

#define NUM_HEADERS 9

int kate_encode_init(kate_state *k,kate_info *ki)
{
  if (!k || !ki) return KATE_E_INVALID_PARAMETER;

  k->ki=ki;
  k->kds=NULL;
  k->ki->num_headers=NUM_HEADERS;
  k->kes=kate_encode_state_create(ki);
  if (!k->kes) return KATE_E_OUT_OF_MEMORY;

  return 0;
}

static inline void kate_pack_write1(kate_pack_buffer *kpb,long value)
{
  kate_pack_write(kpb,value,1);
}

static void kate_writebuf(kate_pack_buffer *kpb,const char *s,int len)
{
  while (len--) kate_pack_write(kpb,*s++,8);
}

static void kate_write32(kate_pack_buffer *kpb,kate_int32_t v)
{
  kate_pack_write(kpb,v&0xff,8);
  v>>=8;
  kate_pack_write(kpb,v&0xff,8);
  v>>=8;
  kate_pack_write(kpb,v&0xff,8);
  v>>=8;
  kate_pack_write(kpb,v&0xff,8);
}

static void kate_write32v(kate_pack_buffer *kpb,kate_int32_t v)
{
  if (v>=0 && v<=14) {
    kate_pack_write(kpb,v,4);
  }
  else {
    int bits=0;
    kate_int32_t tmp;
    kate_pack_write(kpb,15,4);
    if (v&0x80000000) {
      kate_pack_write1(kpb,1);
      v=-v;
    }
    else {
      kate_pack_write1(kpb,0);
    }
    tmp=v;
    while (tmp) {
      ++bits;
      tmp>>=1;
    }
    if (bits==0) bits=1;
    kate_pack_write(kpb,bits-1,5);
    kate_pack_write(kpb,v,bits);
  }
}

static void kate_write64(kate_pack_buffer *kpb,kate_int64_t v)
{
  kate_write32(kpb,(kate_int32_t)v);
  v>>=32;
  kate_write32(kpb,(kate_int32_t)v);
}

static void kate_open_warp(kate_pack_buffer *warp)
{
  kate_pack_writeinit(warp);
}

static void kate_close_warp(kate_pack_buffer *warp,kate_pack_buffer *kpb)
{
  int bits=kate_pack_bits(warp);
  unsigned char *buffer=kate_pack_get_buffer(warp);
  kate_write32v(kpb,bits);
  while (bits>0) {
    kate_pack_writecopy(kpb,buffer,bits>32?32:bits);
    buffer+=32/8;
    bits-=32;
  }
  kate_pack_writeclear(warp);
}

static void kate_warp(kate_pack_buffer *kpb)
{
  kate_pack_buffer warp;
  kate_open_warp(&warp);
  kate_close_warp(&warp,kpb);
}

static int kate_finalize_packet_buffer(kate_pack_buffer *kpb,kate_packet *kp,kate_state *k)
{
  if (!kpb || !kp || !k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  /* fill up any remaining bits in the last byte with zeros */
  kate_pack_writealign(kpb);

  kp->nbytes=kate_pack_bytes(kpb);
  kp->data=kate_malloc(kp->nbytes);
  if (!kp->data) return KATE_E_OUT_OF_MEMORY;

  memcpy(kp->data,kate_pack_get_buffer(kpb),kp->nbytes);

  /* reset the buffer so we're ready for next packet */
  kate_pack_writeclear(kpb);
  kate_pack_writeinit(kpb);

  ++k->kes->packetno;

  /* clear any overrides */
  return kate_encode_state_clear_overrides(k->kes);
}

static int kate_encode_start_header(kate_pack_buffer *kpb,int headerid)
{
  if (!kpb || !(headerid&0x80)) return KATE_E_INVALID_PARAMETER;

  kate_pack_write(kpb,headerid,8);
  kate_writebuf(kpb,"kate\0\0\0",7);
  kate_pack_write(kpb,0,8); /* reserved - 0 */

  return 0;
}

static int kate_encode_write_canvas_size(kate_pack_buffer *kpb,size_t size)
{
  size_t base=size;
  size_t shift=0;

  if (!kpb) return KATE_E_INVALID_PARAMETER;

  while (base&~((1<<12)-1)) {
    /* we have a high bit we can't fit, increase shift if we wouldn't lose low bits */
    if ((size>>shift)&1) return KATE_E_LIMIT;
    ++shift;
    base>>=1;
  }
  if (shift>=16) return KATE_E_LIMIT;

  /* the size can be represented in our encoding */
  kate_pack_write(kpb,shift,4);
  kate_pack_write(kpb,base&0x0f,4);
  kate_pack_write(kpb,base>>4,8);

  return 0;
}

static int kate_encode_info(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t len;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x80);
  if (ret<0) return ret;

  ki=k->ki;
  kate_pack_write(kpb,KATE_BITSTREAM_VERSION_MAJOR,8);
  kate_pack_write(kpb,KATE_BITSTREAM_VERSION_MINOR,8);
  kate_pack_write(kpb,ki->num_headers,8);
  kate_pack_write(kpb,ki->text_encoding,8);
  kate_pack_write(kpb,ki->text_directionality,8);
  kate_pack_write(kpb,0,8); /* reserved - 0 */
  kate_pack_write(kpb,kate_granule_shift(k->ki),8);
  ret=kate_encode_write_canvas_size(kpb,ki->original_canvas_width);
  if (ret<0) return ret;
  ret=kate_encode_write_canvas_size(kpb,ki->original_canvas_height);
  if (ret<0) return ret;
  kate_write32(kpb,0); /* reserved - 0 */
  kate_write32(kpb,ki->gps_numerator);
  kate_write32(kpb,ki->gps_denominator);

  /* language is a 15+1 character max null terminated string */
  if (ki->language) {
    len=strlen(ki->language);
    if (len>15) return KATE_E_LIMIT;
    kate_writebuf(kpb,ki->language,len);
  }
  else len=0;
  while (len++<16) kate_pack_write(kpb,0,8);

  /* category is a 15+1 character max null terminated string */
  if (ki->category) {
    len=strlen(ki->category);
    if (len>15) return KATE_E_LIMIT;
    kate_writebuf(kpb,ki->category,len);
  }
  else len=0;
  while (len++<16) kate_pack_write(kpb,0,8);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_comment(kate_state *k,kate_comment *kc,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  const char *vendor;
  int vendor_len;
  int ret;

  if (!k || !kc || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x81);
  if (ret<0) return ret;

  vendor=kate_get_version_string();
  if (!vendor) return KATE_E_INIT; /* wtf ??? */
  vendor_len=strlen(vendor);

  /* mostly copied from theora encoder_toplevel.c */
  kate_write32(kpb,vendor_len);
  kate_writebuf(kpb,vendor,vendor_len);

  if (kc->comments<0) return KATE_E_INIT;
  kate_write32(kpb,kc->comments);
  if (kc->comments) {
    int i;
    for(i=0;i<kc->comments;++i) {
      if (kc->user_comments[i]) {
        if (kc->comment_lengths[i]<0) return KATE_E_INIT;
        kate_write32(kpb,kc->comment_lengths[i]);
        ret=kate_text_validate(kate_utf8,kc->user_comments[i],kc->comment_lengths[i]);
        if (ret<0) return ret;
        kate_writebuf(kpb,kc->user_comments[i],kc->comment_lengths[i]);
      }
      else {
        kate_write32(kpb,0);
      }
    }
  }

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_region(const kate_region *kr,kate_pack_buffer *kpb)
{
  if (!kr || !kpb) return KATE_E_INVALID_PARAMETER;

  kate_pack_write(kpb,kr->metric,8);
  kate_write32v(kpb,kr->x);
  kate_write32v(kpb,kr->y);
  kate_write32v(kpb,kr->w);
  kate_write32v(kpb,kr->h);
  kate_write32v(kpb,kr->style);

  {
    /* bitstream 0.2: add clip */
    kate_pack_buffer warp;
    kate_open_warp(&warp);
    kate_pack_write1(&warp,kr->clip);
    kate_close_warp(&warp,kpb);
  }

  kate_warp(kpb);

  return 0;
}

static int kate_encode_regions(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x82);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->nregions);

  for(n=0;n<ki->nregions;++n) {
    ret=kate_encode_region(ki->regions[n],kpb);
    if (ret<0) return ret;
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_color(const kate_color *kc,kate_pack_buffer *kpb)
{
  if (!kc || !kpb) return KATE_E_INVALID_PARAMETER;
  kate_pack_write(kpb,kc->r,8);
  kate_pack_write(kpb,kc->g,8);
  kate_pack_write(kpb,kc->b,8);
  kate_pack_write(kpb,kc->a,8);
  return 0;
}

static int kate_encode_style(const kate_style *ks,kate_pack_buffer *kpb)
{
  kate_float d[8];
  size_t idx;

  if (!ks || !kpb) return KATE_E_INVALID_PARAMETER;

  idx=0;
  d[idx++]=ks->halign;
  d[idx++]=ks->valign;
  d[idx++]=ks->font_width;
  d[idx++]=ks->font_height;
  d[idx++]=ks->left_margin;
  d[idx++]=ks->top_margin;
  d[idx++]=ks->right_margin;
  d[idx++]=ks->bottom_margin;
  kate_fp_encode_kate_float(sizeof(d)/sizeof(d[0]),d,1,kpb);
  kate_encode_color(&ks->text_color,kpb);
  kate_encode_color(&ks->background_color,kpb);
  kate_encode_color(&ks->draw_color,kpb);
  kate_pack_write(kpb,ks->font_metric,8);
  kate_pack_write(kpb,ks->margin_metric,8);
  kate_pack_write1(kpb,ks->bold);
  kate_pack_write1(kpb,ks->italics);
  kate_pack_write1(kpb,ks->underline);
  kate_pack_write1(kpb,ks->strike);

  {
    /* bitstream 0.2: add justify and font */
    kate_pack_buffer warp;
    kate_open_warp(&warp);
    kate_pack_write1(&warp,ks->justify);
    if (ks->font) {
      size_t len=strlen(ks->font);
      kate_write32v(&warp,len);
      kate_writebuf(&warp,ks->font,len);
    }
    else {
      kate_write32v(&warp,0);
    }
    kate_close_warp(&warp,kpb);
  }

  {
    /* bitstream 0.4: add nowrap */
    kate_pack_buffer warp;
    kate_open_warp(&warp);
    kate_write32v(&warp,ks->wrap_mode);
    kate_close_warp(&warp,kpb);
  }

  kate_warp(kpb);

  return 0;
}

static int kate_encode_styles(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x83);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->nstyles);

  for(n=0;n<ki->nstyles;++n) {
    ret=kate_encode_style(ki->styles[n],kpb);
    if (ret<0) return ret;
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_curve(const kate_curve *kc,kate_pack_buffer *kpb)
{
  if (!kc || !kpb) return KATE_E_INVALID_PARAMETER;

  kate_pack_write(kpb,kc->type,8);
  kate_write32v(kpb,kc->npts);
  kate_warp(kpb);
  if (kc->npts) kate_fp_encode_kate_float(kc->npts,kc->pts,2,kpb);

  return 0;
}

static int kate_encode_curves(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x84);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->ncurves);

  for(n=0;n<ki->ncurves;++n) {
    ret=kate_encode_curve(ki->curves[n],kpb);
    if (ret<0) return ret;
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_motion(const kate_info *ki,const kate_motion *km,kate_pack_buffer *kpb)
{
  size_t n;
  int ret;

  if (!ki || !km || !kpb) return KATE_E_INVALID_PARAMETER;

  kate_write32v(kpb,km->ncurves);
  for (n=0;n<km->ncurves;++n) {
    int idx=kate_find_curve(ki,km->curves[n]);
    if (idx<0) {
      kate_pack_write1(kpb,0);
      ret=kate_encode_curve(km->curves[n],kpb);
      if (ret<0) return ret;
    }
    else {
      kate_pack_write1(kpb,1);
      kate_write32v(kpb,idx);
    }
  }
  kate_fp_encode_kate_float(km->ncurves,km->durations,1,kpb);
  kate_pack_write(kpb,km->x_mapping,8);
  kate_pack_write(kpb,km->y_mapping,8);
  kate_pack_write(kpb,km->semantics,8);
  kate_pack_write1(kpb,km->periodic);
  kate_warp(kpb);

  return 0;
}

static int kate_encode_motions(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x85);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->nmotions);

  for(n=0;n<ki->nmotions;++n) {
    ret=kate_encode_motion(ki,ki->motions[n],kpb);
    if (ret<0) return ret;
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_palette(const kate_palette *kp,kate_pack_buffer *kpb)
{
  size_t n;

  if (!kp || !kpb) return KATE_E_INVALID_PARAMETER;
  if (kp->ncolors<=0 || kp->ncolors>256) return KATE_E_LIMIT;

  kate_pack_write(kpb,kp->ncolors-1,8);
  for (n=0;n<kp->ncolors;++n) {
    int ret=kate_encode_color(kp->colors+n,kpb);
    if (ret<0) return ret;
  }
  kate_warp(kpb);

  return 0;
}

static int kate_encode_palettes(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x86);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->npalettes);

  for(n=0;n<ki->npalettes;++n) {
    ret=kate_encode_palette(ki->palettes[n],kpb);
    if (ret<0) return ret;
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

#if 0
static int kate_encode_paletted_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
{
  size_t w,h,n;
  unsigned int maxpixel;

  if (kb->bpp>8) return KATE_E_LIMIT;

  kate_write32v(kpb,kb->palette);
  n=0;
  maxpixel=(1<<kb->bpp)-1;
  for (h=0;h<kb->height;++h) {
    for (w=0;w<kb->width;++w) {
      unsigned int pixel=kb->pixels[n++];
      if (pixel>maxpixel) return KATE_E_LIMIT;
      kate_pack_write(kpb,pixel,kb->bpp);
    }
  }

  return 0;
}
#endif

static int kate_encode_rle_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
{
  if (kb->bpp>8) return KATE_E_LIMIT;

  kate_pack_write(kpb,kate_bitmap_type_paletted,8);
  kate_pack_write(kpb,1,8); /* RLE encoding */
  kate_write32v(kpb,kb->bpp);
  kate_write32v(kpb,kb->palette);

  return kate_rle_encode(kb->width,kb->height,kb->pixels,kb->bpp,kpb);
}

static int kate_encode_png_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
{
  kate_pack_write(kpb,kate_bitmap_type_png,8);
  kate_write32(kpb,kb->size);
  kate_writebuf(kpb,(const char*)kb->pixels,kb->size);

  return 0;
}

static int kate_encode_bitmap(const kate_bitmap *kb,kate_pack_buffer *kpb)
{
  int ret;

  if (!kb || !kpb) return KATE_E_INVALID_PARAMETER;

  kate_write32v(kpb,kb->width);
  kate_write32v(kpb,kb->height);
#if 0
  /* paletted bitmaps are now written compressed */
  kate_pack_write(kpb,kb->bpp,8); /* 0 marks a raw bitmap */
#else
  kate_pack_write(kpb,0,8); /* 0 marks a raw bitmap */
#endif

  switch (kb->type) {
    case kate_bitmap_type_paletted:
      ret=kate_encode_rle_bitmap(kb,kpb);
      break;
    case kate_bitmap_type_png:
      ret=kate_encode_png_bitmap(kb,kpb);
      break;
    default:
      ret=KATE_E_INVALID_PARAMETER;
      break;
  }

  if (ret<0) return ret;

  {
    /* bitstream 0.4: x/y offsets */
    kate_pack_buffer warp;
    kate_open_warp(&warp);
    kate_write32v(&warp,kb->x_offset);
    kate_write32v(&warp,kb->y_offset);
    kate_close_warp(&warp,kpb);
  }

  kate_warp(kpb);

  return 0;
}

static int kate_encode_bitmaps(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x87);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->nbitmaps);

  for(n=0;n<ki->nbitmaps;++n) {
    ret=kate_encode_bitmap(ki->bitmaps[n],kpb);
    if (ret<0) return ret;
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static int kate_encode_font_range(const kate_info *ki,const kate_font_range *kfr,kate_pack_buffer *kpb)
{
  if (!ki || !kfr || !kpb) return KATE_E_INVALID_PARAMETER;

  if (!kate_is_valid_code_point(kfr->first_code_point)) return KATE_E_TEXT;
  if (!kate_is_valid_code_point(kfr->last_code_point)) return KATE_E_TEXT;
  if (kfr->first_bitmap<0) return KATE_E_LIMIT;
  if ((size_t)(kfr->first_bitmap+(kfr->last_code_point-kfr->first_code_point))>=ki->nbitmaps) return KATE_E_LIMIT;

  kate_write32v(kpb,kfr->first_code_point);
  kate_write32v(kpb,kfr->last_code_point);
  kate_write32v(kpb,kfr->first_bitmap);
  kate_warp(kpb);

  return 0;
}

static int kate_encode_font_ranges(kate_state *k,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_info *ki;
  size_t n,l;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  kpb=&k->kes->kpb;

  ret=kate_encode_start_header(kpb,0x88);
  if (ret<0) return ret;

  ki=k->ki;
  if (!ki) return KATE_E_INIT;

  kate_write32v(kpb,ki->nfont_ranges);
  for(n=0;n<ki->nfont_ranges;++n) {
    ret=kate_encode_font_range(ki,ki->font_ranges[n],kpb);
    if (ret<0) return ret;
  }

  kate_write32v(kpb,ki->nfont_mappings);
  for(n=0;n<ki->nfont_mappings;++n) {
    const kate_font_mapping *kfm=ki->font_mappings[n];
    kate_write32v(kpb,kfm->nranges);
    for (l=0;l<kfm->nranges;++l) {
      const kate_font_range *kfr=kfm->ranges[l];
      int idx=kate_find_font_range(ki,kfr);
      if (idx>=0) {
        kate_pack_write1(kpb,1);
        kate_write32v(kpb,idx);
      }
      else {
        kate_pack_write1(kpb,0);
        ret=kate_encode_font_range(ki,kfr,kpb);
        if (ret<0) return ret;
      }
    }
  }

  kate_warp(kpb);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

static inline int kate_check_granule(kate_state *k,kate_int64_t *granulepos)
{
  if (*granulepos<k->kes->granulepos) return -1;
  return 0;
}

#define WRITE_OVERRIDE(kpb,var,def,write) \
  do \
    if (ret==0 && (kes->overrides.var!=(def))) { \
      kate_pack_write1(kpb,1); \
      write; \
    } \
    else kate_pack_write1(kpb,0); \
  while(0)

static int kate_encode_overrides(kate_state *k,kate_pack_buffer *kpb)
{
  kate_encode_state *kes;
  size_t n;
  int ret=0;

  if (!k || !kpb) return KATE_E_INVALID_PARAMETER;
  kes=k->kes;
  if (!kes) return KATE_E_INIT;

  if (kes->overrides.language
   || kes->overrides.text_encoding!=k->ki->text_encoding
   || kes->overrides.text_directionality!=k->ki->text_directionality
   || kes->overrides.region_index>=0
   || kes->overrides.region
   || kes->overrides.style_index>=0
   || kes->overrides.style
   || kes->overrides.secondary_style_index>=0
   || kes->overrides.secondary_style
   || kes->overrides.font_mapping_index>=0
  ) {
    kate_pack_write1(kpb,1);
    WRITE_OVERRIDE(kpb,text_encoding,k->ki->text_encoding,kate_pack_write(kpb,kes->overrides.text_encoding,8));
    WRITE_OVERRIDE(kpb,text_directionality,k->ki->text_directionality,kate_pack_write(kpb,kes->overrides.text_directionality,8));
    WRITE_OVERRIDE(kpb,language,NULL,
      do {
        size_t len=strlen(kes->overrides.language);
        kate_write32v(kpb,len);
        kate_writebuf(kpb,kes->overrides.language,len);
      } while(0));
    WRITE_OVERRIDE(kpb,region_index,-1,kate_write32v(kpb,kes->overrides.region_index));
    WRITE_OVERRIDE(kpb,region,NULL,ret=kate_encode_region(kes->overrides.region,kpb));
    WRITE_OVERRIDE(kpb,style_index,-1,kate_write32v(kpb,kes->overrides.style_index));
    WRITE_OVERRIDE(kpb,style,NULL,ret=kate_encode_style(kes->overrides.style,kpb));
    WRITE_OVERRIDE(kpb,secondary_style_index,-1,kate_write32v(kpb,kes->overrides.secondary_style_index));
    WRITE_OVERRIDE(kpb,secondary_style,NULL,ret=kate_encode_style(kes->overrides.secondary_style,kpb));
    WRITE_OVERRIDE(kpb,font_mapping_index,-1,kate_write32v(kpb,kes->overrides.font_mapping_index));
  }
  else kate_pack_write1(kpb,0);

  if (ret==0) {
    /* bitstream 0.2: add palette, bitmap, markup type */
    kate_pack_buffer warp;
    kate_open_warp(&warp);
    if (kes->overrides.palette_index>=0
     || kes->overrides.palette
     || kes->overrides.bitmap_index>=0
     || kes->overrides.bitmap
     || kes->overrides.text_markup_type!=k->ki->text_markup_type) {
      kate_pack_write1(&warp,1);
      WRITE_OVERRIDE(&warp,palette_index,-1,kate_write32v(&warp,kes->overrides.palette_index));
      WRITE_OVERRIDE(&warp,palette,NULL,ret=kate_encode_palette(kes->overrides.palette,&warp));
      WRITE_OVERRIDE(&warp,bitmap_index,-1,kate_write32v(&warp,kes->overrides.bitmap_index));
      WRITE_OVERRIDE(&warp,bitmap,NULL,ret=kate_encode_bitmap(kes->overrides.bitmap,&warp));
      WRITE_OVERRIDE(&warp,text_markup_type,k->ki->text_markup_type,kate_pack_write(&warp,kes->overrides.text_markup_type,8));
    }
    else kate_pack_write1(&warp,0);
    kate_close_warp(&warp,kpb);
  }

  if (ret==0) {
    /* bitstream 0.4: add bitmaps */
    kate_pack_buffer warp;
    kate_open_warp(&warp);
    kate_write32v(&warp,kes->nbitmaps);
    for(n=0;n<kes->nbitmaps;++n) {
      if (kes->bitmaps[n]==NULL) {
        /* we have an index into the bitmaps header */
        kate_pack_write1(&warp,1);
        kate_write32v(&warp,kes->bitmap_indices[n]);
      }
      else {
        /* we have a fully defined bitmap */
        kate_pack_write1(&warp,0);
        ret=kate_encode_bitmap(kes->bitmaps[n],&warp);
        if (ret<0) break;
      }
    }
    kate_close_warp(&warp,kpb);
  }

  kate_warp(kpb);

  return ret;
}

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)
{
  kate_pack_buffer *kpb;
  kate_int64_t start_granulepos;
  kate_int64_t start;
  kate_int64_t duration;
  kate_int64_t backlink;
  kate_int64_t earliest_t;
  int ret;
  size_t n;

  if (!k || !text || !kp) return KATE_E_INVALID_PARAMETER;
  if (t0<0 || t1<t0) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (k->kes->eos) return KATE_E_INIT;

  ret=kate_text_validate(k->kes->overrides.text_encoding,text,sz);
  if (ret<0) return ret;

  ret=kate_encode_state_trim_events(k->kes,t0);
  if (ret<0) return ret;
  ret=kate_encode_state_add_event(k->kes,t0,t1);
  if (ret<0) return ret;
  ret=kate_encode_state_get_earliest_event(k->kes,&earliest_t,NULL);
  if (ret<0) return ret;

  start_granulepos=(earliest_t<<k->ki->granule_shift)|(t0-earliest_t);
  if (start_granulepos<0) return KATE_E_BAD_GRANULE;
  if (kate_check_granule(k,&start_granulepos)<0) return KATE_E_BAD_GRANULE;

  start=t0;
  if (start<0) return KATE_E_BAD_GRANULE;
  duration=t1-t0;
  if (duration<0) return KATE_E_BAD_GRANULE;
  backlink=t0-earliest_t;
  if (backlink<0) return KATE_E_BAD_GRANULE;

  kpb=&k->kes->kpb;
  kate_pack_write(kpb,0x00,8);

  kate_write64(kpb,start);
  kate_write64(kpb,duration);
  kate_write64(kpb,backlink);

  kate_write32(kpb,sz);
  kate_writebuf(kpb,text,sz);

  if (k->kes->id>=0) {
    kate_pack_write1(kpb,1);
    kate_write32v(kpb,k->kes->id);
  }
  else {
    kate_pack_write1(kpb,0);
  }

  if (k->kes->nmotions) {
    kate_pack_write1(kpb,1);
    kate_write32v(kpb,k->kes->nmotions);
    for (n=0;n<k->kes->nmotions;++n) {
      if (k->kes->motions[n]==NULL) {
        /* we have an index into the motions header */
        kate_pack_write1(kpb,1);
        kate_write32v(kpb,k->kes->motion_indices[n]);
      }
      else {
        /* we have a fully defined motion */
        kate_pack_write1(kpb,0);
        ret=kate_encode_motion(k->ki,k->kes->motions[n],kpb);
        if (ret<0) return ret;
      }
    }
  }
  else kate_pack_write1(kpb,0);

  kate_encode_overrides(k,kpb);

  if (start_granulepos>k->kes->furthest_granule) k->kes->furthest_granule=start_granulepos;

  k->kes->granulepos=start_granulepos;
  ret=kate_finalize_packet_buffer(kpb,kp,k);
  if (ret<0) return ret;

  /* save the packet in case we have to repeat it */
  ret=kate_encode_state_save_event_buffer(k->kes,kp->nbytes,kp->data);
  if (ret<0) return ret;

  return 0;
}

int kate_encode_text(kate_state *k,kate_float t0,kate_float t1,const char *text,size_t sz,kate_packet *kp)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  return kate_encode_text_raw_times(k,kate_duration_granule(k->ki,t0),kate_duration_granule(k->ki,t1),text,sz,kp);
}

int kate_encode_keepalive_raw_times(kate_state *k,kate_int64_t t,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_int64_t granulepos;
  kate_int64_t earliest_t;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (k->kes->eos) return KATE_E_INIT;

  ret=kate_encode_state_trim_events(k->kes,t);
  if (ret<0) return ret;

  ret=kate_encode_state_get_earliest_event(k->kes,&earliest_t,NULL);
  if (ret==KATE_E_NOT_FOUND) {
    /* if there are no live events yet, base from now */
    earliest_t=t;
    ret=0;
  }
  if (ret<0) return ret;

  granulepos=(earliest_t<<k->ki->granule_shift)|(t-earliest_t);
  if (granulepos<0) return KATE_E_BAD_GRANULE;

  if (kate_check_granule(k,&granulepos)<0) return KATE_E_BAD_GRANULE;
  k->kes->granulepos=granulepos;

  ret=kate_encode_state_add_event(k->kes,t,t);
  if (ret<0) return ret;

  kpb=&k->kes->kpb;
  kate_pack_write(kpb,0x01,8);

  return kate_finalize_packet_buffer(kpb,kp,k);
}

int kate_encode_keepalive(kate_state *k,kate_float t,kate_packet *kp)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  return kate_encode_keepalive_raw_times(k,kate_duration_granule(k->ki,t),kp);
}

int kate_encode_repeat_raw_times(kate_state *k,kate_int64_t t,kate_int64_t threshold,kate_packet *kp)
{
  kate_int64_t earliest_t;
  kate_int64_t granulepos;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (threshold<0) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (k->kes->eos) return KATE_E_INIT;

  ret=kate_encode_state_trim_events(k->kes,t);
  if (ret<0) return ret;
  ret=kate_encode_state_get_earliest_event(k->kes,&earliest_t,NULL);
  if (ret==KATE_E_NOT_FOUND) {
    /* if there are no live events yet, base from now */
    earliest_t=t;
  }
  else if (ret<0) {
    return ret;
  }
  granulepos=(earliest_t<<k->ki->granule_shift)|(t-earliest_t);
  if (granulepos<0) return KATE_E_BAD_GRANULE;

  if (kate_check_granule(k,&granulepos)<0) return KATE_E_BAD_GRANULE;

  ret=kate_encode_state_get_repeat(k->kes,t,threshold,kp);
  if (ret>0) {
    /* if we encoded a repeat, update encoding state granpos */
    k->kes->granulepos=granulepos;
  }
  return ret;
}

int kate_encode_repeat(kate_state *k,kate_float t,kate_float threshold,kate_packet *kp)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  return kate_encode_repeat_raw_times(k,kate_duration_granule(k->ki,t),kate_duration_granule(k->ki,threshold),kp);
}

int kate_encode_finish_raw_times(kate_state *k,kate_int64_t t,kate_packet *kp)
{
  kate_pack_buffer *kpb;
  kate_int64_t granulepos;
  int ret;

  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (k->kes->eos) return KATE_E_INIT;

  ret=kate_encode_state_trim_events(k->kes,t);
  if (ret<0) return ret;

  if (t<0) {
    ret=kate_encode_state_get_latest_event(k->kes,NULL,&t);
    if (ret==KATE_E_NOT_FOUND) {
      /* if nothing was encoded, it is still a valid stream */
      t=0;
      ret=0;
    }
    if (ret<0) return ret;
  }

  granulepos=t<<k->ki->granule_shift;
  if (granulepos<0) return KATE_E_BAD_GRANULE;

  if (kate_check_granule(k,&granulepos)<0) return KATE_E_BAD_GRANULE;
  k->kes->granulepos=granulepos;

  kpb=&k->kes->kpb;
  kate_pack_write(kpb,0x7f,8);

  k->kes->eos=1;

  return kate_finalize_packet_buffer(kpb,kp,k);
}

int kate_encode_finish(kate_state *k,kate_float t,kate_packet *kp)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  return kate_encode_finish_raw_times(k,kate_duration_granule(k->ki,t),kp);
}

int kate_encode_headers(kate_state *k,kate_comment *kc,kate_packet *kp)
{
  if (!k || !kc || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (k->kes->eos) return KATE_E_INIT;

  switch (k->kes->packetno+1) {
    case 0: return kate_encode_info(k,kp);
    case 1: return kate_encode_comment(k,kc,kp);
    case 2: return kate_encode_regions(k,kp);
    case 3: return kate_encode_styles(k,kp);
    case 4: return kate_encode_curves(k,kp);
    case 5: return kate_encode_motions(k,kp);
    case 6: return kate_encode_palettes(k,kp);
    case 7: return kate_encode_bitmaps(k,kp);
    case 8: return kate_encode_font_ranges(k,kp);
    case 9: return 1;
    default: return KATE_E_INVALID_PARAMETER;
  }
}

int kate_encode_add_motion(kate_state *k,kate_motion *km,int destroy)
{
  if (!k || !km) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  return kate_encode_state_add_motion(k->kes,km,destroy);
}

int kate_encode_add_motion_index(kate_state *k,size_t motion)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->ki) return KATE_E_INIT;
  if (motion>=k->ki->nmotions) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  return kate_encode_state_add_motion_index(k->kes,motion);
}

int kate_encode_add_bitmap(kate_state *k,const kate_bitmap *kb)
{
  if (!k || !kb) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  return kate_encode_state_add_bitmap(k->kes,kb);
}

int kate_encode_add_bitmap_index(kate_state *k,size_t bitmap)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->ki) return KATE_E_INIT;
  if (bitmap>=k->ki->nbitmaps) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  return kate_encode_state_add_bitmap_index(k->kes,bitmap);
}

int kate_encode_set_region_index(kate_state *k,size_t region)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (region>=k->ki->nregions) return KATE_E_INVALID_PARAMETER;
  if (k->kes->overrides.region) return KATE_E_INIT;
  k->kes->overrides.region_index=region;
  return 0;
}

int kate_encode_set_region(kate_state *k,const kate_region *kr)
{
  if (!k || !kr) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (k->kes->overrides.region_index>=0) return KATE_E_INIT;
  k->kes->overrides.region=kr;
  return 0;
}

int kate_encode_set_style_index(kate_state *k,size_t style)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (style>=k->ki->nstyles) return KATE_E_INVALID_PARAMETER;
  if (k->kes->overrides.style) return KATE_E_INIT;
  k->kes->overrides.style_index=style;
  return 0;
}

int kate_encode_set_style(kate_state *k,const kate_style *ks)
{
  if (!k || !ks) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (k->kes->overrides.style_index>=0) return KATE_E_INIT;
  k->kes->overrides.style=ks;
  return 0;
}

int kate_encode_set_secondary_style_index(kate_state *k,size_t style)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (style>=k->ki->nstyles) return KATE_E_INVALID_PARAMETER;
  if (k->kes->overrides.secondary_style) return KATE_E_INIT;
  k->kes->overrides.secondary_style_index=style;
  return 0;
}

int kate_encode_set_secondary_style(kate_state *k,const kate_style *ks)
{
  if (!k || !ks) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (k->kes->overrides.secondary_style_index>=0) return KATE_E_INIT;
  k->kes->overrides.secondary_style=ks;
  return 0;
}

int kate_encode_set_palette_index(kate_state *k,size_t palette)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (palette>=k->ki->npalettes) return KATE_E_INVALID_PARAMETER;
  if (k->kes->overrides.palette) return KATE_E_INIT;
  k->kes->overrides.palette_index=palette;
  return 0;
}

int kate_encode_set_palette(kate_state *k,const kate_palette *kp)
{
  if (!k || !kp) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (k->kes->overrides.palette_index>=0) return KATE_E_INIT;
  k->kes->overrides.palette=kp;
  return 0;
}

int kate_encode_set_bitmap_index(kate_state *k,size_t bitmap)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (bitmap>=k->ki->nbitmaps) return KATE_E_INVALID_PARAMETER;
  if (k->kes->overrides.bitmap) return KATE_E_INIT;
  k->kes->overrides.bitmap_index=bitmap;
  return 0;
}

int kate_encode_set_bitmap(kate_state *k,const kate_bitmap *kb)
{
  if (!k || !kb) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (k->kes->overrides.bitmap_index>=0) return KATE_E_INIT;
  k->kes->overrides.bitmap=kb;
  return 0;
}

int kate_encode_set_font_mapping_index(kate_state *k,size_t font_mapping)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  if (!k->ki) return KATE_E_INIT;
  if (font_mapping>=k->ki->nfont_mappings) return KATE_E_INVALID_PARAMETER;
  k->kes->overrides.font_mapping_index=font_mapping;
  return 0;
}

int kate_encode_set_text_encoding(kate_state *k,kate_text_encoding text_encoding)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  k->kes->overrides.text_encoding=text_encoding;
  return 0;
}

int kate_encode_set_text_directionality(kate_state *k,kate_text_directionality text_directionality)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;
  k->kes->overrides.text_directionality=text_directionality;
  return 0;
}

int kate_encode_set_id(kate_state *k,kate_int32_t id)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  (void)id;

  return KATE_E_IMPL;
}

int kate_encode_set_language(kate_state *k,const char *language) /* language can be NULL */
{
  size_t len;
  char *l=NULL;

  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  if (language) {
    len=strlen(language);
    l=(char*)kate_malloc(len+1);
    if (!l) return KATE_E_OUT_OF_MEMORY;
    memcpy(l,language,len+1);
  }

  if (k->kes->overrides.language) kate_free(k->kes->overrides.language);
  k->kes->overrides.language=l;

  return 0;
}

int kate_encode_set_markup_type(kate_state *k,int text_markup_type)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  k->kes->overrides.text_markup_type=text_markup_type;

  return 0;
}

kate_int64_t kate_encode_get_granule(const kate_state *k)
{
  if (!k) return KATE_E_INVALID_PARAMETER;
  if (!k->kes) return KATE_E_INIT;

  return k->kes->granulepos;
}

---