lacing resize
[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, newsize);
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 (oggp->lacing_fill + nb_255s + 1 > oggp->lacing_size) {
252     /* FIXME: Check if it's worth shifting the lacing values. */
253
254     /* If we didn't shift the values or if we did and there's still not enough room, make some more. */
255     if (oggp->lacing_fill + nb_255s + 1 > oggp->lacing_size) {
256       int newsize;
257       unsigned char *newbuf;
258       newsize = oggp->lacing_fill + nb_255s + 1;
259       newbuf = realloc(oggp->lacing, newsize);
260       if (newbuf != NULL) {
261         oggp->lacing = newbuf;
262         oggp->lacing_size = newsize;
263       } else {
264         return 1;
265       }
266     }
267   }
268   /* If we moved the buffer data, update the incoming packet location. */
269   if (oggp->user_buf > &oggp->buf[oggp->buf_fill]) {
270     memmove(&oggp->buf[oggp->buf_fill], oggp->user_buf, bytes);
271   }
272   for (i=0;i<nb_255s;i++) {
273     oggp->lacing[oggp->lacing_fill+i] = 255;
274   }
275   oggp->lacing[oggp->lacing_fill+nb_255s] = bytes - 255*nb_255s;
276   oggp->curr_granule = granulepos;
277   oggp->is_eos = eos;
278   if (oggp->muxing_delay && granulepos - oggp->last_granule >= oggp->muxing_delay) {
279     oggp_flush_page(oggp);
280   }
281   return 0;
282 }
283
284 /** Create a page from the data written so far (and not yet part of a previous page).
285     If there is too much data for one page, all page continuations will be closed too. */
286 int oggp_flush_page(oggpacker *oggp) {
287   oggp_page *p;
288   /* FIXME: Check we have a free page. */
289   /* FIXME: Check there is at least one packet. */
290   p = &oggp->pages[oggp->pages_fill++];
291   p->granulepos = oggp->curr_granule;
292
293   p->buf_pos = oggp->buf_begin;
294   p->buf_size = oggp->buf_fill - oggp->buf_begin;
295   p->lacing_pos = oggp->lacing_begin;
296   p->lacing_size = oggp->lacing_fill - oggp->lacing_begin;
297   p->pageno = oggp->pageno;
298   /* FIXME: Handle bos/eos and continued pages. */
299   p->flags = 0;
300
301   oggp->buf_begin = oggp->buf_fill;
302   oggp->lacing_begin = oggp->lacing_fill;
303   oggp->pageno++;
304   oggp->last_granule = oggp->curr_granule;
305   return 0;
306 }
307
308 /** Get a pointer to the contents of the next available page. Pointer is
309     invalidated on the next call to oggp_get_next_page() or oggp_commit_packet(). */
310 int oggp_get_next_page(oggpacker *oggp, unsigned char **page, int *bytes) {
311   oggp_page *p;
312   int i;
313   unsigned char *ptr;
314   int len;
315   int header_size;
316   oggp_uint64 granule_pos;
317   p = &oggp->pages[0];
318   header_size = 27 + p->lacing_size;
319   ptr = &oggp->buf[p->buf_pos - header_size];
320   len = p->buf_size + header_size;
321   memcpy(&ptr[27], &oggp->lacing[p->lacing_pos], p->lacing_size);
322   memcpy(ptr, "OggS", 4);
323
324   /* stream structure version */
325   ptr[4]=0x00;
326
327   /* FIXME: handle eos/continuation */
328   ptr[5]=0x00;
329   if (p->pageno == 0) ptr[5] |= 0x02;
330
331   granule_pos = p->granulepos;
332   /* 64 bits of PCM position */
333   for(i=6;i<14;i++){
334     ptr[i]=(unsigned char)(granule_pos&0xff);
335     granule_pos>>=8;
336   }
337
338   /* 32 bits of stream serial number */
339   {
340     long serialno=oggp->serialno;
341     for(i=14;i<18;i++){
342       ptr[i]=(unsigned char)(serialno&0xff);
343       serialno>>=8;
344     }
345   }
346
347   {
348     long pageno=p->pageno;
349     for(i=18;i<22;i++){
350       ptr[i]=(unsigned char)(pageno&0xff);
351       pageno>>=8;
352     }
353   }
354
355   ptr[26] = p->lacing_size;
356
357   /* CRC is always last. */
358   ogg_page_checksum_set(ptr, len);
359
360   *page = ptr;
361   *bytes = len;
362   oggp->pages_fill--;
363   memmove(&oggp->pages[0], &oggp->pages[1], oggp->pages_fill);
364   return 0;
365 }
366
367 /** Creates a new (chained) stream. This closes all outstanding pages. These
368     pages remain available with oggp_get_next_page(). */
369 int oggp_chain(oggpacker *oggp, int serialno) {
370   oggp_flush_page(oggp);
371   oggp->serialno = serialno;
372   oggp->curr_granule = 0;
373   oggp->last_granule = 0;
374   oggp->is_eos = 0;
375   oggp->pageno = 0;
376   return 0;
377 }