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