src/libFLAC/format.c

   1 /* libFLAC - Free Lossless Audio Codec library
   2  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008,2009  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 <stdio.h>
  37 #include <stdlib.h> /* for qsort() */
  38 #include <string.h> /* for memset() */
  39 #include "FLAC/assert.h"
  40 #include "FLAC/format.h"
  41 #include "private/format.h"
  42
  43 #ifdef min
  44 #undef min
  45 #endif
  46 #define min(a,b) ((a)<(b)?(a):(b))
  47
  48 /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
  49 #ifdef _MSC_VER
  50 #define FLAC__U64L(x) x
  51 #else
  52 #define FLAC__U64L(x) x##LLU
  53 #endif
  54
  55 /* VERSION should come from configure */
  56 FLAC_API const char *FLAC__VERSION_STRING = VERSION;
  57
  58 #if defined _MSC_VER || defined __BORLANDC__ || defined __MINW32__
  59 /* yet one more hack because of MSVC6: */
  60 FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC 1.2.1 20070917";
  61 #else
  62 FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC " VERSION " 20070917";
  63 #endif
  64
  65 FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4] = { 'f','L','a','C' };
  66 FLAC_API const unsigned FLAC__STREAM_SYNC = 0x664C6143;
  67 FLAC_API const unsigned FLAC__STREAM_SYNC_LEN = 32; /* bits */
  68
  69 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN = 16; /* bits */
  70 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN = 16; /* bits */
  71 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN = 24; /* bits */
  72 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN = 24; /* bits */
  73 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN = 20; /* bits */
  74 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN = 3; /* bits */
  75 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN = 5; /* bits */
  76 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN = 36; /* bits */
  77 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN = 128; /* bits */
  78
  79 FLAC_API const unsigned FLAC__STREAM_METADATA_APPLICATION_ID_LEN = 32; /* bits */
  80
  81 FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN = 64; /* bits */
  82 FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN = 64; /* bits */
  83 FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN = 16; /* bits */
  84
  85 FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = FLAC__U64L(0xffffffffffffffff);
  86
  87 FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN = 32; /* bits */
  88 FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN = 32; /* bits */
  89
  90 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN = 64; /* bits */
  91 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN = 8; /* bits */
  92 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN = 3*8; /* bits */
  93
  94 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN = 64; /* bits */
  95 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN = 8; /* bits */
  96 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN = 12*8; /* bits */
  97 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN = 1; /* bit */
  98 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN = 1; /* bit */
  99 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN = 6+13*8; /* bits */
 100 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN = 8; /* bits */
 101
 102 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN = 128*8; /* bits */
 103 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN = 64; /* bits */
 104 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN = 1; /* bit */
 105 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN = 7+258*8; /* bits */
 106 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN = 8; /* bits */
 107
 108 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_TYPE_LEN = 32; /* bits */
 109 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN = 32; /* bits */
 110 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN = 32; /* bits */
 111 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN = 32; /* bits */
 112 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN = 32; /* bits */
 113 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN = 32; /* bits */
 114 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_COLORS_LEN = 32; /* bits */
 115 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN = 32; /* bits */
 116
 117 FLAC_API const unsigned FLAC__STREAM_METADATA_IS_LAST_LEN = 1; /* bits */
 118 FLAC_API const unsigned FLAC__STREAM_METADATA_TYPE_LEN = 7; /* bits */
 119 FLAC_API const unsigned FLAC__STREAM_METADATA_LENGTH_LEN = 24; /* bits */
 120
 121 FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC = 0x3ffe;
 122 FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC_LEN = 14; /* bits */
 123 FLAC_API const unsigned FLAC__FRAME_HEADER_RESERVED_LEN = 1; /* bits */
 124 FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN = 1; /* bits */
 125 FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCK_SIZE_LEN = 4; /* bits */
 126 FLAC_API const unsigned FLAC__FRAME_HEADER_SAMPLE_RATE_LEN = 4; /* bits */
 127 FLAC_API const unsigned FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN = 4; /* bits */
 128 FLAC_API const unsigned FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN = 3; /* bits */
 129 FLAC_API const unsigned FLAC__FRAME_HEADER_ZERO_PAD_LEN = 1; /* bits */
 130 FLAC_API const unsigned FLAC__FRAME_HEADER_CRC_LEN = 8; /* bits */
 131
 132 FLAC_API const unsigned FLAC__FRAME_FOOTER_CRC_LEN = 16; /* bits */
 133
 134 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_TYPE_LEN = 2; /* bits */
 135 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN = 4; /* bits */
 136 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN = 4; /* bits */
 137 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN = 5; /* bits */
 138 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN = 5; /* bits */
 139
 140 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER = 15; /* == (1<<FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN)-1 */
 141 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER = 31; /* == (1<<FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN)-1 */
 142
 143 FLAC_API const char * const FLAC__EntropyCodingMethodTypeString[] = {
 144         "PARTITIONED_RICE",
 145         "PARTITIONED_RICE2"
 146 };
 147
 148 FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN = 4; /* bits */
 149 FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN = 5; /* bits */
 150
 151 FLAC_API const unsigned FLAC__SUBFRAME_ZERO_PAD_LEN = 1; /* bits */
 152 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LEN = 6; /* bits */
 153 FLAC_API const unsigned FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN = 1; /* bits */
 154
 155 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK = 0x00;
 156 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK = 0x02;
 157 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK = 0x10;
 158 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK = 0x40;
 159
 160 FLAC_API const char * const FLAC__SubframeTypeString[] = {
 161         "CONSTANT",
 162         "VERBATIM",
 163         "FIXED",
 164         "LPC"
 165 };
 166
 167 FLAC_API const char * const FLAC__ChannelAssignmentString[] = {
 168         "INDEPENDENT",
 169         "LEFT_SIDE",
 170         "RIGHT_SIDE",
 171         "MID_SIDE"
 172 };
 173
 174 FLAC_API const char * const FLAC__FrameNumberTypeString[] = {
 175         "FRAME_NUMBER_TYPE_FRAME_NUMBER",
 176         "FRAME_NUMBER_TYPE_SAMPLE_NUMBER"
 177 };
 178
 179 FLAC_API const char * const FLAC__MetadataTypeString[] = {
 180         "STREAMINFO",
 181         "PADDING",
 182         "APPLICATION",
 183         "SEEKTABLE",
 184         "VORBIS_COMMENT",
 185         "CUESHEET",
 186         "PICTURE"
 187 };
 188
 189 FLAC_API const char * const FLAC__StreamMetadata_Picture_TypeString[] = {
 190         "Other",
 191         "32x32 pixels 'file icon' (PNG only)",
 192         "Other file icon",
 193         "Cover (front)",
 194         "Cover (back)",
 195         "Leaflet page",
 196         "Media (e.g. label side of CD)",
 197         "Lead artist/lead performer/soloist",
 198         "Artist/performer",
 199         "Conductor",
 200         "Band/Orchestra",
 201         "Composer",
 202         "Lyricist/text writer",
 203         "Recording Location",
 204         "During recording",
 205         "During performance",
 206         "Movie/video screen capture",
 207         "A bright coloured fish",
 208         "Illustration",
 209         "Band/artist logotype",
 210         "Publisher/Studio logotype"
 211 };
 212
 213 FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(unsigned sample_rate)
 214 {
 215         if(sample_rate == 0 || sample_rate > FLAC__MAX_SAMPLE_RATE) {
 216                 return false;
 217         }
 218         else
 219                 return true;
 220 }
 221
 222 FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(unsigned blocksize, unsigned sample_rate)
 223 {
 224         if(blocksize > 16384)
 225                 return false;
 226         else if(sample_rate <= 48000 && blocksize > 4608)
 227                 return false;
 228         else
 229                 return true;
 230 }
 231
 232 FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(unsigned sample_rate)
 233 {
 234         if(
 235                 !FLAC__format_sample_rate_is_valid(sample_rate) ||
 236                 (
 237                         sample_rate >= (1u << 16) &&
 238                         !(sample_rate % 1000 == 0 || sample_rate % 10 == 0)
 239                 )
 240         ) {
 241                 return false;
 242         }
 243         else
 244                 return true;
 245 }
 246
 247 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
 248 FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_SeekTable *seek_table)
 249 {
 250         unsigned i;
 251         FLAC__uint64 prev_sample_number = 0;
 252         FLAC__bool got_prev = false;
 253
 254         FLAC__ASSERT(0 != seek_table);
 255
 256         for(i = 0; i < seek_table->num_points; i++) {
 257                 if(got_prev) {
 258                         if(
 259                                 seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER &&
 260                                 seek_table->points[i].sample_number <= prev_sample_number
 261                         )
 262                                 return false;
 263                 }
 264                 prev_sample_number = seek_table->points[i].sample_number;
 265                 got_prev = true;
 266         }
 267
 268         return true;
 269 }
 270
 271 /* used as the sort predicate for qsort() */
 272 static int seekpoint_compare_(const FLAC__StreamMetadata_SeekPoint *l, const FLAC__StreamMetadata_SeekPoint *r)
 273 {
 274         /* we don't just 'return l->sample_number - r->sample_number' since the result (FLAC__int64) might overflow an 'int' */
 275         if(l->sample_number == r->sample_number)
 276                 return 0;
 277         else if(l->sample_number < r->sample_number)
 278                 return -1;
 279         else
 280                 return 1;
 281 }
 282
 283 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
 284 FLAC_API unsigned FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table)
 285 {
 286         unsigned i, j;
 287         FLAC__bool first;
 288
 289         FLAC__ASSERT(0 != seek_table);
 290
 291         /* sort the seekpoints */
 292         qsort(seek_table->points, seek_table->num_points, sizeof(FLAC__StreamMetadata_SeekPoint), (int (*)(const void *, const void *))seekpoint_compare_);
 293
 294         /* uniquify the seekpoints */
 295         first = true;
 296         for(i = j = 0; i < seek_table->num_points; i++) {
 297                 if(seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER) {
 298                         if(!first) {
 299                                 if(seek_table->points[i].sample_number == seek_table->points[j-1].sample_number)
 300                                         continue;
 301                         }
 302                 }
 303                 first = false;
 304                 seek_table->points[j++] = seek_table->points[i];
 305         }
 306
 307         for(i = j; i < seek_table->num_points; i++) {
 308                 seek_table->points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 309                 seek_table->points[i].stream_offset = 0;
 310                 seek_table->points[i].frame_samples = 0;
 311         }
 312
 313         return j;
 314 }
 315
 316 /*
 317  * also disallows non-shortest-form encodings, c.f.
 318  *   http://www.unicode.org/versions/corrigendum1.html
 319  * and a more clear explanation at the end of this section:
 320  *   http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
 321  */
 322 static unsigned utf8len_(const FLAC__byte *utf8)
 323 {
 324         FLAC__ASSERT(0 != utf8);
 325         if ((utf8[0] & 0x80) == 0) {
 326                 return 1;
 327         }
 328         else if ((utf8[0] & 0xE0) == 0xC0 && (utf8[1] & 0xC0) == 0x80) {
 329                 if ((utf8[0] & 0xFE) == 0xC0) /* overlong sequence check */
 330                         return 0;
 331                 return 2;
 332         }
 333         else if ((utf8[0] & 0xF0) == 0xE0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80) {
 334                 if (utf8[0] == 0xE0 && (utf8[1] & 0xE0) == 0x80) /* overlong sequence check */
 335                         return 0;
 336                 /* illegal surrogates check (U+D800...U+DFFF and U+FFFE...U+FFFF) */
 337                 if (utf8[0] == 0xED && (utf8[1] & 0xE0) == 0xA0) /* D800-DFFF */
 338                         return 0;
 339                 if (utf8[0] == 0xEF && utf8[1] == 0xBF && (utf8[2] & 0xFE) == 0xBE) /* FFFE-FFFF */
 340                         return 0;
 341                 return 3;
 342         }
 343         else if ((utf8[0] & 0xF8) == 0xF0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80) {
 344                 if (utf8[0] == 0xF0 && (utf8[1] & 0xF0) == 0x80) /* overlong sequence check */
 345                         return 0;
 346                 return 4;
 347         }
 348         else if ((utf8[0] & 0xFC) == 0xF8 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80 && (utf8[4] & 0xC0) == 0x80) {
 349                 if (utf8[0] == 0xF8 && (utf8[1] & 0xF8) == 0x80) /* overlong sequence check */
 350                         return 0;
 351                 return 5;
 352         }
 353         else if ((utf8[0] & 0xFE) == 0xFC && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80 && (utf8[4] & 0xC0) == 0x80 && (utf8[5] & 0xC0) == 0x80) {
 354                 if (utf8[0] == 0xFC && (utf8[1] & 0xFC) == 0x80) /* overlong sequence check */
 355                         return 0;
 356                 return 6;
 357         }
 358         else {
 359                 return 0;
 360         }
 361 }
 362
 363 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name)
 364 {
 365         char c;
 366         for(c = *name; c; c = *(++name))
 367                 if(c < 0x20 || c == 0x3d || c > 0x7d)
 368                         return false;
 369         return true;
 370 }
 371
 372 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, unsigned length)
 373 {
 374         if(length == (unsigned)(-1)) {
 375                 while(*value) {
 376                         unsigned n = utf8len_(value);
 377                         if(n == 0)
 378                                 return false;
 379                         value += n;
 380                 }
 381         }
 382         else {
 383                 const FLAC__byte *end = value + length;
 384                 while(value < end) {
 385                         unsigned n = utf8len_(value);
 386                         if(n == 0)
 387                                 return false;
 388                         value += n;
 389                 }
 390                 if(value != end)
 391                         return false;
 392         }
 393         return true;
 394 }
 395
 396 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, unsigned length)
 397 {
 398         const FLAC__byte *s, *end;
 399
 400         for(s = entry, end = s + length; s < end && *s != '='; s++) {
 401                 if(*s < 0x20 || *s > 0x7D)
 402                         return false;
 403         }
 404         if(s == end)
 405                 return false;
 406
 407         s++; /* skip '=' */
 408
 409         while(s < end) {
 410                 unsigned n = utf8len_(s);
 411                 if(n == 0)
 412                         return false;
 413                 s += n;
 414         }
 415         if(s != end)
 416                 return false;
 417
 418         return true;
 419 }
 420
 421 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
 422 FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation)
 423 {
 424         unsigned i, j;
 425
 426         if(check_cd_da_subset) {
 427                 if(cue_sheet->lead_in < 2 * 44100) {
 428                         if(violation) *violation = "CD-DA cue sheet must have a lead-in length of at least 2 seconds";
 429                         return false;
 430                 }
 431                 if(cue_sheet->lead_in % 588 != 0) {
 432                         if(violation) *violation = "CD-DA cue sheet lead-in length must be evenly divisible by 588 samples";
 433                         return false;
 434                 }
 435         }
 436
 437         if(cue_sheet->num_tracks == 0) {
 438                 if(violation) *violation = "cue sheet must have at least one track (the lead-out)";
 439                 return false;
 440         }
 441
 442         if(check_cd_da_subset && cue_sheet->tracks[cue_sheet->num_tracks-1].number != 170) {
 443                 if(violation) *violation = "CD-DA cue sheet must have a lead-out track number 170 (0xAA)";
 444                 return false;
 445         }
 446
 447         for(i = 0; i < cue_sheet->num_tracks; i++) {
 448                 if(cue_sheet->tracks[i].number == 0) {
 449                         if(violation) *violation = "cue sheet may not have a track number 0";
 450                         return false;
 451                 }
 452
 453                 if(check_cd_da_subset) {
 454                         if(!((cue_sheet->tracks[i].number >= 1 && cue_sheet->tracks[i].number <= 99) || cue_sheet->tracks[i].number == 170)) {
 455                                 if(violation) *violation = "CD-DA cue sheet track number must be 1-99 or 170";
 456                                 return false;
 457                         }
 458                 }
 459
 460                 if(check_cd_da_subset && cue_sheet->tracks[i].offset % 588 != 0) {
 461                         if(violation) {
 462                                 if(i == cue_sheet->num_tracks-1) /* the lead-out track... */
 463                                         *violation = "CD-DA cue sheet lead-out offset must be evenly divisible by 588 samples";
 464                                 else
 465                                         *violation = "CD-DA cue sheet track offset must be evenly divisible by 588 samples";
 466                         }
 467                         return false;
 468                 }
 469
 470                 if(i < cue_sheet->num_tracks - 1) {
 471                         if(cue_sheet->tracks[i].num_indices == 0) {
 472                                 if(violation) *violation = "cue sheet track must have at least one index point";
 473                                 return false;
 474                         }
 475
 476                         if(cue_sheet->tracks[i].indices[0].number > 1) {
 477                                 if(violation) *violation = "cue sheet track's first index number must be 0 or 1";
 478                                 return false;
 479                         }
 480                 }
 481
 482                 for(j = 0; j < cue_sheet->tracks[i].num_indices; j++) {
 483                         if(check_cd_da_subset && cue_sheet->tracks[i].indices[j].offset % 588 != 0) {
 484                                 if(violation) *violation = "CD-DA cue sheet track index offset must be evenly divisible by 588 samples";
 485                                 return false;
 486                         }
 487
 488                         if(j > 0) {
 489                                 if(cue_sheet->tracks[i].indices[j].number != cue_sheet->tracks[i].indices[j-1].number + 1) {
 490                                         if(violation) *violation = "cue sheet track index numbers must increase by 1";
 491                                         return false;
 492                                 }
 493                         }
 494                 }
 495         }
 496
 497         return true;
 498 }
 499
 500 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
 501 FLAC_API FLAC__bool FLAC__format_picture_is_legal(const FLAC__StreamMetadata_Picture *picture, const char **violation)
 502 {
 503         char *p;
 504         FLAC__byte *b;
 505
 506         for(p = picture->mime_type; *p; p++) {
 507                 if(*p < 0x20 || *p > 0x7e) {
 508                         if(violation) *violation = "MIME type string must contain only printable ASCII characters (0x20-0x7e)";
 509                         return false;
 510                 }
 511         }
 512
 513         for(b = picture->description; *b; ) {
 514                 unsigned n = utf8len_(b);
 515                 if(n == 0) {
 516                         if(violation) *violation = "description string must be valid UTF-8";
 517                         return false;
 518                 }
 519                 b += n;
 520         }
 521
 522         return true;
 523 }
 524
 525 /*
 526  * These routines are private to libFLAC
 527  */
 528 unsigned FLAC__format_get_max_rice_partition_order(unsigned blocksize, unsigned predictor_order)
 529 {
 530         return
 531                 FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(
 532                         FLAC__format_get_max_rice_partition_order_from_blocksize(blocksize),
 533                         blocksize,
 534                         predictor_order
 535                 );
 536 }
 537
 538 unsigned FLAC__format_get_max_rice_partition_order_from_blocksize(unsigned blocksize)
 539 {
 540         unsigned max_rice_partition_order = 0;
 541         while(!(blocksize & 1)) {
 542                 max_rice_partition_order++;
 543                 blocksize >>= 1;
 544         }
 545         return min(FLAC__MAX_RICE_PARTITION_ORDER, max_rice_partition_order);
 546 }
 547
 548 unsigned FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(unsigned limit, unsigned blocksize, unsigned predictor_order)
 549 {
 550         unsigned max_rice_partition_order = limit;
 551
 552         while(max_rice_partition_order > 0 && (blocksize >> max_rice_partition_order) <= predictor_order)
 553                 max_rice_partition_order--;
 554
 555         FLAC__ASSERT(
 556                 (max_rice_partition_order == 0 && blocksize >= predictor_order) ||
 557                 (max_rice_partition_order > 0 && blocksize >> max_rice_partition_order > predictor_order)
 558         );
 559
 560         return max_rice_partition_order;
 561 }
 562
 563 void FLAC__format_entropy_coding_method_partitioned_rice_contents_init(FLAC__EntropyCodingMethod_PartitionedRiceContents *object)
 564 {
 565         FLAC__ASSERT(0 != object);
 566
 567         object->parameters = 0;
 568         object->raw_bits = 0;
 569         object->capacity_by_order = 0;
 570 }
 571
 572 void FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(FLAC__EntropyCodingMethod_PartitionedRiceContents *object)
 573 {
 574         FLAC__ASSERT(0 != object);
 575
 576         if(0 != object->parameters)
 577                 free(object->parameters);
 578         if(0 != object->raw_bits)
 579                 free(object->raw_bits);
 580         FLAC__format_entropy_coding_method_partitioned_rice_contents_init(object);
 581 }
 582
 583 FLAC__bool FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(FLAC__EntropyCodingMethod_PartitionedRiceContents *object, unsigned max_partition_order)
 584 {
 585         FLAC__ASSERT(0 != object);
 586
 587         FLAC__ASSERT(object->capacity_by_order > 0 || (0 == object->parameters && 0 == object->raw_bits));
 588
 589         if(object->capacity_by_order < max_partition_order) {
 590                 if(0 == (object->parameters = (unsigned*)realloc(object->parameters, sizeof(unsigned)*(1 << max_partition_order))))
 591                         return false;
 592                 if(0 == (object->raw_bits = (unsigned*)realloc(object->raw_bits, sizeof(unsigned)*(1 << max_partition_order))))
 593                         return false;
 594                 memset(object->raw_bits, 0, sizeof(unsigned)*(1 << max_partition_order));
 595                 object->capacity_by_order = max_partition_order;
 596         }
 597
 598         return true;
 599 }