f188489678097daff7ed84401546266f907fa002
[libopusenc.git] / src / ogg_packer.c
1 /* Copyright (c) 2017 Jean-Marc Valin */
2 /*
3    Redistribution and use in source and binary forms, with or without
4    modification, are permitted provided that the following conditions
5    are met:
6
7    - Redistributions of source code must retain the above copyright
8    notice, this list of conditions and the following disclaimer.
9
10    - Redistributions in binary form must reproduce the above copyright
11    notice, this list of conditions and the following disclaimer in the
12    documentation and/or other materials provided with the distribution.
13
14    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
15    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
16    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
18    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
22    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
23    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include <stdlib.h>
28 #include <string.h>
29 #include <assert.h>
30
31 #include "ogg_packer.h"
32
33 #define MAX_HEADER_SIZE (27+255)
34
35 #define MAX_PAGE_SIZE (255*255 + MAX_HEADER_SIZE)
36
37 static const oggp_uint32 crc_lookup[256]={
38   0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
39   0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
40   0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
41   0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
42   0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
43   0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
44   0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
45   0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
46   0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
47   0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
48   0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
49   0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
50   0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
51   0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
52   0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
53   0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
54   0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
55   0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
56   0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
57   0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
58   0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
59   0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
60   0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
61   0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
62   0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
63   0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
64   0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
65   0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
66   0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
67   0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
68   0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
69   0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
70   0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
71   0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
72   0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
73   0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
74   0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
75   0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
76   0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
77   0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
78   0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
79   0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
80   0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
81   0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
82   0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
83   0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
84   0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
85   0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
86   0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
87   0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
88   0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
89   0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
90   0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
91   0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
92   0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
93   0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
94   0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
95   0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
96   0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
97   0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
98   0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
99   0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
100   0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
101   0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
102
103 static void ogg_page_checksum_set(unsigned char *page, int len){
104   oggp_uint32 crc_reg=0;
105   int i;
106
107   /* safety; needed for API behavior, but not framing code */
108   page[22]=0;
109   page[23]=0;
110   page[24]=0;
111   page[25]=0;
112
113   for(i=0;i<len;i++) crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^page[i]];
114
115   page[22]=(unsigned char)(crc_reg&0xff);
116   page[23]=(unsigned char)((crc_reg>>8)&0xff);
117   page[24]=(unsigned char)((crc_reg>>16)&0xff);
118   page[25]=(unsigned char)((crc_reg>>24)&0xff);
119 }
120
121 typedef struct {
122   oggp_uint64 granulepos;
123   int buf_pos;
124   int buf_size;
125   int lacing_pos;
126   int lacing_size;
127   int flags;
128   int pageno;
129 } oggp_page;
130
131 struct oggpacker {
132   int serialno;
133   unsigned char *buf;
134   unsigned char *alloc_buf;
135   unsigned char *user_buf;
136   int buf_size;
137   int buf_fill;
138   int buf_begin;
139   unsigned char *lacing;
140   int lacing_size;
141   int lacing_fill;
142   int lacing_begin;
143   oggp_page *pages;
144   int pages_size;
145   int pages_fill;
146   oggp_uint64 muxing_delay;
147   int is_eos;
148   oggp_uint64 curr_granule;
149   oggp_uint64 last_granule;
150   int pageno;
151 };
152
153 /** Allocates an oggpacker object */
154 oggpacker *oggp_create(int serialno) {
155   oggpacker *oggp;
156   oggp = malloc(sizeof(*oggp));
157   if (oggp == NULL) goto fail;
158   oggp->alloc_buf = NULL;
159   oggp->lacing = NULL;
160   oggp->pages = NULL;
161   oggp->user_buf = NULL;
162
163   oggp->buf_size = MAX_PAGE_SIZE;
164   oggp->lacing_size = 256;
165   oggp->pages_size = 10;
166
167   oggp->alloc_buf = malloc(oggp->buf_size + MAX_HEADER_SIZE);
168   oggp->lacing = malloc(oggp->lacing_size);
169   oggp->pages = malloc(oggp->pages_size * sizeof(oggp->pages[0]));
170   if (!oggp->alloc_buf || !oggp->lacing || !oggp->pages) goto fail;
171   oggp->buf = oggp->alloc_buf + MAX_HEADER_SIZE;
172
173   oggp->serialno = serialno;
174   oggp->buf_fill = 0;
175   oggp->buf_begin = 0;
176   oggp->lacing_fill = 0;
177   oggp->lacing_begin = 0;
178   oggp->pages_fill = 0;
179
180   oggp->is_eos = 0;
181   oggp->curr_granule = 0;
182   oggp->last_granule = 0;
183   oggp->pageno = 0;
184   oggp->muxing_delay = 0;
185   return oggp;
186 fail:
187   if (oggp) {
188     if (oggp->lacing) free(oggp->lacing);
189     if (oggp->alloc_buf) free(oggp->alloc_buf);
190     if (oggp->pages) free(oggp->pages);
191     free(oggp);
192   }
193   return NULL;
194 }
195
196 /** Frees memory associated with an oggpacker object */
197 void oggp_destroy(oggpacker *oggp) {
198   free(oggp->lacing);
199   free(oggp->alloc_buf);
200   free(oggp->pages);
201   free(oggp);
202 }
203
204 /** Sets the maximum muxing delay in granulepos units. Pages will be auto-flushed
205     to enforce the delay and to avoid continued pages if possible. */
206 void oggp_set_muxing_delay(oggpacker *oggp, oggp_uint64 delay) {
207   oggp->muxing_delay = delay;
208 }
209
210 /** Get a buffer where to write the next packet. The buffer will have
211     size "bytes", but fewer bytes can be written. The buffer remains valid through
212     a call to oggp_close_page() or oggp_get_next_page(), but is invalidated by
213     another call to oggp_get_packet_buffer() or by a call to oggp_commit_packet(). */
214 unsigned char *oggp_get_packet_buffer(oggpacker *oggp, int bytes) {
215   if (oggp->buf_fill + bytes > oggp->buf_size) {
216     /* FIXME: Check if it's worth shifting the buffer. */
217
218     /* If we didn't shift the buffer or if we did and there's still not enough room, make some more. */
219     if (oggp->buf_fill + bytes > oggp->buf_size) {
220       int newsize;
221       unsigned char *newbuf;
222       newsize = oggp->buf_fill + bytes + MAX_HEADER_SIZE;
223       newbuf = realloc(oggp->alloc_buf, oggp->buf_fill + bytes + MAX_HEADER_SIZE);
224       if (newbuf != NULL) {
225         oggp->alloc_buf = newbuf;
226         oggp->buf_size = newsize;
227         oggp->buf = oggp->alloc_buf + MAX_HEADER_SIZE;
228       } else {
229         return NULL;
230       }
231     }
232   }
233   oggp->user_buf = &oggp->buf[oggp->buf_fill];
234   return oggp->user_buf;
235 }
236
237 /** Tells the oggpacker that the packet buffer obtained from
238     oggp_get_packet_buffer() has been filled and the number of bytes written
239     has to be no more than what was originally asked for. */
240 int oggp_commit_packet(oggpacker *oggp, int bytes, oggp_uint64 granulepos, int eos) {
241   int i;
242   int nb_255s;
243   assert(oggp->user_buf != NULL);
244   oggp->buf_fill += bytes;
245   nb_255s = bytes/255;
246   if (oggp->lacing_fill-oggp->lacing_begin+nb_255s+1 > 255 ||
247       (oggp->muxing_delay && granulepos - oggp->last_granule > oggp->muxing_delay)) {
248     oggp_flush_page(oggp);
249   }
250   assert(oggp->user_buf >= &oggp->buf[oggp->buf_fill]);
251   /* If we moved the buffer data, update the incoming packet location. */
252   if (oggp->user_buf > &oggp->buf[oggp->buf_fill]) {
253     memmove(&oggp->buf[oggp->buf_fill], oggp->user_buf, bytes);
254   }
255   for (i=0;i<nb_255s;i++) {
256     oggp->lacing[oggp->lacing_fill+i] = 255;
257   }
258   oggp->lacing[oggp->lacing_fill+nb_255s] = bytes - 255*nb_255s;
259   oggp->curr_granule = granulepos;
260   oggp->is_eos = eos;
261   if (oggp->muxing_delay && granulepos - oggp->last_granule >= oggp->muxing_delay) {
262     oggp_flush_page(oggp);
263   }
264   return 0;
265 }
266
267 /** Create a page from the data written so far (and not yet part of a previous page).
268     If there is too much data for one page, all page continuations will be closed too. */
269 int oggp_flush_page(oggpacker *oggp) {
270   oggp_page *p;
271   /* FIXME: Check we have a free page. */
272   /* FIXME: Check there is at least one packet. */
273   p = &oggp->pages[oggp->pages_fill++];
274   p->granulepos = oggp->curr_granule;
275
276   p->buf_pos = oggp->buf_begin;
277   p->buf_size = oggp->buf_fill - oggp->buf_begin;
278   p->lacing_pos = oggp->lacing_begin;
279   p->lacing_size = oggp->lacing_fill - oggp->lacing_begin;
280   p->pageno = oggp->pageno;
281   /* FIXME: Handle bos/eos and continued pages. */
282   p->flags = 0;
283
284   oggp->buf_begin = oggp->buf_fill;
285   oggp->lacing_begin = oggp->lacing_fill;
286   oggp->pageno++;
287   oggp->last_granule = oggp->curr_granule;
288   return 0;
289 }
290
291 /** Get a pointer to the contents of the next available page. Pointer is
292     invalidated on the next call to oggp_get_next_page(). */
293 int oggp_get_next_page(oggpacker *oggp, unsigned char **page, int *bytes) {
294   oggp_page *p;
295   int i;
296   unsigned char *ptr;
297   int len;
298   int header_size;
299   oggp_uint64 granule_pos;
300   p = &oggp->pages[0];
301   header_size = 27 + p->lacing_size;
302   ptr = &oggp->buf[p->buf_pos - header_size];
303   len = p->buf_size + header_size;
304   memcpy(&ptr[27], &oggp->lacing[p->lacing_pos], p->lacing_size);
305   memcpy(ptr, "OggS", 4);
306
307   /* stream structure version */
308   ptr[4]=0x00;
309
310   /* FIXME: handle eos/continuation */
311   ptr[5]=0x00;
312   if (p->pageno == 0) ptr[5] |= 0x02;
313
314   granule_pos = p->granulepos;
315   /* 64 bits of PCM position */
316   for(i=6;i<14;i++){
317     ptr[i]=(unsigned char)(granule_pos&0xff);
318     granule_pos>>=8;
319   }
320
321   /* 32 bits of stream serial number */
322   {
323     long serialno=oggp->serialno;
324     for(i=14;i<18;i++){
325       ptr[i]=(unsigned char)(serialno&0xff);
326       serialno>>=8;
327     }
328   }
329
330   {
331     long pageno=p->pageno;
332     for(i=18;i<22;i++){
333       ptr[i]=(unsigned char)(pageno&0xff);
334       pageno>>=8;
335     }
336   }
337
338   ptr[26] = p->lacing_size;
339
340   /* CRC is always last. */
341   ogg_page_checksum_set(ptr, len);
342
343   *page = ptr;
344   *bytes = len;
345   oggp->pages_fill--;
346   memmove(&oggp->pages[0], &oggp->pages[1], oggp->pages_fill);
347   return 0;
348 }
349
350 /** Creates a new (chained) stream. This closes all outstanding pages. These
351     pages remain available with oggp_get_next_page(). */
352 int oggp_chain(oggpacker *oggp, int serialno) {
353   oggp_flush_page(oggp);
354   oggp->serialno = serialno;
355   oggp->curr_granule = 0;
356   oggp->last_granule = 0;
357   oggp->is_eos = 0;
358   oggp->pageno = 0;
359   return 0;
360 }