j2k.c

This document is intended to serve as an introduction to Wavelet processing through a set of Matlab

void j2k_read_ppm() {
    int len;
    len=cio_read(2);
    /*     fprintf(stderr, "WARNING: PPM marker segment processing not implemented\n"); */
    cio_skip(len-2);
}

void j2k_read_ppt() {
    int len;
    len=cio_read(2);
    /*     fprintf(stderr, "WARNING: PPT marker segment processing not implemented\n"); */
    cio_skip(len-2);
}

void j2k_write_sot() {
    int lenp, len;
    /*     fprintf(stderr, "%.8x: SOT\n", cio_tell()); */
    j2k_sot_start=cio_tell();
    cio_write(J2K_MS_SOT, 2);
    lenp=cio_tell();
    cio_skip(2);
    cio_write(j2k_curtileno, 2);
    cio_skip(4);
    cio_write(0, 1);
    cio_write(1, 1);
    len=cio_tell()-lenp;
    cio_seek(lenp);
    cio_write(len, 2);
    cio_seek(lenp+len);
}

void j2k_read_sot() {
    int len, tileno, totlen, partno, numparts, i;
    j2k_tcp_t *tcp;
    j2k_tccp_t *tmp;
    /*     fprintf(stderr, "%.8x: SOT\n", cio_tell()-2); */
    len=cio_read(2);
    tileno=cio_read(2);
    totlen=cio_read(4);
    partno=cio_read(1);
    numparts=cio_read(1);
    j2k_curtileno=tileno;
    j2k_eot=cio_getbp()-12+totlen;
    j2k_state=J2K_STATE_TPH;
    tcp=&j2k_cp->tcps[j2k_curtileno];
    tmp=tcp->tccps;
    *tcp=j2k_default_tcp;
    tcp->tccps=tmp;
    for (i=0; i<j2k_img->numcomps; i++) {
        tcp->tccps[i]=j2k_default_tcp.tccps[i];
    }
}

void j2k_write_sod() {
    int l, layno;
    int totlen;
    j2k_tcp_t *tcp;
    /*     fprintf(stderr, "%.8x: SOD\n", cio_tell()); */
    cio_write(J2K_MS_SOD, 2);
    tcp=&j2k_cp->tcps[j2k_curtileno];
    for (layno=0; layno<tcp->numlayers; layno++) {
        tcp->rates[layno]-=cio_tell();
    /*         fprintf(stderr, "tcp->rates[%d]=%d\n", layno, tcp->rates[layno]); */
    }
    /*     fprintf(stderr, "cio_numbytesleft=%d\n", cio_numbytesleft()); */
    tcd_init(j2k_img, j2k_cp);
    l=tcd_encode_tile(j2k_curtileno, cio_getbp(), cio_numbytesleft()-2);
    totlen=cio_tell()+l-j2k_sot_start;
    cio_seek(j2k_sot_start+6);
    cio_write(totlen, 4);
    cio_seek(j2k_sot_start+totlen);
}

void j2k_read_sod() {
    int len;
    unsigned char *data;
    /*     fprintf(stderr, "%.8x: SOD\n", cio_tell()-2); */
    len=int_min(j2k_eot-cio_getbp(), cio_numbytesleft());
    j2k_tile_len[j2k_curtileno]+=len;
    data=(unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
    memcpy(data, cio_getbp(), len);
    j2k_tile_data[j2k_curtileno]=data;
    cio_skip(len);
    j2k_state=J2K_STATE_TPHSOT;
}

void j2k_read_rgn() {
    int len, compno, roisty;
    j2k_tcp_t *tcp;
    /*     fprintf(stderr, "%.8x: RGN\n", cio_tell()-2); */
    tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
    len=cio_read(2);
    compno=cio_read(j2k_img->numcomps<=256?1:2);
    roisty=cio_read(1);
    tcp->tccps[compno].roishift=cio_read(1);
}

void j2k_write_eoc() {
  /*     fprintf(stderr, "%.8x: EOC\n", cio_tell()); */
    cio_write(J2K_MS_EOC, 2);
}

void j2k_read_eoc() {
    int tileno;
    /*     fprintf(stderr, "%.8x: EOC\n", cio_tell()-2); */
    /*     j2k_dump_image(j2k_img); */
    /*    j2k_dump_cp(j2k_img, j2k_cp); */
    tcd_init(j2k_img, j2k_cp);
    for (tileno=0; tileno<j2k_cp->tw*j2k_cp->th; tileno++) {
        tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno);
    }
    j2k_state=J2K_STATE_MT;
    longjmp(j2k_error, 1);
}

void j2k_read_unk() {
  /*     fprintf(stderr, "warning: unknown marker\n"); */
}

