| #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 |
| |
| |
| |
| |
| |
| |
