src/libFLAC/format.c

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