ext/tarkin/tarkin.c - mtk-gst-plugins-bad - Git at Google

 /*
  *   The real io-stuff is in tarkin-io.c
  *   (this one has to be rewritten to write ogg streams ...)
  */

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

 #include "mem.h"
 #include "tarkin.h"
 #include "yuv.h"


 #define N_FRAMES 1


 TarkinStream *
 tarkin_stream_new ()
 {
   TarkinStream *s = (TarkinStream *) CALLOC (1, sizeof (TarkinStream));

   if (!s)
     return NULL;
   memset (s, 0, sizeof (*s));

   s->frames_per_buf = N_FRAMES;

   return s;
 }


 void
 tarkin_stream_destroy (TarkinStream * s)
 {
   uint32_t i, j;

   if (!s)
     return;

   for (i = 0; i < s->n_layers; i++) {
     if (s->layer[i].waveletbuf) {
       for (j = 0; j < s->layer[i].n_comp; j++) {
         wavelet_3d_buf_destroy (s->layer[i].waveletbuf[j]);
         FREE (s->layer[i].packet[j].data);
       }
       FREE (s->layer[i].waveletbuf);
       FREE (s->layer[i].packet);
     }
   }

   if (s->layer)
     FREE (s->layer);

   if (s->headers.header)
     FREE (s->headers.header);

   if (s->headers.header1)
     FREE (s->headers.header1);

   if (s->headers.header2)
     FREE (s->headers.header2);


   FREE (s);
 }


 int
 tarkin_analysis_init (TarkinStream * s, TarkinInfo * ti,
     TarkinError (*free_frame) (void *s, void *ptr),
     TarkinError (*packet_out) (void *s, ogg_packet * ptr), void *user_ptr)
 {
   if ((!ti->inter.numerator) || (!ti->inter.denominator))
     return (-TARKIN_FAULT);
   if ((!free_frame) || (!packet_out))
     return (-TARKIN_FAULT);
   s->ti = ti;
   s->free_frame = free_frame;
   s->packet_out = packet_out;
   s->user_ptr = user_ptr;
   return (0);
 }


 extern int
 tarkin_analysis_add_layer (TarkinStream * s, TarkinVideoLayerDesc * tvld)
 {
   int i;
   TarkinVideoLayer *layer;

   if (s->n_layers) {
     s->layer = REALLOC (s->layer, (s->n_layers + 1) * sizeof (*s->layer));
   } else {
     s->layer = MALLOC (sizeof (*s->layer));
   }
   layer = s->layer + s->n_layers;
   memset (layer, 0, sizeof (*s->layer));
   memcpy (&layer->desc, tvld, sizeof (TarkinVideoLayerDesc));

   s->n_layers++;
   s->ti->n_layers = s->n_layers;
   s->ti->layer = s->layer;

   switch (layer->desc.format) {
     case TARKIN_GRAYSCALE:
       layer->n_comp = 1;
       layer->color_fwd_xform = grayscale_to_y;
       layer->color_inv_xform = y_to_grayscale;
       break;
     case TARKIN_RGB24:
       layer->n_comp = 3;
       layer->color_fwd_xform = rgb24_to_yuv;
       layer->color_inv_xform = yuv_to_rgb24;
       break;
     case TARKIN_RGB32:
       layer->n_comp = 3;
       layer->color_fwd_xform = rgb32_to_yuv;
       layer->color_inv_xform = yuv_to_rgb32;
       break;
     case TARKIN_RGBA:
       layer->n_comp = 4;
       layer->color_fwd_xform = rgba_to_yuv;
       layer->color_inv_xform = yuv_to_rgba;
       break;
     default:
       return -TARKIN_INVALID_COLOR_FORMAT;
   };

 #ifdef DBG_OGG
   printf ("dbg_ogg:add_layer %d with %d components\n",
       s->n_layers, layer->n_comp);
 #endif

   layer->waveletbuf = (Wavelet3DBuf **) CALLOC (layer->n_comp,
       sizeof (Wavelet3DBuf *));

   layer->packet = MALLOC (layer->n_comp * sizeof (*layer->packet));
   memset (layer->packet, 0, layer->n_comp * sizeof (*layer->packet));

   for (i = 0; i < layer->n_comp; i++) {
     layer->waveletbuf[i] = wavelet_3d_buf_new (layer->desc.width,
         layer->desc.height, layer->desc.frames_per_buf);
     layer->packet[i].data = MALLOC (layer->desc.bitstream_len);
     layer->packet[i].storage = layer->desc.bitstream_len;
   }
   /*
      max_bitstream_len += layer->desc.bitstream_len
      + 2 * 10 * sizeof(uint32_t) * layer->n_comp;
    */
   return (TARKIN_OK);
 }

 TarkinError
 _analysis_packetout (TarkinStream * s, uint32_t layer_id, uint32_t comp)
 {
   ogg_packet op;
   oggpack_buffer opb;
   uint8_t *data;
   uint32_t data_len;
   int i;

   data = s->layer[layer_id].packet[comp].data;
   data_len = s->layer[layer_id].packet[comp].data_len;

   oggpack_writeinit (&opb);
   oggpack_write (&opb, 0, 8);   /* No feature flags for now */
   oggpack_write (&opb, layer_id, 12);
   oggpack_write (&opb, comp, 12);
   for (i = 0; i < data_len; i++)
     oggpack_write (&opb, *(data + i), 8);

   op.b_o_s = 0;
   op.e_o_s = data_len ? 0 : 1;
   op.granulepos = 0;
   op.bytes = oggpack_bytes (&opb) + 4;
   op.packet = opb.buffer;
 #ifdef DBG_OGG
   printf ("dbg_ogg: writing packet layer %d, comp %d, data_len %d %s\n",
       layer_id, comp, data_len, op.e_o_s ? "eos" : "");
 #endif
   s->layer[layer_id].packet[comp].data_len = 0; /* so direct call => eos */
   return (s->packet_out (s, &op));
 }

 void
 _stream_flush (TarkinStream * s)
 {
   uint32_t i, j;

   s->current_frame_in_buf = 0;

   for (i = 0; i < s->n_layers; i++) {
     TarkinVideoLayer *layer = &s->layer[i];

     for (j = 0; j < layer->n_comp; j++) {
       uint32_t comp_bitstream_len;
       TarkinPacket *packet = layer->packet + j;

         /**
          *  implicit 6:1:1 subsampling
          */
       if (j == 0)
         comp_bitstream_len =
             6 * layer->desc.bitstream_len / (layer->n_comp + 5);
       else
         comp_bitstream_len = layer->desc.bitstream_len / (layer->n_comp + 5);

       if (packet->storage < comp_bitstream_len) {
         packet->storage = comp_bitstream_len;
         packet->data = REALLOC (packet->data, comp_bitstream_len);
       }

       wavelet_3d_buf_dump ("color-%d-%03d.pgm",
           s->current_frame, j, layer->waveletbuf[j], j == 0 ? 0 : 128);

       wavelet_3d_buf_fwd_xform (layer->waveletbuf[j],
           layer->desc.a_moments, layer->desc.s_moments);

       wavelet_3d_buf_dump ("coeff-%d-%03d.pgm",
           s->current_frame, j, layer->waveletbuf[j], 128);

       packet->data_len = wavelet_3d_buf_encode_coeff (layer->waveletbuf[j],
           packet->data, comp_bitstream_len);

       _analysis_packetout (s, i, j);
     }
   }
 }


 uint32_t
 tarkin_analysis_framein (TarkinStream * s, uint8_t * frame,
     uint32_t layer_id, TarkinTime * date)
 {
   TarkinVideoLayer *layer;

   if (!frame)
     return (_analysis_packetout (s, 0, 0));     /* eos */
   if ((layer_id >= s->n_layers) || (date->denominator == 0))
     return (TARKIN_FAULT);

   layer = s->layer + layer_id;
   layer->color_fwd_xform (frame, layer->waveletbuf, s->current_frame_in_buf);
   /* We don't use this feature for now, neither date... */
   s->free_frame (s, frame);

   s->current_frame_in_buf++;

   if (s->current_frame_in_buf == s->frames_per_buf)
     _stream_flush (s);

 #ifdef DBG_OGG
   printf ("dbg_ogg: framein at pos %d/%d, n? %d,%d on layer %d\n",
       date->numerator, date->denominator,
       layer->frameno, s->current_frame, layer_id);
 #endif

   layer->frameno++;
   return (++s->current_frame);
 }


 /**
  *   tarkin_stream_read_header() is now info.c:_tarkin_unpack_layer_desc()
  */


 TarkinError
 tarkin_stream_get_layer_desc (TarkinStream * s,
     uint32_t layer_id, TarkinVideoLayerDesc * desc)
 {
   if (layer_id > s->n_layers - 1)
     return -TARKIN_INVALID_LAYER;

   memcpy (desc, &(s->layer[layer_id].desc), sizeof (TarkinVideoLayerDesc));

   return TARKIN_OK;
 }

 TarkinError
 tarkin_synthesis_init (TarkinStream * s, TarkinInfo * ti)
 {
   s->ti = ti;
   s->layer = ti->layer;         /* It was malloc()ed by headerin() */
   s->n_layers = ti->n_layers;
   return (TARKIN_OK);
 }

 TarkinError
 tarkin_synthesis_packetin (TarkinStream * s, ogg_packet * op)
 {
   uint32_t i, layer_id, comp, data_len;
   uint32_t flags, junk;
   int nread;
   oggpack_buffer opb;
   TarkinPacket *packet;

 #ifdef DBG_OGG
   printf ("dbg_ogg: Reading packet n? %lld, granulepos %lld, len %ld, %s%s\n",
       op->packetno, op->granulepos, op->bytes,
       op->b_o_s ? "b_o_s" : "", op->e_o_s ? "e_o_s" : "");
 #endif
   oggpack_readinit (&opb, op->packet, op->bytes);
   flags = oggpack_read (&opb, 8);
   layer_id = oggpack_read (&opb, 12);   /* Theses are  required for */
   comp = oggpack_read (&opb, 12);       /* data hole handling (or maybe
                                          * packetno would be enough ?) */
   nread = 4;

   if (flags) {                  /* This is void "infinite future features" feature ;) */
     if (flags & 1 << 7) {
       junk = flags;
       while (junk & 1 << 7)
         junk = oggpack_read (&opb, 8);  /* allow for many future flags
                                            that must be correctly ordonned. */
     }
     /* This shows how to get a feature's data:
        if (flags & TARKIN_FLAGS_EXAMPLE){
        tp->example = oggpack_read(&opb,32);
        junk = tp->example & 3<<30;
        tp->example &= 0x4fffffff;
        }
      */
     for (junk = 1 << 31; junk & 1 << 31;)       /* and many future data */
       while ((junk = oggpack_read (&opb, 32)) & 1 << 30);
     /* That is, feature data comes in 30 bit chunks. We also have
      * 31 potentially useful bits in last chunk. */
   }

   nread = (opb.ptr - opb.buffer);
   data_len = op->bytes - nread;

 #ifdef DBG_OGG
   printf ("   layer_id %d, comp %d, meta-data %dB, w3d data %dB.\n",
       layer_id, comp, nread, data_len);
 #endif

   /* We now have for shure our data. */
   packet = &s->layer[layer_id].packet[comp];
   if (packet->data_len)
     return (-TARKIN_UNUSED);    /* Previous data wasn't used */

   if (packet->storage < data_len) {
     packet->storage = data_len + 255;
     packet->data = REALLOC (packet->data, packet->storage);
   }

   for (i = 0; i < data_len; i++)
     packet->data[i] = oggpack_read (&opb, 8);

   packet->data_len = data_len;

   return (TARKIN_OK);
 }

 TarkinError
 tarkin_synthesis_frameout (TarkinStream * s,
     uint8_t ** frame, uint32_t layer_id, TarkinTime * date)
 {
   int j;
   TarkinVideoLayer *layer = &s->layer[layer_id];

   if (s->current_frame_in_buf == 0) {
     *frame = MALLOC (layer->desc.width * layer->desc.height * layer->n_comp);
     for (j = 0; j < layer->n_comp; j++) {
       TarkinPacket *packet = layer->packet + j;

       if (packet->data_len == 0)
         goto err_out;

       wavelet_3d_buf_decode_coeff (layer->waveletbuf[j], packet->data,
           packet->data_len);

       wavelet_3d_buf_dump ("rcoeff-%d-%03d.pgm",
           s->current_frame, j, layer->waveletbuf[j], 128);

       wavelet_3d_buf_inv_xform (layer->waveletbuf[j],
           layer->desc.a_moments, layer->desc.s_moments);

       wavelet_3d_buf_dump ("rcolor-%d-%03d.pgm",
           s->current_frame, j, layer->waveletbuf[j], j == 0 ? 0 : 128);
     }

     /* We did successfylly read a block from this layer, acknowledge it. */
     for (j = 0; j < layer->n_comp; j++)
       layer->packet[j].data_len = 0;
   }

   layer->color_inv_xform (layer->waveletbuf, *frame, s->current_frame_in_buf);
   s->current_frame_in_buf++;
   s->current_frame++;

   if (s->current_frame_in_buf == s->frames_per_buf)
     s->current_frame_in_buf = 0;

   date->numerator = layer->frameno * s->ti->inter.numerator;
   date->denominator = s->ti->inter.denominator;
 #ifdef DBG_OGG
   printf ("dbg_ogg: outputting frame pos %d/%d from layer %d.\n",
       date->numerator, date->denominator, layer_id);
 #endif
   layer->frameno++;
   return (TARKIN_OK);
 err_out:
   FREE (*frame);
   return (TARKIN_NEED_MORE);
 }

 int
 tarkin_synthesis_freeframe (TarkinStream * s, uint8_t * frame)
 {
   FREE (frame);

   return (TARKIN_OK);
 }
	/*
	* The real io-stuff is in tarkin-io.c
	* (this one has to be rewritten to write ogg streams ...)
	*/

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include "mem.h"
	#include "tarkin.h"
	#include "yuv.h"


	#define N_FRAMES 1



	TarkinStream *
	tarkin_stream_new ()
	{
	TarkinStream s = (TarkinStream ) CALLOC (1, sizeof (TarkinStream));

	if (!s)
	return NULL;
	memset (s, 0, sizeof (*s));

	s->frames_per_buf = N_FRAMES;

	return s;
	}


	void
	tarkin_stream_destroy (TarkinStream * s)
	{
	uint32_t i, j;

	if (!s)
	return;

	for (i = 0; i < s->n_layers; i++) {
	if (s->layer[i].waveletbuf) {
	for (j = 0; j < s->layer[i].n_comp; j++) {
	wavelet_3d_buf_destroy (s->layer[i].waveletbuf[j]);
	FREE (s->layer[i].packet[j].data);
	}
	FREE (s->layer[i].waveletbuf);
	FREE (s->layer[i].packet);
	}
	}

	if (s->layer)
	FREE (s->layer);

	if (s->headers.header)
	FREE (s->headers.header);

	if (s->headers.header1)
	FREE (s->headers.header1);

	if (s->headers.header2)
	FREE (s->headers.header2);


	FREE (s);
	}


	int
	tarkin_analysis_init (TarkinStream * s, TarkinInfo * ti,
	TarkinError (free_frame) (void s, void *ptr),
	TarkinError (packet_out) (void s, ogg_packet * ptr), void *user_ptr)
	{
	if ((!ti->inter.numerator) \|\| (!ti->inter.denominator))
	return (-TARKIN_FAULT);
	if ((!free_frame) \|\| (!packet_out))
	return (-TARKIN_FAULT);
	s->ti = ti;
	s->free_frame = free_frame;
	s->packet_out = packet_out;
	s->user_ptr = user_ptr;
	return (0);
	}


	extern int
	tarkin_analysis_add_layer (TarkinStream * s, TarkinVideoLayerDesc * tvld)
	{
	int i;
	TarkinVideoLayer *layer;

	if (s->n_layers) {
	s->layer = REALLOC (s->layer, (s->n_layers + 1) * sizeof (*s->layer));
	} else {
	s->layer = MALLOC (sizeof (*s->layer));
	}
	layer = s->layer + s->n_layers;
	memset (layer, 0, sizeof (*s->layer));
	memcpy (&layer->desc, tvld, sizeof (TarkinVideoLayerDesc));

	s->n_layers++;
	s->ti->n_layers = s->n_layers;
	s->ti->layer = s->layer;

	switch (layer->desc.format) {
	case TARKIN_GRAYSCALE:
	layer->n_comp = 1;
	layer->color_fwd_xform = grayscale_to_y;
	layer->color_inv_xform = y_to_grayscale;
	break;
	case TARKIN_RGB24:
	layer->n_comp = 3;
	layer->color_fwd_xform = rgb24_to_yuv;
	layer->color_inv_xform = yuv_to_rgb24;
	break;
	case TARKIN_RGB32:
	layer->n_comp = 3;
	layer->color_fwd_xform = rgb32_to_yuv;
	layer->color_inv_xform = yuv_to_rgb32;
	break;
	case TARKIN_RGBA:
	layer->n_comp = 4;
	layer->color_fwd_xform = rgba_to_yuv;
	layer->color_inv_xform = yuv_to_rgba;
	break;
	default:
	return -TARKIN_INVALID_COLOR_FORMAT;
	};

	#ifdef DBG_OGG
	printf ("dbg_ogg:add_layer %d with %d components\n",
	s->n_layers, layer->n_comp);
	#endif

	layer->waveletbuf = (Wavelet3DBuf **) CALLOC (layer->n_comp,
	sizeof (Wavelet3DBuf *));

	layer->packet = MALLOC (layer->n_comp * sizeof (*layer->packet));
	memset (layer->packet, 0, layer->n_comp * sizeof (*layer->packet));

	for (i = 0; i < layer->n_comp; i++) {
	layer->waveletbuf[i] = wavelet_3d_buf_new (layer->desc.width,
	layer->desc.height, layer->desc.frames_per_buf);
	layer->packet[i].data = MALLOC (layer->desc.bitstream_len);
	layer->packet[i].storage = layer->desc.bitstream_len;
	}
	/*
	max_bitstream_len += layer->desc.bitstream_len
	+ 2 * 10 * sizeof(uint32_t) * layer->n_comp;
	*/
	return (TARKIN_OK);
	}

	TarkinError
	_analysis_packetout (TarkinStream * s, uint32_t layer_id, uint32_t comp)
	{
	ogg_packet op;
	oggpack_buffer opb;
	uint8_t *data;
	uint32_t data_len;
	int i;

	data = s->layer[layer_id].packet[comp].data;
	data_len = s->layer[layer_id].packet[comp].data_len;

	oggpack_writeinit (&opb);
	oggpack_write (&opb, 0, 8); /* No feature flags for now */
	oggpack_write (&opb, layer_id, 12);
	oggpack_write (&opb, comp, 12);
	for (i = 0; i < data_len; i++)
	oggpack_write (&opb, *(data + i), 8);

	op.b_o_s = 0;
	op.e_o_s = data_len ? 0 : 1;
	op.granulepos = 0;
	op.bytes = oggpack_bytes (&opb) + 4;
	op.packet = opb.buffer;
	#ifdef DBG_OGG
	printf ("dbg_ogg: writing packet layer %d, comp %d, data_len %d %s\n",
	layer_id, comp, data_len, op.e_o_s ? "eos" : "");
	#endif
	s->layer[layer_id].packet[comp].data_len = 0; /* so direct call => eos */
	return (s->packet_out (s, &op));
	}

	void
	_stream_flush (TarkinStream * s)
	{
	uint32_t i, j;

	s->current_frame_in_buf = 0;

	for (i = 0; i < s->n_layers; i++) {
	TarkinVideoLayer *layer = &s->layer[i];

	for (j = 0; j < layer->n_comp; j++) {
	uint32_t comp_bitstream_len;
	TarkinPacket *packet = layer->packet + j;

	/**
	* implicit 6:1:1 subsampling
	*/
	if (j == 0)
	comp_bitstream_len =
	6 * layer->desc.bitstream_len / (layer->n_comp + 5);
	else
	comp_bitstream_len = layer->desc.bitstream_len / (layer->n_comp + 5);

	if (packet->storage < comp_bitstream_len) {
	packet->storage = comp_bitstream_len;
	packet->data = REALLOC (packet->data, comp_bitstream_len);
	}

	wavelet_3d_buf_dump ("color-%d-%03d.pgm",
	s->current_frame, j, layer->waveletbuf[j], j == 0 ? 0 : 128);

	wavelet_3d_buf_fwd_xform (layer->waveletbuf[j],
	layer->desc.a_moments, layer->desc.s_moments);

	wavelet_3d_buf_dump ("coeff-%d-%03d.pgm",
	s->current_frame, j, layer->waveletbuf[j], 128);

	packet->data_len = wavelet_3d_buf_encode_coeff (layer->waveletbuf[j],
	packet->data, comp_bitstream_len);

	_analysis_packetout (s, i, j);
	}
	}
	}


	uint32_t
	tarkin_analysis_framein (TarkinStream * s, uint8_t * frame,
	uint32_t layer_id, TarkinTime * date)
	{
	TarkinVideoLayer *layer;

	if (!frame)
	return (_analysis_packetout (s, 0, 0)); /* eos */
	if ((layer_id >= s->n_layers) \|\| (date->denominator == 0))
	return (TARKIN_FAULT);

	layer = s->layer + layer_id;
	layer->color_fwd_xform (frame, layer->waveletbuf, s->current_frame_in_buf);
	/* We don't use this feature for now, neither date... */
	s->free_frame (s, frame);

	s->current_frame_in_buf++;

	if (s->current_frame_in_buf == s->frames_per_buf)
	_stream_flush (s);

	#ifdef DBG_OGG
	printf ("dbg_ogg: framein at pos %d/%d, n? %d,%d on layer %d\n",
	date->numerator, date->denominator,
	layer->frameno, s->current_frame, layer_id);
	#endif

	layer->frameno++;
	return (++s->current_frame);
	}




	/**
	* tarkin_stream_read_header() is now info.c:_tarkin_unpack_layer_desc()
	*/



	TarkinError
	tarkin_stream_get_layer_desc (TarkinStream * s,
	uint32_t layer_id, TarkinVideoLayerDesc * desc)
	{
	if (layer_id > s->n_layers - 1)
	return -TARKIN_INVALID_LAYER;

	memcpy (desc, &(s->layer[layer_id].desc), sizeof (TarkinVideoLayerDesc));

	return TARKIN_OK;
	}

	TarkinError
	tarkin_synthesis_init (TarkinStream * s, TarkinInfo * ti)
	{
	s->ti = ti;
	s->layer = ti->layer; /* It was malloc()ed by headerin() */
	s->n_layers = ti->n_layers;
	return (TARKIN_OK);
	}

	TarkinError
	tarkin_synthesis_packetin (TarkinStream * s, ogg_packet * op)
	{
	uint32_t i, layer_id, comp, data_len;
	uint32_t flags, junk;
	int nread;
	oggpack_buffer opb;
	TarkinPacket *packet;

	#ifdef DBG_OGG
	printf ("dbg_ogg: Reading packet n? %lld, granulepos %lld, len %ld, %s%s\n",
	op->packetno, op->granulepos, op->bytes,
	op->b_o_s ? "b_o_s" : "", op->e_o_s ? "e_o_s" : "");
	#endif
	oggpack_readinit (&opb, op->packet, op->bytes);
	flags = oggpack_read (&opb, 8);
	layer_id = oggpack_read (&opb, 12); /* Theses are required for */
	comp = oggpack_read (&opb, 12); /* data hole handling (or maybe
	* packetno would be enough ?) */
	nread = 4;

	if (flags) { /* This is void "infinite future features" feature ;) */
	if (flags & 1 << 7) {
	junk = flags;
	while (junk & 1 << 7)
	junk = oggpack_read (&opb, 8); /* allow for many future flags
	that must be correctly ordonned. */
	}
	/* This shows how to get a feature's data:
	if (flags & TARKIN_FLAGS_EXAMPLE){
	tp->example = oggpack_read(&opb,32);
	junk = tp->example & 3<<30;
	tp->example &= 0x4fffffff;
	}
	*/
	for (junk = 1 << 31; junk & 1 << 31;) /* and many future data */
	while ((junk = oggpack_read (&opb, 32)) & 1 << 30);
	/* That is, feature data comes in 30 bit chunks. We also have
	* 31 potentially useful bits in last chunk. */
	}

	nread = (opb.ptr - opb.buffer);
	data_len = op->bytes - nread;

	#ifdef DBG_OGG
	printf (" layer_id %d, comp %d, meta-data %dB, w3d data %dB.\n",
	layer_id, comp, nread, data_len);
	#endif

	/* We now have for shure our data. */
	packet = &s->layer[layer_id].packet[comp];
	if (packet->data_len)
	return (-TARKIN_UNUSED); /* Previous data wasn't used */

	if (packet->storage < data_len) {
	packet->storage = data_len + 255;
	packet->data = REALLOC (packet->data, packet->storage);
	}

	for (i = 0; i < data_len; i++)
	packet->data[i] = oggpack_read (&opb, 8);

	packet->data_len = data_len;

	return (TARKIN_OK);
	}

	TarkinError
	tarkin_synthesis_frameout (TarkinStream * s,
	uint8_t ** frame, uint32_t layer_id, TarkinTime * date)
	{
	int j;
	TarkinVideoLayer *layer = &s->layer[layer_id];

	if (s->current_frame_in_buf == 0) {
	frame = MALLOC (layer->desc.width layer->desc.height * layer->n_comp);
	for (j = 0; j < layer->n_comp; j++) {
	TarkinPacket *packet = layer->packet + j;

	if (packet->data_len == 0)
	goto err_out;

	wavelet_3d_buf_decode_coeff (layer->waveletbuf[j], packet->data,
	packet->data_len);

	wavelet_3d_buf_dump ("rcoeff-%d-%03d.pgm",
	s->current_frame, j, layer->waveletbuf[j], 128);

	wavelet_3d_buf_inv_xform (layer->waveletbuf[j],
	layer->desc.a_moments, layer->desc.s_moments);

	wavelet_3d_buf_dump ("rcolor-%d-%03d.pgm",
	s->current_frame, j, layer->waveletbuf[j], j == 0 ? 0 : 128);
	}

	/* We did successfylly read a block from this layer, acknowledge it. */
	for (j = 0; j < layer->n_comp; j++)
	layer->packet[j].data_len = 0;
	}

	layer->color_inv_xform (layer->waveletbuf, *frame, s->current_frame_in_buf);
	s->current_frame_in_buf++;
	s->current_frame++;

	if (s->current_frame_in_buf == s->frames_per_buf)
	s->current_frame_in_buf = 0;

	date->numerator = layer->frameno * s->ti->inter.numerator;
	date->denominator = s->ti->inter.denominator;
	#ifdef DBG_OGG
	printf ("dbg_ogg: outputting frame pos %d/%d from layer %d.\n",
	date->numerator, date->denominator, layer_id);
	#endif
	layer->frameno++;
	return (TARKIN_OK);
	err_out:
	FREE (*frame);
	return (TARKIN_NEED_MORE);
	}

	int
	tarkin_synthesis_freeframe (TarkinStream * s, uint8_t * frame)
	{
	FREE (frame);

	return (TARKIN_OK);
	}