LIBJ2K_API int j2k_encode(j2k_image_t *img, j2k_cp_t *cp, unsigned char *dest, int len) {
    int tileno, compno;
    if (setjmp(j2k_error)) {
        return 0;
    }
    cio_init(dest, len);
    j2k_img=img;
    j2k_cp=cp;
    /*     j2k_dump_cp(j2k_img, j2k_cp); */
    j2k_write_soc();
    j2k_write_siz();
    j2k_write_com();
    for (tileno=0; tileno<cp->tw*cp->th; tileno++) {
        j2k_curtileno=tileno;
        j2k_write_sot();
        j2k_write_cod();
        j2k_write_qcd();
        for (compno=1; compno<img->numcomps; compno++) {
            j2k_write_coc(compno);
            j2k_write_qcc(compno);
        }
        j2k_write_sod();
    }
    j2k_write_eoc();
    return cio_tell();
}

typedef struct {
    int id;
    int states;
    void (*handler)();
} j2k_dec_mstabent_t;

j2k_dec_mstabent_t j2k_dec_mstab[]={
    {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
    {J2K_MS_SOT, J2K_STATE_MH|J2K_STATE_TPHSOT, j2k_read_sot},
    {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
    {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
    {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
    {J2K_MS_COD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_cod},
    {J2K_MS_COC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_coc},
    {J2K_MS_RGN, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_rgn},
    {J2K_MS_QCD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcd},
    {J2K_MS_QCC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcc},
    {J2K_MS_POC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_poc},
    {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
    {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
    {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
    {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
    {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
    {J2K_MS_SOP, 0, 0},
    {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
    {J2K_MS_COM, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_com},
    {0, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_unk}
};

j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
    j2k_dec_mstabent_t *e;
    for (e=j2k_dec_mstab; e->id!=0; e++) {
        if (e->id==id) {
            break;
        }
    }
    return e;
}

/*  j2k_release is used to free up all working data allocated */
/*  during the j2k_decode operation. */

extern tcd_image_t tcd_image;
 
LIBJ2K_API void j2k_release(j2k_image_t *img, j2k_cp_t *cp) 
{
   int c,b,r, tileno;
   
   if (cp)
   {
      for (tileno=0; tileno<cp->tw*cp->th; tileno++)
      {
         tcd_tile_t *tile = &tcd_image.tiles[tileno];

         if (j2k_tile_data[tileno])
       {
         free(j2k_tile_data[tileno]);
         j2k_tile_data[tileno]=NULL;
       }

         if (j2k_tile_len)
       {
         free(j2k_tile_len);
         j2k_tile_len=NULL;
       }

     if (tile) 
       {
         for (c=0;c<tile->numcomps;c++)
         {
            tcd_tilecomp_t *tc = &tile->comps[c];

            if (tc->data)
               free(tc->data);

            if (tc->resolutions)
            {
               for (r=0;r<tc->numresolutions;r++)
               {
                  tcd_resolution_t *res = &tc->resolutions[r];

                  for (b=0;b<res->numbands;b++)
                  {
                     tcd_band_t *band = &res->bands[b];

                     if (band->precincts)
                     {
                         if (band->precincts->cblks)
                            free(band->precincts->cblks);

                         if (band->precincts->incltree)
                         {
                            if (band->precincts->incltree->nodes)
                              free(band->precincts->incltree->nodes);

                            free(band->precincts->incltree);
                         }

                         if (band->precincts->imsbtree)
                         {
                             if (band->precincts->imsbtree->nodes)
                                free(band->precincts->imsbtree->nodes);

                            free(band->precincts->imsbtree);
                         }

                         free(band->precincts);
                     }
                  }
               }

               free(tc->resolutions);
            }
         }

         free(tile->comps);
       }
      }

      free(tcd_image.tiles);
      tcd_image.tiles = NULL;

      if (cp->tcps)
      {
         if (cp->tcps->tccps)
            free(cp->tcps->tccps);

         free(cp->tcps);
      }
      
      free(cp);
         
      if (j2k_tile_data)
         free(j2k_tile_data);
      j2k_tile_data=NULL;
   }

   if (img)
   {
      for (c=0; c< img->numcomps; c++)
      {
         if (img->comps[c].data)
            free(img->comps[c].data);
      }

      if (img->comps)
         free (img->comps);

      free(img);
   }

   if (j2k_default_tcp.tccps)
   {
      free(j2k_default_tcp.tccps);
      j2k_default_tcp.tccps = NULL;
   }
}

LIBJ2K_API void j2k_release_encode(j2k_image_t *img, j2k_cp_t *cp) 
{
   int c,b,r, tileno;
   
   if (cp)
   {
      for (tileno=0; tileno<cp->tw*cp->th; tileno++)
      {
         tcd_tile_t *tile = &tcd_image.tiles[tileno];

     /*          if (j2k_tile_data[tileno]) */
     /*             free(j2k_tile_data[tileno]); */

     /*          if (j2k_tile_len) */
     /*             free(j2k_tile_len); */

         for (c=0;c<tile->numcomps;c++)
         {
            tcd_tilecomp_t *tc = &tile->comps[c];

            if (tc->data)
               free(tc->data);

            if (tc->resolutions)
            {
               for (r=0;r<tc->numresolutions;r++)
               {
                  tcd_resolution_t *res = &tc->resolutions[r];

                  for (b=0;b<res->numbands;b++)
                  {
                     tcd_band_t *band = &res->bands[b];

                     if (band->precincts)
                     {
                         if (band->precincts->cblks)
                            free(band->precincts->cblks);

                         if (band->precincts->incltree)
                         {
                            if (band->precincts->incltree->nodes)
                              free(band->precincts->incltree->nodes);

                            free(band->precincts->incltree);
                         }

                         if (band->precincts->imsbtree)
                         {
                             if (band->precincts->imsbtree->nodes)
                                free(band->precincts->imsbtree->nodes);

                            free(band->precincts->imsbtree);
                         }

                         free(band->precincts);
                     }
                  }
               }

               free(tc->resolutions);
            }
         }

         free(tile->comps);
      }

      free(tcd_image.tiles);
      tcd_image.tiles = NULL;

      if (cp->tcps)
      {
         if (cp->tcps->tccps)
            free(cp->tcps->tccps);

         free(cp->tcps);
      }
      
      /* free(cp); */
         
      if (j2k_tile_data)
         free(j2k_tile_data);
      j2k_tile_data=NULL;
   }

   if (img)
   {
      for (c=0; c< img->numcomps; c++)
      {
         if (img->comps[c].data)
            free(img->comps[c].data);
      }

      if (img->comps)
         free (img->comps);

      free(img);
   }

   if (j2k_default_tcp.tccps)
   {
      free(j2k_default_tcp.tccps);
      j2k_default_tcp.tccps = NULL;
   }
}



LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **img, j2k_cp_t **cp) {

   /*  Initialize globals ... */
   j2k_eot = NULL;
   j2k_img = NULL;
   j2k_cp  = NULL;
   j2k_tile_data = NULL;
   j2k_tile_len = NULL;
   j2k_default_tcp.tccps = NULL;
   
   if (setjmp(j2k_error)) {
        if (j2k_state!=J2K_STATE_MT) {
            fprintf(stderr, "WARNING: incomplete bitstream\n");
            return 0;
        }
        return cio_numbytes();
    }
    j2k_img=(j2k_image_t*)malloc(sizeof(j2k_image_t));
    j2k_img->numcomps=0;
    j2k_img->comps=NULL;
    j2k_cp=(j2k_cp_t*)malloc(sizeof(j2k_cp_t));
    j2k_cp->tcps=NULL;
    j2k_cp->tw=0;
    j2k_cp->th=0;
    *img=j2k_img;
    *cp=j2k_cp;
    j2k_state=J2K_STATE_MHSOC;
    cio_init(src, len);
    for (;;) {
        j2k_dec_mstabent_t *e;
        int id=cio_read(2);
        if (id>>8!=0xff) {
      /*             fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell()-2, id); */
            return 0;
        }
        e=j2k_dec_mstab_lookup(id);
        if (!(j2k_state & e->states)) {
      /*             fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell()-2, id); */
            return 0;
        }
        if (e->handler) {
            (*e->handler)();
        }
    }
}

/* dirty */
LIBJ2K_API int j2k_info(unsigned char *src, int len, j2k_image_t **img, j2k_cp_t **cp) {

   /*  Initialize globals ... */
   j2k_eot = NULL;
   j2k_img = NULL;
   j2k_cp  = NULL;
   j2k_tile_data = NULL;
   j2k_tile_len = NULL;
   j2k_default_tcp.tccps = NULL;

   if (setjmp(j2k_error)) {
        if (j2k_state!=J2K_STATE_MT) {
            fprintf(stderr, "WARNING: incomplete bitstream\n");
            return 0;
        }
        return cio_numbytes();
    }
    j2k_img=(j2k_image_t*)malloc(sizeof(j2k_image_t));
    j2k_img->numcomps=0;
    j2k_img->x1=0;
    j2k_img->x0=1;
    j2k_img->comps=NULL;

    j2k_cp=(j2k_cp_t*)malloc(sizeof(j2k_cp_t));
    j2k_cp->tcps=NULL;
    j2k_cp->tw=0;
    j2k_cp->th=0;
    *img=j2k_img;
    *cp=j2k_cp;
    j2k_state=J2K_STATE_MHSOC;
    cio_init(src, len);
    for (;;) {
        j2k_dec_mstabent_t *e;
        int id=cio_read(2);
        if (id>>8!=0xff) {
      /*             fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell()-2, id); */
            return 0;
        }
    e=j2k_dec_mstab_lookup(id);
        if (!(j2k_state & e->states)) {
      /*             fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell()-2, id); */
      return 0;
        }
    if (id==J2K_MS_SIZ)
      {
        j2k_read_siz();
        return cio_numbytes();
      }
    else
      {
        if (e->handler) {
          (*e->handler)();
        }
        }

    }
}

#ifdef WIN32
#include <windows.h>

BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
        case DLL_PROCESS_ATTACH:
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
        case DLL_PROCESS_DETACH:
            break;
    }
    return TRUE;
}
#endif