diff options
Diffstat (limited to 'apps/codecs/libtremor/ogg.h')
-rw-r--r-- | apps/codecs/libtremor/ogg.h | 387 |
1 files changed, 192 insertions, 195 deletions
diff --git a/apps/codecs/libtremor/ogg.h b/apps/codecs/libtremor/ogg.h index 15ca46b3cd..da072184b4 100644 --- a/apps/codecs/libtremor/ogg.h +++ b/apps/codecs/libtremor/ogg.h | |||
@@ -1,17 +1,17 @@ | |||
1 | /******************************************************************** | 1 | /******************************************************************** |
2 | * * | 2 | * * |
3 | * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * | 3 | * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * |
4 | * * | ||
5 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * | 4 | * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * |
6 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * | 5 | * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * |
7 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * | 6 | * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * |
8 | * * | 7 | * * |
9 | * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 * | 8 | * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 * |
10 | * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * | 9 | * by the Xiph.Org Foundation http://www.xiph.org/ * |
11 | * * | 10 | * * |
12 | ******************************************************************** | 11 | ******************************************************************** |
13 | 12 | ||
14 | function: subsumed libogg includes | 13 | function: toplevel libogg include |
14 | last mod: $Id$ | ||
15 | 15 | ||
16 | ********************************************************************/ | 16 | ********************************************************************/ |
17 | #ifndef _OGG_H | 17 | #ifndef _OGG_H |
@@ -21,241 +21,238 @@ | |||
21 | extern "C" { | 21 | extern "C" { |
22 | #endif | 22 | #endif |
23 | 23 | ||
24 | #include <stddef.h> | ||
24 | #include "os_types.h" | 25 | #include "os_types.h" |
25 | 26 | ||
26 | typedef struct ogg_buffer_state{ | 27 | extern const unsigned long mask[] ICONST_ATTR; |
27 | struct ogg_buffer *unused_buffers; | ||
28 | struct ogg_reference *unused_references; | ||
29 | int outstanding; | ||
30 | int shutdown; | ||
31 | } ogg_buffer_state; | ||
32 | |||
33 | typedef struct ogg_buffer { | ||
34 | unsigned char *data; | ||
35 | long size; | ||
36 | int refcount; | ||
37 | |||
38 | union { | ||
39 | ogg_buffer_state *owner; | ||
40 | struct ogg_buffer *next; | ||
41 | } ptr; | ||
42 | } ogg_buffer; | ||
43 | |||
44 | typedef struct ogg_reference { | ||
45 | ogg_buffer *buffer; | ||
46 | long begin; | ||
47 | long length; | ||
48 | |||
49 | struct ogg_reference *next; | ||
50 | } ogg_reference; | ||
51 | |||
52 | typedef struct oggpack_buffer { | ||
53 | int headbit; | ||
54 | unsigned char *headptr; | ||
55 | long headend; | ||
56 | |||
57 | /* memory management */ | ||
58 | ogg_reference *head; | ||
59 | ogg_reference *tail; | ||
60 | |||
61 | /* render the byte/bit counter API constant time */ | ||
62 | long count; /* doesn't count the tail */ | ||
63 | } oggpack_buffer; | ||
64 | 28 | ||
65 | typedef struct oggbyte_buffer { | 29 | typedef struct { |
66 | ogg_reference *baseref; | 30 | void *iov_base; |
31 | size_t iov_len; | ||
32 | } ogg_iovec_t; | ||
33 | |||
34 | typedef struct { | ||
35 | long endbyte; | ||
36 | int endbit; | ||
67 | 37 | ||
68 | ogg_reference *ref; | 38 | unsigned char *buffer; |
69 | unsigned char *ptr; | 39 | unsigned char *ptr; |
70 | long pos; | 40 | long storage; |
71 | long end; | 41 | } oggpack_buffer; |
72 | } oggbyte_buffer; | ||
73 | 42 | ||
74 | typedef struct ogg_sync_state { | 43 | /* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/ |
75 | /* decode memory management pool */ | ||
76 | ogg_buffer_state *bufferpool; | ||
77 | 44 | ||
78 | /* stream buffers */ | 45 | typedef struct { |
79 | ogg_reference *fifo_head; | 46 | unsigned char *header; |
80 | ogg_reference *fifo_tail; | 47 | long header_len; |
81 | long fifo_fill; | 48 | unsigned char *body; |
49 | long body_len; | ||
50 | } ogg_page; | ||
82 | 51 | ||
83 | /* stream sync management */ | 52 | /* ogg_stream_state contains the current encode/decode state of a logical |
84 | int unsynced; | 53 | Ogg bitstream **********************************************************/ |
85 | int headerbytes; | ||
86 | int bodybytes; | ||
87 | 54 | ||
88 | } ogg_sync_state; | 55 | typedef struct { |
56 | unsigned char *body_data; /* bytes from packet bodies */ | ||
57 | long body_storage; /* storage elements allocated */ | ||
58 | long body_fill; /* elements stored; fill mark */ | ||
59 | long body_returned; /* elements of fill returned */ | ||
60 | |||
61 | |||
62 | int *lacing_vals; /* The values that will go to the segment table */ | ||
63 | ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact | ||
64 | this way, but it is simple coupled to the | ||
65 | lacing fifo */ | ||
66 | long lacing_storage; | ||
67 | long lacing_fill; | ||
68 | long lacing_packet; | ||
69 | long lacing_returned; | ||
70 | |||
71 | #if 0 | ||
72 | unsigned char header[282]; /* working space for header encode */ | ||
73 | int header_fill; | ||
74 | #endif | ||
75 | int e_o_s; /* set when we have buffered the last packet in the | ||
76 | logical bitstream */ | ||
77 | int b_o_s; /* set after we've written the initial page | ||
78 | of a logical bitstream */ | ||
79 | ogg_uint32_t serialno; | ||
80 | long pageno; | ||
81 | ogg_int64_t packetno; /* sequence number for decode; the framing | ||
82 | knows where there's a hole in the data, | ||
83 | but we need coupling so that the codec | ||
84 | (which is in a separate abstraction | ||
85 | layer) also knows about the gap */ | ||
86 | ogg_int64_t granulepos; | ||
89 | 87 | ||
90 | typedef struct ogg_stream_state { | ||
91 | ogg_reference *header_head; | ||
92 | ogg_reference *header_tail; | ||
93 | ogg_reference *body_head; | ||
94 | ogg_reference *body_tail; | ||
95 | |||
96 | int e_o_s; /* set when we have buffered the last | ||
97 | packet in the logical bitstream */ | ||
98 | int b_o_s; /* set after we've written the initial page | ||
99 | of a logical bitstream */ | ||
100 | long serialno; | ||
101 | long pageno; | ||
102 | ogg_int64_t packetno; /* sequence number for decode; the framing | ||
103 | knows where there's a hole in the data, | ||
104 | but we need coupling so that the codec | ||
105 | (which is in a seperate abstraction | ||
106 | layer) also knows about the gap */ | ||
107 | ogg_int64_t granulepos; | ||
108 | |||
109 | int lacing_fill; | ||
110 | ogg_uint32_t body_fill; | ||
111 | |||
112 | /* decode-side state data */ | ||
113 | int holeflag; | ||
114 | int spanflag; | ||
115 | int clearflag; | ||
116 | int laceptr; | ||
117 | ogg_uint32_t body_fill_next; | ||
118 | |||
119 | } ogg_stream_state; | 88 | } ogg_stream_state; |
120 | 89 | ||
90 | /* ogg_packet is used to encapsulate the data and metadata belonging | ||
91 | to a single raw Ogg/Vorbis packet *************************************/ | ||
92 | |||
121 | typedef struct { | 93 | typedef struct { |
122 | ogg_reference *packet; | 94 | unsigned char *packet; |
123 | long bytes; | 95 | long bytes; |
124 | long b_o_s; | 96 | long b_o_s; |
125 | long e_o_s; | 97 | long e_o_s; |
126 | ogg_int64_t granulepos; | 98 | |
127 | ogg_int64_t packetno; /* sequence number for decode; the framing | 99 | ogg_int64_t granulepos; |
128 | knows where there's a hole in the data, | 100 | |
129 | but we need coupling so that the codec | 101 | ogg_int64_t packetno; /* sequence number for decode; the framing |
130 | (which is in a seperate abstraction | 102 | knows where there's a hole in the data, |
131 | layer) also knows about the gap */ | 103 | but we need coupling so that the codec |
104 | (which is in a separate abstraction | ||
105 | layer) also knows about the gap */ | ||
132 | } ogg_packet; | 106 | } ogg_packet; |
133 | 107 | ||
134 | typedef struct { | 108 | typedef struct { |
135 | ogg_reference *header; | 109 | unsigned char *data; |
136 | int header_len; | 110 | int storage; |
137 | ogg_reference *body; | 111 | int fill; |
138 | long body_len; | 112 | int returned; |
139 | } ogg_page; | 113 | |
114 | int unsynced; | ||
115 | int headerbytes; | ||
116 | int bodybytes; | ||
117 | } ogg_sync_state; | ||
140 | 118 | ||
141 | /* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ | 119 | /* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ |
120 | /* | ||
121 | extern void oggpack_writeinit(oggpack_buffer *b); | ||
122 | extern int oggpack_writecheck(oggpack_buffer *b); | ||
123 | extern void oggpack_writetrunc(oggpack_buffer *b,long bits); | ||
124 | extern void oggpack_writealign(oggpack_buffer *b); | ||
125 | extern void oggpack_writecopy(oggpack_buffer *b,void *source,long bits); | ||
126 | extern void oggpack_reset(oggpack_buffer *b); | ||
127 | extern void oggpack_writeclear(oggpack_buffer *b); */ | ||
128 | extern void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); | ||
129 | /* extern void oggpack_write(oggpack_buffer *b,unsigned long value,int bits); */ | ||
130 | |||
131 | //extern long oggpack_look(oggpack_buffer *b,int bits); | ||
132 | static inline long oggpack_look(oggpack_buffer *b,int bits){ | ||
133 | unsigned long ret; | ||
134 | unsigned long m; | ||
135 | |||
136 | if(bits<0 || bits>32) return -1; | ||
137 | m=mask[bits]; | ||
138 | bits+=b->endbit; | ||
139 | |||
140 | if(b->endbyte >= b->storage-4){ | ||
141 | /* not the main path */ | ||
142 | if(b->endbyte > b->storage-((bits+7)>>3)) return -1; | ||
143 | /* special case to avoid reading b->ptr[0], which might be past the end of | ||
144 | the buffer; also skips some useless accounting */ | ||
145 | else if(!bits)return(0L); | ||
146 | } | ||
142 | 147 | ||
143 | extern void oggpack_readinit(oggpack_buffer *b,ogg_reference *r); | 148 | ret=b->ptr[0]>>b->endbit; |
144 | extern long oggpack_look_full(oggpack_buffer *b,int bits); | 149 | if(bits>8){ |
145 | extern long oggpack_read(oggpack_buffer *b,register int bits); | 150 | ret|=b->ptr[1]<<(8-b->endbit); |
146 | 151 | if(bits>16){ | |
147 | /* Inline a few, often called functions */ | 152 | ret|=b->ptr[2]<<(16-b->endbit); |
148 | 153 | if(bits>24){ | |
149 | /* mark read process as having run off the end */ | 154 | ret|=b->ptr[3]<<(24-b->endbit); |
150 | static inline void _adv_halt(oggpack_buffer *b){ | 155 | if(bits>32 && b->endbit) |
151 | b->headptr=b->head->buffer->data+b->head->begin+b->head->length; | 156 | ret|=b->ptr[4]<<(32-b->endbit); |
152 | b->headend=-1; | 157 | } |
153 | b->headbit=0; | ||
154 | } | ||
155 | |||
156 | /* spans forward, skipping as many bytes as headend is negative; if | ||
157 | headend is zero, simply finds next byte. If we're up to the end | ||
158 | of the buffer, leaves headend at zero. If we've read past the end, | ||
159 | halt the decode process. */ | ||
160 | static inline void _span(oggpack_buffer *b){ | ||
161 | while(b->headend<1){ | ||
162 | if(b->head->next){ | ||
163 | b->count+=b->head->length; | ||
164 | b->head=b->head->next; | ||
165 | b->headptr=b->head->buffer->data+b->head->begin-b->headend; | ||
166 | b->headend+=b->head->length; | ||
167 | }else{ | ||
168 | /* we've either met the end of decode, or gone past it. halt | ||
169 | only if we're past */ | ||
170 | if(b->headend<0 || b->headbit) | ||
171 | /* read has fallen off the end */ | ||
172 | _adv_halt(b); | ||
173 | |||
174 | break; | ||
175 | } | 158 | } |
176 | } | 159 | } |
160 | return(m&ret); | ||
177 | } | 161 | } |
178 | 162 | ||
179 | /* limited to 32 at a time */ | 163 | extern long oggpack_look1(oggpack_buffer *b); |
164 | |||
165 | //extern void oggpack_adv(oggpack_buffer *b,int bits); | ||
180 | static inline void oggpack_adv(oggpack_buffer *b,int bits){ | 166 | static inline void oggpack_adv(oggpack_buffer *b,int bits){ |
181 | bits+=b->headbit; | 167 | bits+=b->endbit; |
182 | b->headbit=bits&7; | ||
183 | b->headptr+=bits/8; | ||
184 | if((b->headend-=((unsigned)bits)/8)<1)_span(b); | ||
185 | } | ||
186 | 168 | ||
187 | static inline long oggpack_look(oggpack_buffer *b, int bits){ | 169 | if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow; |
188 | if(bits+b->headbit < b->headend<<3){ | 170 | |
189 | extern const unsigned long oggpack_mask[]; | 171 | b->ptr+=bits/8; |
190 | unsigned long m=oggpack_mask[bits]; | 172 | b->endbyte+=bits/8; |
191 | unsigned long ret=-1; | 173 | b->endbit=bits&7; |
192 | 174 | return; | |
193 | bits+=b->headbit; | 175 | |
194 | ret=b->headptr[0]>>b->headbit; | 176 | overflow: |
195 | if(bits>8){ | 177 | b->ptr=NULL; |
196 | ret|=b->headptr[1]<<(8-b->headbit); | 178 | b->endbyte=b->storage; |
197 | if(bits>16){ | 179 | b->endbit=1; |
198 | ret|=b->headptr[2]<<(16-b->headbit); | ||
199 | if(bits>24){ | ||
200 | ret|=b->headptr[3]<<(24-b->headbit); | ||
201 | if(bits>32 && b->headbit) | ||
202 | ret|=b->headptr[4]<<(32-b->headbit); | ||
203 | } | ||
204 | } | ||
205 | } | ||
206 | return ret&m; | ||
207 | }else{ | ||
208 | return oggpack_look_full(b, bits); | ||
209 | } | ||
210 | } | 180 | } |
211 | 181 | ||
182 | extern void oggpack_adv1(oggpack_buffer *b); | ||
183 | extern long oggpack_read(oggpack_buffer *b,int bits); | ||
184 | extern long oggpack_read1(oggpack_buffer *b); | ||
185 | #if 0 | ||
186 | extern long oggpack_bytes(oggpack_buffer *b); | ||
187 | extern long oggpack_bits(oggpack_buffer *b); | ||
188 | extern unsigned char *oggpack_get_buffer(oggpack_buffer *b); | ||
189 | |||
190 | extern void oggpackB_writeinit(oggpack_buffer *b); | ||
191 | extern int oggpackB_writecheck(oggpack_buffer *b); | ||
192 | extern void oggpackB_writetrunc(oggpack_buffer *b,long bits); | ||
193 | extern void oggpackB_writealign(oggpack_buffer *b); | ||
194 | extern void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits); | ||
195 | extern void oggpackB_reset(oggpack_buffer *b); | ||
196 | extern void oggpackB_writeclear(oggpack_buffer *b); | ||
197 | extern void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); | ||
198 | extern void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits); | ||
199 | extern long oggpackB_look(oggpack_buffer *b,int bits); | ||
200 | extern long oggpackB_look1(oggpack_buffer *b); | ||
201 | extern void oggpackB_adv(oggpack_buffer *b,int bits); | ||
202 | extern void oggpackB_adv1(oggpack_buffer *b); | ||
203 | extern long oggpackB_read(oggpack_buffer *b,int bits); | ||
204 | extern long oggpackB_read1(oggpack_buffer *b); | ||
205 | extern long oggpackB_bytes(oggpack_buffer *b); | ||
206 | extern long oggpackB_bits(oggpack_buffer *b); | ||
207 | extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b); | ||
208 | # endif | ||
209 | /* Ogg BITSTREAM PRIMITIVES: encoding **************************/ | ||
210 | #if 0 | ||
211 | extern int ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op); | ||
212 | extern int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, | ||
213 | int count, long e_o_s, ogg_int64_t granulepos); | ||
214 | extern int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og); | ||
215 | extern int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill); | ||
216 | extern int ogg_stream_flush(ogg_stream_state *os, ogg_page *og); | ||
217 | #endif | ||
212 | /* Ogg BITSTREAM PRIMITIVES: decoding **************************/ | 218 | /* Ogg BITSTREAM PRIMITIVES: decoding **************************/ |
213 | 219 | ||
214 | extern ogg_sync_state *ogg_sync_create(void); | 220 | extern int ogg_sync_init(ogg_sync_state *oy); |
215 | extern int ogg_sync_destroy(ogg_sync_state *oy); | 221 | extern int ogg_sync_clear(ogg_sync_state *oy); |
216 | extern int ogg_sync_reset(ogg_sync_state *oy); | 222 | extern int ogg_sync_reset(ogg_sync_state *oy); |
223 | extern int ogg_sync_destroy(ogg_sync_state *oy); | ||
224 | extern int ogg_sync_check(ogg_sync_state *oy); | ||
217 | 225 | ||
218 | extern unsigned char *ogg_sync_bufferin(ogg_sync_state *oy, long size); | 226 | extern char *ogg_sync_buffer(ogg_sync_state *oy, long size); |
219 | extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes); | 227 | extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes); |
220 | extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); | 228 | extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); |
229 | extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og); | ||
221 | extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og); | 230 | extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og); |
222 | extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); | 231 | extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); |
223 | extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); | 232 | extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); |
224 | 233 | ||
225 | /* Ogg BITSTREAM PRIMITIVES: general ***************************/ | 234 | /* Ogg BITSTREAM PRIMITIVES: general ***************************/ |
226 | 235 | ||
227 | extern ogg_stream_state *ogg_stream_create(int serialno); | 236 | extern int ogg_stream_init(ogg_stream_state *os,int serialno); |
228 | extern int ogg_stream_destroy(ogg_stream_state *os); | 237 | extern int ogg_stream_clear(ogg_stream_state *os); |
229 | extern int ogg_stream_reset(ogg_stream_state *os); | 238 | extern int ogg_stream_reset(ogg_stream_state *os); |
230 | extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); | 239 | extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); |
240 | extern int ogg_stream_destroy(ogg_stream_state *os); | ||
241 | extern int ogg_stream_check(ogg_stream_state *os); | ||
231 | extern int ogg_stream_eos(ogg_stream_state *os); | 242 | extern int ogg_stream_eos(ogg_stream_state *os); |
232 | 243 | ||
233 | extern int ogg_page_checksum_set(ogg_page *og); | 244 | extern void ogg_page_checksum_set(ogg_page *og); |
234 | |||
235 | extern int ogg_page_version(ogg_page *og); | ||
236 | extern int ogg_page_continued(ogg_page *og); | ||
237 | extern int ogg_page_bos(ogg_page *og); | ||
238 | extern int ogg_page_eos(ogg_page *og); | ||
239 | extern ogg_int64_t ogg_page_granulepos(ogg_page *og); | ||
240 | extern ogg_uint32_t ogg_page_serialno(ogg_page *og); | ||
241 | extern ogg_uint32_t ogg_page_pageno(ogg_page *og); | ||
242 | extern int ogg_page_getbuffer(ogg_page *og, unsigned char **buffer); | ||
243 | |||
244 | extern int ogg_packet_release(ogg_packet *op); | ||
245 | extern int ogg_page_release(ogg_page *og); | ||
246 | |||
247 | extern void ogg_page_dup(ogg_page *d, ogg_page *s); | ||
248 | |||
249 | /* Ogg BITSTREAM PRIMITIVES: return codes ***************************/ | ||
250 | 245 | ||
251 | #define OGG_SUCCESS 0 | 246 | extern int ogg_page_version(const ogg_page *og); |
247 | extern int ogg_page_continued(const ogg_page *og); | ||
248 | extern int ogg_page_bos(const ogg_page *og); | ||
249 | extern int ogg_page_eos(const ogg_page *og); | ||
250 | extern ogg_int64_t ogg_page_granulepos(const ogg_page *og); | ||
251 | extern ogg_uint32_t ogg_page_serialno(const ogg_page *og); | ||
252 | extern long ogg_page_pageno(const ogg_page *og); | ||
253 | extern int ogg_page_packets(const ogg_page *og); | ||
252 | 254 | ||
253 | #define OGG_HOLE -10 | 255 | extern void ogg_packet_clear(ogg_packet *op); |
254 | #define OGG_SPAN -11 | ||
255 | #define OGG_EVERSION -12 | ||
256 | #define OGG_ESERIAL -13 | ||
257 | #define OGG_EINVAL -14 | ||
258 | #define OGG_EEOS -15 | ||
259 | 256 | ||
260 | 257 | ||
261 | #ifdef __cplusplus | 258 | #ifdef __cplusplus |