src/lib/dl/ext/flac/ogg_decoder_aspect.c

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