src/libFLAC/format.c

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