gstreamer/ext/tarkin/tarkin.h

240 lines
8.7 KiB
C
Raw Normal View History

#ifndef __TARKIN_H
#define __TARKIN_H
#include <stdio.h>
#include "wavelet.h"
#include <ogg/ogg.h>
#define BUG(x...) \
do { \
printf("BUG in %s (%s: line %i): ", __FUNCTION__, __FILE__, __LINE__); \
printf(#x); \
printf("\n"); \
exit (-1); \
} while (0);
/* Theses determine what infos the packet comes with */
#define TARKIN_PACK_EXAMPLE 1
typedef struct {
uint8_t *data;
uint32_t data_len;
uint32_t storage;
} TarkinPacket;
typedef enum {
TARKIN_GRAYSCALE,
TARKIN_RGB24, /* tight packed RGB */
TARKIN_RGB32, /* 32bit, no alphachannel */
TARKIN_RGBA, /* dito w/ alphachannel */
TARKIN_YUV2, /* 16 bits YUV */
TARKIN_YUV12, /* 12 bits YUV */
TARKIN_FYUV, /* Tarkin's Fast YUV-like? */
} TarkinColorFormat;
#define TARKIN_INTERNAL_FORMAT TARKIN_FYUV
typedef enum {
TARKIN_OK = 0,
TARKIN_IO_ERROR,
TARKIN_SIGNATURE_NOT_FOUND,
TARKIN_INVALID_LAYER,
TARKIN_INVALID_COLOR_FORMAT,
TARKIN_VERSION,
TARKIN_BAD_HEADER,
TARKIN_NOT_TARKIN,
TARKIN_FAULT,
TARKIN_UNUSED,
TARKIN_NEED_MORE,
TARKIN_NOT_IMPLEMENTED
} TarkinError;
typedef struct {
uint32_t width;
uint32_t height;
uint32_t a_moments;
uint32_t s_moments;
uint32_t frames_per_buf;
uint32_t bitstream_len; /* for all color components, bytes */
TarkinColorFormat format;
} TarkinVideoLayerDesc;
typedef struct {
TarkinVideoLayerDesc desc;
uint32_t n_comp; /* number of color components */
Wavelet3DBuf **waveletbuf;
TarkinPacket *packet;
uint32_t current_frame_in_buf;
uint32_t frameno;
void (*color_fwd_xform) (uint8_t *rgba, Wavelet3DBuf *yuva [], uint32_t count);
void (*color_inv_xform) (Wavelet3DBuf *yuva [], uint8_t *rgba, uint32_t count);
} TarkinVideoLayer;
typedef struct {
uint32_t numerator;
uint32_t denominator;
} TarkinTime; /* Let's say the unit is 1 second */
typedef struct TarkinInfo {
int version;
int n_layers;
TarkinVideoLayer *layer;
TarkinTime inter; /* numerator == O if per-frame time info. */
int frames_per_block;
int comp_per_block; /* AKA "packets per block" for now */
uint32_t max_bitstream_len;
/* The below bitrate declarations are *hints*.
Combinations of the three values carry the following implications:
all three set to the same value:
implies a fixed rate bitstream
only nominal set:
implies a VBR stream that averages the nominal bitrate. No hard
upper/lower limit
upper and or lower set:
implies a VBR bitstream that obeys the bitrate limits. nominal
may also be set to give a nominal rate.
none set:
the coder does not care to speculate.
*/
long bitrate_upper;
long bitrate_nominal;
long bitrate_lower;
long bitrate_window;
} TarkinInfo;
/* This is used for encoding */
typedef struct {
unsigned char *header;
unsigned char *header1;
unsigned char *header2;
} tarkin_header_store;
/* Some of the fields in TarkinStream are redundent with TarkinInfo ones
* and will probably get deleted, namely n_layers and frames_per_buf */
typedef struct TarkinStream {
uint32_t n_layers;
TarkinVideoLayer *layer;
uint32_t current_frame;
uint32_t current_frame_in_buf;
ogg_int64_t packetno;
uint32_t frames_per_buf;
uint32_t max_bitstream_len;
TarkinInfo *ti;
tarkin_header_store headers;
/* These callbacks are only used for encoding */
TarkinError (*free_frame)(void *tarkinstream, void *ptr);
/* These thing allows not to buffer but it needs global var in caller. */
TarkinError (*packet_out)(void *tarkinstream, ogg_packet *ptr);
void * user_ptr;
} TarkinStream;
typedef struct TarkinComment{
/* unlimited user comment fields. libtarkin writes 'libtarkin'
whatever vendor is set to in encode */
char **user_comments;
int *comment_lengths;
int comments;
char *vendor;
} TarkinComment;
/* Tarkin PRIMITIVES: general ***************************************/
/* The Tarkin header is in three packets, the initial small packet in
the first page that identifies basic parameters, that is a TarkinInfo
structure, a second packet with bitstream comments and a third packet
that holds the layers description structures. */
/* Theses are the very same than Vorbis versions, they could be shared. */
extern TarkinStream* tarkin_stream_new ();
extern void tarkin_stream_destroy (TarkinStream *s);
extern void tarkin_info_init(TarkinInfo *vi);
extern void tarkin_info_clear(TarkinInfo *vi);
extern void tarkin_comment_init(TarkinComment *vc);
extern void tarkin_comment_add(TarkinComment *vc, char *comment);
extern void tarkin_comment_add_tag(TarkinComment *vc,
char *tag, char *contents);
extern char *tarkin_comment_query(TarkinComment *vc, char *tag, int count);
extern int tarkin_comment_query_count(TarkinComment *vc, char *tag);
extern void tarkin_comment_clear(TarkinComment *vc);
/* Tarkin PRIMITIVES: analysis layer ****************************/
/* Tarkin encoding is done this way : you init it passing a fresh
* TarkinStream and a fresh TarkinInfo which has at least the rate_num
* field renseigned. You also pass it two callback functions: free_frame()
* is called when the lib doesn't need a frame anymore, and packet_out
* is called when a packet is ready. The pointers given as arguments to
* these callback functions are of course only valid at the function call
* time. The user_ptr is stored in s and can be used by packet_out(). */
extern int tarkin_analysis_init(TarkinStream *s,
TarkinInfo *ti,
TarkinError (*free_frame)(void *tarkinstream, void *ptr),
TarkinError (*packet_out)(void *tarkinstream, ogg_packet *ptr),
void *user_ptr
);
/* Then you need to add at least a layer in your stream, passing a
* TarkinVideoLayerDesc renseigned at least on the width, height and
* format parameters. */
extern int tarkin_analysis_add_layer(TarkinStream *s,
TarkinVideoLayerDesc *tvld);
/* At that point you are ready to get headers out the lib by calling
* tarkin_analysis_headerout() passing it a renseigned TarkinComment
* structure. It does fill your 3 ogg_packet headers, which are valid
* till next call */
extern int TarkinCommentheader_out(TarkinComment *vc, ogg_packet *op);
extern TarkinError tarkin_analysis_headerout(TarkinStream *s,
TarkinComment *vc,
ogg_packet *op,
ogg_packet *op_comm,
ogg_packet *op_code);
/* You are now ready to pass in frames to the codec, however don't free
* them before the codec told you so. It'll tell you when packets are
* ready to be taken out. When you have no more frame, simply pass NULL.
* If you encode multiple layers you have to do it synchronously, putting
* one frame from each layer at a time. */
extern uint32_t tarkin_analysis_framein(TarkinStream *s,
uint8_t *frame, /* NULL for EOS */
uint32_t layer,
TarkinTime *date);
/* Tarkin PRIMITIVES: synthesis layer *******************************/
/* For decoding, you needs first to give the three first packet of the
* stream to tarkin_synthesis_headerin() which will fill for you blank
* TarkinInfo and TarkinComment. */
extern TarkinError tarkin_synthesis_headerin(TarkinInfo *vi,TarkinComment *vc,
ogg_packet *op);
/* Then you can init your stream with your TarkinInfo struct. */
extern TarkinError tarkin_synthesis_init(TarkinStream *s,TarkinInfo *ti);
/* All subsequent packets are to this be passed to tarkin_synthesis_packetin*/
extern TarkinError tarkin_synthesis_packetin(TarkinStream *s, ogg_packet *op);
/* and then tarkin_synthesis_frameout gives you ptr on next frame, or NULL. It
* also fills for you date. */
extern TarkinError tarkin_synthesis_frameout(TarkinStream *s,
uint8_t **frame, uint32_t layer_id, TarkinTime *date);
/* When you're done with a frame, tell it to the codec with this. */
extern int tarkin_synthesis_freeframe(TarkinStream *s, uint8_t *frame);
#endif