libFLAC/cpu.c: Get rid of OS_IS_ANDROID function
[flac.git] / src / libFLAC / ogg_decoder_aspect.c
1 /* libFLAC - Free Lossless Audio Codec
2  * Copyright (C) 2002-2009  Josh Coalson
3  * Copyright (C) 2011-2014  Xiph.Org Foundation
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * - Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * - Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * - Neither the name of the Xiph.org Foundation nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #ifdef HAVE_CONFIG_H
34 #  include <config.h>
35 #endif
36
37 #include <string.h> /* for memcpy() */
38 #include "FLAC/assert.h"
39 #include "private/ogg_decoder_aspect.h"
40 #include "private/ogg_mapping.h"
41 #include "private/macros.h"
42
43
44 /***********************************************************************
45  *
46  * Public class methods
47  *
48  ***********************************************************************/
49
50 FLAC__bool FLAC__ogg_decoder_aspect_init(FLAC__OggDecoderAspect *aspect)
51 {
52         /* we will determine the serial number later if necessary */
53         if(ogg_stream_init(&aspect->stream_state, aspect->serial_number) != 0)
54                 return false;
55
56         if(ogg_sync_init(&aspect->sync_state) != 0)
57                 return false;
58
59         aspect->version_major = ~(0u);
60         aspect->version_minor = ~(0u);
61
62         aspect->need_serial_number = aspect->use_first_serial_number;
63
64         aspect->end_of_stream = false;
65         aspect->have_working_page = false;
66
67         return true;
68 }
69
70 void FLAC__ogg_decoder_aspect_finish(FLAC__OggDecoderAspect *aspect)
71 {
72         (void)ogg_sync_clear(&aspect->sync_state);
73         (void)ogg_stream_clear(&aspect->stream_state);
74 }
75
76 void FLAC__ogg_decoder_aspect_set_serial_number(FLAC__OggDecoderAspect *aspect, long value)
77 {
78         aspect->use_first_serial_number = false;
79         aspect->serial_number = value;
80 }
81
82 void FLAC__ogg_decoder_aspect_set_defaults(FLAC__OggDecoderAspect *aspect)
83 {
84         aspect->use_first_serial_number = true;
85 }
86
87 void FLAC__ogg_decoder_aspect_flush(FLAC__OggDecoderAspect *aspect)
88 {
89         (void)ogg_stream_reset(&aspect->stream_state);
90         (void)ogg_sync_reset(&aspect->sync_state);
91         aspect->end_of_stream = false;
92         aspect->have_working_page = false;
93 }
94
95 void FLAC__ogg_decoder_aspect_reset(FLAC__OggDecoderAspect *aspect)
96 {
97         FLAC__ogg_decoder_aspect_flush(aspect);
98
99         if(aspect->use_first_serial_number)
100                 aspect->need_serial_number = true;
101 }
102
103 FLAC__OggDecoderAspectReadStatus FLAC__ogg_decoder_aspect_read_callback_wrapper(FLAC__OggDecoderAspect *aspect, FLAC__byte buffer[], size_t *bytes, FLAC__OggDecoderAspectReadCallbackProxy read_callback, const FLAC__StreamDecoder *decoder, void *client_data)
104 {
105         static const size_t OGG_BYTES_CHUNK = 8192;
106         const size_t bytes_requested = *bytes;
107
108         /*
109          * The FLAC decoding API uses pull-based reads, whereas Ogg decoding
110          * is push-based.  In libFLAC, when you ask to decode a frame, the
111          * decoder will eventually call the read callback to supply some data,
112          * but how much it asks for depends on how much free space it has in
113          * its internal buffer.  It does not try to grow its internal buffer
114          * to accomodate a whole frame because then the internal buffer size
115          * could not be limited, which is necessary in embedded applications.
116          *
117          * Ogg however grows its internal buffer until a whole page is present;
118          * only then can you get decoded data out.  So we can't just ask for
119          * the same number of bytes from Ogg, then pass what's decoded down to
120          * libFLAC.  If what libFLAC is asking for will not contain a whole
121          * page, then we will get no data from ogg_sync_pageout(), and at the
122          * same time cannot just read more data from the client for the purpose
123          * of getting a whole decoded page because the decoded size might be
124          * larger than libFLAC's internal buffer.
125          *
126          * Instead, whenever this read callback wrapper is called, we will
127          * continually request data from the client until we have at least one
128          * page, and manage pages internally so that we can send pieces of
129          * pages down to libFLAC in such a way that we obey its size
130          * requirement.  To limit the amount of callbacks, we will always try
131          * to read in enough pages to return the full number of bytes
132          * requested.
133          */
134         *bytes = 0;
135         while (*bytes < bytes_requested && !aspect->end_of_stream) {
136                 if (aspect->have_working_page) {
137                         if (aspect->have_working_packet) {
138                                 size_t n = bytes_requested - *bytes;
139                                 if ((size_t)aspect->working_packet.bytes <= n) {
140                                         /* the rest of the packet will fit in the buffer */
141                                         n = aspect->working_packet.bytes;
142                                         memcpy(buffer, aspect->working_packet.packet, n);
143                                         *bytes += n;
144                                         buffer += n;
145                                         aspect->have_working_packet = false;
146                                 }
147                                 else {
148                                         /* only n bytes of the packet will fit in the buffer */
149                                         memcpy(buffer, aspect->working_packet.packet, n);
150                                         *bytes += n;
151                                         buffer += n;
152                                         aspect->working_packet.packet += n;
153                                         aspect->working_packet.bytes -= n;
154                                 }
155                         }
156                         else {
157                                 /* try and get another packet */
158                                 const int ret = ogg_stream_packetout(&aspect->stream_state, &aspect->working_packet);
159                                 if (ret > 0) {
160                                         aspect->have_working_packet = true;
161                                         /* if it is the first header packet, check for magic and a supported Ogg FLAC mapping version */
162                                         if (aspect->working_packet.bytes > 0 && aspect->working_packet.packet[0] == FLAC__OGG_MAPPING_FIRST_HEADER_PACKET_TYPE) {
163                                                 const FLAC__byte *b = aspect->working_packet.packet;
164                                                 const unsigned header_length =
165                                                         FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH +
166                                                         FLAC__OGG_MAPPING_MAGIC_LENGTH +
167                                                         FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH +
168                                                         FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH +
169                                                         FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH;
170                                                 if (aspect->working_packet.bytes < (long)header_length)
171                                                         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_NOT_FLAC;
172                                                 b += FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH;
173                                                 if (memcmp(b, FLAC__OGG_MAPPING_MAGIC, FLAC__OGG_MAPPING_MAGIC_LENGTH))
174                                                         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_NOT_FLAC;
175                                                 b += FLAC__OGG_MAPPING_MAGIC_LENGTH;
176                                                 aspect->version_major = (unsigned)(*b);
177                                                 b += FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH;
178                                                 aspect->version_minor = (unsigned)(*b);
179                                                 if (aspect->version_major != 1)
180                                                         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_UNSUPPORTED_MAPPING_VERSION;
181                                                 aspect->working_packet.packet += header_length;
182                                                 aspect->working_packet.bytes -= header_length;
183                                         }
184                                 }
185                                 else if (ret == 0) {
186                                         aspect->have_working_page = false;
187                                 }
188                                 else { /* ret < 0 */
189                                         /* lost sync, we'll leave the working page for the next call */
190                                         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_LOST_SYNC;
191                                 }
192                         }
193                 }
194                 else {
195                         /* try and get another page */
196                         const int ret = ogg_sync_pageout(&aspect->sync_state, &aspect->working_page);
197                         if (ret > 0) {
198                                 /* got a page, grab the serial number if necessary */
199                                 if(aspect->need_serial_number) {
200                                         aspect->stream_state.serialno = aspect->serial_number = ogg_page_serialno(&aspect->working_page);
201                                         aspect->need_serial_number = false;
202                                 }
203                                 if(ogg_stream_pagein(&aspect->stream_state, &aspect->working_page) == 0) {
204                                         aspect->have_working_page = true;
205                                         aspect->have_working_packet = false;
206                                 }
207                                 /* else do nothing, could be a page from another stream */
208                         }
209                         else if (ret == 0) {
210                                 /* need more data */
211                                 const size_t ogg_bytes_to_read = flac_max(bytes_requested - *bytes, OGG_BYTES_CHUNK);
212                                 char *oggbuf = ogg_sync_buffer(&aspect->sync_state, ogg_bytes_to_read);
213
214                                 if(0 == oggbuf) {
215                                         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_MEMORY_ALLOCATION_ERROR;
216                                 }
217                                 else {
218                                         size_t ogg_bytes_read = ogg_bytes_to_read;
219
220                                         switch(read_callback(decoder, (FLAC__byte*)oggbuf, &ogg_bytes_read, client_data)) {
221                                                 case FLAC__OGG_DECODER_ASPECT_READ_STATUS_OK:
222                                                         break;
223                                                 case FLAC__OGG_DECODER_ASPECT_READ_STATUS_END_OF_STREAM:
224                                                         aspect->end_of_stream = true;
225                                                         break;
226                                                 case FLAC__OGG_DECODER_ASPECT_READ_STATUS_ABORT:
227                                                         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_ABORT;
228                                                 default:
229                                                         FLAC__ASSERT(0);
230                                         }
231
232                                         if(ogg_sync_wrote(&aspect->sync_state, ogg_bytes_read) < 0) {
233                                                 /* double protection; this will happen if the read callback returns more bytes than the max requested, which would overflow Ogg's internal buffer */
234                                                 FLAC__ASSERT(0);
235                                                 return FLAC__OGG_DECODER_ASPECT_READ_STATUS_ERROR;
236                                         }
237                                 }
238                         }
239                         else { /* ret < 0 */
240                                 /* lost sync, bail out */
241                                 return FLAC__OGG_DECODER_ASPECT_READ_STATUS_LOST_SYNC;
242                         }
243                 }
244         }
245
246         if (aspect->end_of_stream && *bytes == 0) {
247                 return FLAC__OGG_DECODER_ASPECT_READ_STATUS_END_OF_STREAM;
248         }
249
250         return FLAC__OGG_DECODER_ASPECT_READ_STATUS_OK;
251 }