gstreamer/ext/tarkin/tarkin.c

421 lines
11 KiB
C
Raw Normal View History

/*
* 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);
}