gstreamer/ext/tarkin/tarkin.c

423 lines
12 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 usefull 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);
}