1 /* libFLAC - Free Lossless Audio Codec library 2 * Copyright (C) 2000-2009 Josh Coalson 3 * Copyright (C) 2011-2014 Xiph.Org Foundation 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * - Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * - Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * - Neither the name of the Xiph.org Foundation nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR 24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 27 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 28 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 29 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #ifdef HAVE_CONFIG_H 34 # include <config.h> 35 #endif 36 37 #include <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/alloc.h" 43 #include "share/compat.h" 44 #include "private/format.h" 45 #include "private/macros.h" 46 47 /* VERSION should come from configure */ 48 FLAC_API const char *FLAC__VERSION_STRING = VERSION; 49 50 FLAC_API const char *FLAC__VENDOR_STRING = "reference libFLAC " VERSION " 20141125"; 51 52 FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4] = { 'f','L','a','C' }; 53 FLAC_API const unsigned FLAC__STREAM_SYNC = 0x664C6143; 54 FLAC_API const unsigned FLAC__STREAM_SYNC_LEN = 32; /* bits */ 55 56 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN = 16; /* bits */ 57 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN = 16; /* bits */ 58 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN = 24; /* bits */ 59 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN = 24; /* bits */ 60 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN = 20; /* bits */ 61 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN = 3; /* bits */ 62 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN = 5; /* bits */ 63 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN = 36; /* bits */ 64 FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN = 128; /* bits */ 65 66 FLAC_API const unsigned FLAC__STREAM_METADATA_APPLICATION_ID_LEN = 32; /* bits */ 67 68 FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN = 64; /* bits */ 69 FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN = 64; /* bits */ 70 FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN = 16; /* bits */ 71 72 FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = FLAC__U64L(0xffffffffffffffff); 73 74 FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN = 32; /* bits */ 75 FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN = 32; /* bits */ 76 77 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN = 64; /* bits */ 78 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN = 8; /* bits */ 79 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN = 3*8; /* bits */ 80 81 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN = 64; /* bits */ 82 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN = 8; /* bits */ 83 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN = 12*8; /* bits */ 84 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN = 1; /* bit */ 85 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN = 1; /* bit */ 86 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN = 6+13*8; /* bits */ 87 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN = 8; /* bits */ 88 89 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN = 128*8; /* bits */ 90 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN = 64; /* bits */ 91 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN = 1; /* bit */ 92 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN = 7+258*8; /* bits */ 93 FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN = 8; /* bits */ 94 95 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_TYPE_LEN = 32; /* bits */ 96 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN = 32; /* bits */ 97 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN = 32; /* bits */ 98 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN = 32; /* bits */ 99 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN = 32; /* bits */ 100 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN = 32; /* bits */ 101 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_COLORS_LEN = 32; /* bits */ 102 FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN = 32; /* bits */ 103 104 FLAC_API const unsigned FLAC__STREAM_METADATA_IS_LAST_LEN = 1; /* bits */ 105 FLAC_API const unsigned FLAC__STREAM_METADATA_TYPE_LEN = 7; /* bits */ 106 FLAC_API const unsigned FLAC__STREAM_METADATA_LENGTH_LEN = 24; /* bits */ 107 108 FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC = 0x3ffe; 109 FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC_LEN = 14; /* bits */ 110 FLAC_API const unsigned FLAC__FRAME_HEADER_RESERVED_LEN = 1; /* bits */ 111 FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN = 1; /* bits */ 112 FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCK_SIZE_LEN = 4; /* bits */ 113 FLAC_API const unsigned FLAC__FRAME_HEADER_SAMPLE_RATE_LEN = 4; /* bits */ 114 FLAC_API const unsigned FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN = 4; /* bits */ 115 FLAC_API const unsigned FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN = 3; /* bits */ 116 FLAC_API const unsigned FLAC__FRAME_HEADER_ZERO_PAD_LEN = 1; /* bits */ 117 FLAC_API const unsigned FLAC__FRAME_HEADER_CRC_LEN = 8; /* bits */ 118 119 FLAC_API const unsigned FLAC__FRAME_FOOTER_CRC_LEN = 16; /* bits */ 120 121 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_TYPE_LEN = 2; /* bits */ 122 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN = 4; /* bits */ 123 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN = 4; /* bits */ 124 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN = 5; /* bits */ 125 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN = 5; /* bits */ 126 127 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER = 15; /* == (1<<FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN)-1 */ 128 FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER = 31; /* == (1<<FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN)-1 */ 129 130 FLAC_API const char * const FLAC__EntropyCodingMethodTypeString[] = { 131 "PARTITIONED_RICE", 132 "PARTITIONED_RICE2" 133 }; 134 135 FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN = 4; /* bits */ 136 FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN = 5; /* bits */ 137 138 FLAC_API const unsigned FLAC__SUBFRAME_ZERO_PAD_LEN = 1; /* bits */ 139 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LEN = 6; /* bits */ 140 FLAC_API const unsigned FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN = 1; /* bits */ 141 142 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK = 0x00; 143 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK = 0x02; 144 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK = 0x10; 145 FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK = 0x40; 146 147 FLAC_API const char * const FLAC__SubframeTypeString[] = { 148 "CONSTANT", 149 "VERBATIM", 150 "FIXED", 151 "LPC" 152 }; 153 154 FLAC_API const char * const FLAC__ChannelAssignmentString[] = { 155 "INDEPENDENT", 156 "LEFT_SIDE", 157 "RIGHT_SIDE", 158 "MID_SIDE" 159 }; 160 161 FLAC_API const char * const FLAC__FrameNumberTypeString[] = { 162 "FRAME_NUMBER_TYPE_FRAME_NUMBER", 163 "FRAME_NUMBER_TYPE_SAMPLE_NUMBER" 164 }; 165 166 FLAC_API const char * const FLAC__MetadataTypeString[] = { 167 "STREAMINFO", 168 "PADDING", 169 "APPLICATION", 170 "SEEKTABLE", 171 "VORBIS_COMMENT", 172 "CUESHEET", 173 "PICTURE" 174 }; 175 176 FLAC_API const char * const FLAC__StreamMetadata_Picture_TypeString[] = { 177 "Other", 178 "32x32 pixels 'file icon' (PNG only)", 179 "Other file icon", 180 "Cover (front)", 181 "Cover (back)", 182 "Leaflet page", 183 "Media (e.g. label side of CD)", 184 "Lead artist/lead performer/soloist", 185 "Artist/performer", 186 "Conductor", 187 "Band/Orchestra", 188 "Composer", 189 "Lyricist/text writer", 190 "Recording Location", 191 "During recording", 192 "During performance", 193 "Movie/video screen capture", 194 "A bright coloured fish", 195 "Illustration", 196 "Band/artist logotype", 197 "Publisher/Studio logotype" 198 }; 199 200 FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(unsigned sample_rate) 201 { 202 if(sample_rate == 0 || sample_rate > FLAC__MAX_SAMPLE_RATE) { 203 return false; 204 } 205 else 206 return true; 207 } 208 209 FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(unsigned blocksize, unsigned sample_rate) 210 { 211 if(blocksize > 16384) 212 return false; 213 else if(sample_rate <= 48000 && blocksize > 4608) 214 return false; 215 else 216 return true; 217 } 218 219 FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(unsigned sample_rate) 220 { 221 if( 222 !FLAC__format_sample_rate_is_valid(sample_rate) || 223 ( 224 sample_rate >= (1u << 16) && 225 !(sample_rate % 1000 == 0 || sample_rate % 10 == 0) 226 ) 227 ) { 228 return false; 229 } 230 else 231 return true; 232 } 233 234 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */ 235 FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_SeekTable *seek_table) 236 { 237 unsigned i; 238 FLAC__uint64 prev_sample_number = 0; 239 FLAC__bool got_prev = false; 240 241 FLAC__ASSERT(0 != seek_table); 242 243 for(i = 0; i < seek_table->num_points; i++) { 244 if(got_prev) { 245 if( 246 seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER && 247 seek_table->points[i].sample_number <= prev_sample_number 248 ) 249 return false; 250 } 251 prev_sample_number = seek_table->points[i].sample_number; 252 got_prev = true; 253 } 254 255 return true; 256 } 257 258 /* used as the sort predicate for qsort() */ 259 static int seekpoint_compare_(const FLAC__StreamMetadata_SeekPoint *l, const FLAC__StreamMetadata_SeekPoint *r) 260 { 261 /* we don't just 'return l->sample_number - r->sample_number' since the result (FLAC__int64) might overflow an 'int' */ 262 if(l->sample_number == r->sample_number) 263 return 0; 264 else if(l->sample_number < r->sample_number) 265 return -1; 266 else 267 return 1; 268 } 269 270 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */ 271 FLAC_API unsigned FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table) 272 { 273 unsigned i, j; 274 FLAC__bool first; 275 276 FLAC__ASSERT(0 != seek_table); 277 278 if (seek_table->num_points == 0) 279 return 0; 280 281 /* sort the seekpoints */ 282 qsort(seek_table->points, seek_table->num_points, sizeof(FLAC__StreamMetadata_SeekPoint), (int (*)(const void *, const void *))seekpoint_compare_); 283 284 /* uniquify the seekpoints */ 285 first = true; 286 for(i = j = 0; i < seek_table->num_points; i++) { 287 if(seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER) { 288 if(!first) { 289 if(seek_table->points[i].sample_number == seek_table->points[j-1].sample_number) 290 continue; 291 } 292 } 293 first = false; 294 seek_table->points[j++] = seek_table->points[i]; 295 } 296 297 for(i = j; i < seek_table->num_points; i++) { 298 seek_table->points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER; 299 seek_table->points[i].stream_offset = 0; 300 seek_table->points[i].frame_samples = 0; 301 } 302 303 return j; 304 } 305 306 /* 307 * also disallows non-shortest-form encodings, c.f. 308 * http://www.unicode.org/versions/corrigendum1.html 309 * and a more clear explanation at the end of this section: 310 * http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 311 */ 312 static unsigned utf8len_(const FLAC__byte *utf8) 313 { 314 FLAC__ASSERT(0 != utf8); 315 if ((utf8[0] & 0x80) == 0) { 316 return 1; 317 } 318 else if ((utf8[0] & 0xE0) == 0xC0 && (utf8[1] & 0xC0) == 0x80) { 319 if ((utf8[0] & 0xFE) == 0xC0) /* overlong sequence check */ 320 return 0; 321 return 2; 322 } 323 else if ((utf8[0] & 0xF0) == 0xE0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80) { 324 if (utf8[0] == 0xE0 && (utf8[1] & 0xE0) == 0x80) /* overlong sequence check */ 325 return 0; 326 /* illegal surrogates check (U+D800...U+DFFF and U+FFFE...U+FFFF) */ 327 if (utf8[0] == 0xED && (utf8[1] & 0xE0) == 0xA0) /* D800-DFFF */ 328 return 0; 329 if (utf8[0] == 0xEF && utf8[1] == 0xBF && (utf8[2] & 0xFE) == 0xBE) /* FFFE-FFFF */ 330 return 0; 331 return 3; 332 } 333 else if ((utf8[0] & 0xF8) == 0xF0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80) { 334 if (utf8[0] == 0xF0 && (utf8[1] & 0xF0) == 0x80) /* overlong sequence check */ 335 return 0; 336 return 4; 337 } 338 else if ((utf8[0] & 0xFC) == 0xF8 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80 && (utf8[4] & 0xC0) == 0x80) { 339 if (utf8[0] == 0xF8 && (utf8[1] & 0xF8) == 0x80) /* overlong sequence check */ 340 return 0; 341 return 5; 342 } 343 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) { 344 if (utf8[0] == 0xFC && (utf8[1] & 0xFC) == 0x80) /* overlong sequence check */ 345 return 0; 346 return 6; 347 } 348 else { 349 return 0; 350 } 351 } 352 353 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name) 354 { 355 char c; 356 for(c = *name; c; c = *(++name)) 357 if(c < 0x20 || c == 0x3d || c > 0x7d) 358 return false; 359 return true; 360 } 361 362 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, unsigned length) 363 { 364 if(length == (unsigned)(-1)) { 365 while(*value) { 366 unsigned n = utf8len_(value); 367 if(n == 0) 368 return false; 369 value += n; 370 } 371 } 372 else { 373 const FLAC__byte *end = value + length; 374 while(value < end) { 375 unsigned n = utf8len_(value); 376 if(n == 0) 377 return false; 378 value += n; 379 } 380 if(value != end) 381 return false; 382 } 383 return true; 384 } 385 386 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, unsigned length) 387 { 388 const FLAC__byte *s, *end; 389 390 for(s = entry, end = s + length; s < end && *s != '='; s++) { 391 if(*s < 0x20 || *s > 0x7D) 392 return false; 393 } 394 if(s == end) 395 return false; 396 397 s++; /* skip '=' */ 398 399 while(s < end) { 400 unsigned n = utf8len_(s); 401 if(n == 0) 402 return false; 403 s += n; 404 } 405 if(s != end) 406 return false; 407 408 return true; 409 } 410 411 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */ 412 FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation) 413 { 414 unsigned i, j; 415 416 if(check_cd_da_subset) { 417 if(cue_sheet->lead_in < 2 * 44100) { 418 if(violation) *violation = "CD-DA cue sheet must have a lead-in length of at least 2 seconds"; 419 return false; 420 } 421 if(cue_sheet->lead_in % 588 != 0) { 422 if(violation) *violation = "CD-DA cue sheet lead-in length must be evenly divisible by 588 samples"; 423 return false; 424 } 425 } 426 427 if(cue_sheet->num_tracks == 0) { 428 if(violation) *violation = "cue sheet must have at least one track (the lead-out)"; 429 return false; 430 } 431 432 if(check_cd_da_subset && cue_sheet->tracks[cue_sheet->num_tracks-1].number != 170) { 433 if(violation) *violation = "CD-DA cue sheet must have a lead-out track number 170 (0xAA)"; 434 return false; 435 } 436 437 for(i = 0; i < cue_sheet->num_tracks; i++) { 438 if(cue_sheet->tracks[i].number == 0) { 439 if(violation) *violation = "cue sheet may not have a track number 0"; 440 return false; 441 } 442 443 if(check_cd_da_subset) { 444 if(!((cue_sheet->tracks[i].number >= 1 && cue_sheet->tracks[i].number <= 99) || cue_sheet->tracks[i].number == 170)) { 445 if(violation) *violation = "CD-DA cue sheet track number must be 1-99 or 170"; 446 return false; 447 } 448 } 449 450 if(check_cd_da_subset && cue_sheet->tracks[i].offset % 588 != 0) { 451 if(violation) { 452 if(i == cue_sheet->num_tracks-1) /* the lead-out track... */ 453 *violation = "CD-DA cue sheet lead-out offset must be evenly divisible by 588 samples"; 454 else 455 *violation = "CD-DA cue sheet track offset must be evenly divisible by 588 samples"; 456 } 457 return false; 458 } 459 460 if(i < cue_sheet->num_tracks - 1) { 461 if(cue_sheet->tracks[i].num_indices == 0) { 462 if(violation) *violation = "cue sheet track must have at least one index point"; 463 return false; 464 } 465 466 if(cue_sheet->tracks[i].indices[0].number > 1) { 467 if(violation) *violation = "cue sheet track's first index number must be 0 or 1"; 468 return false; 469 } 470 } 471 472 for(j = 0; j < cue_sheet->tracks[i].num_indices; j++) { 473 if(check_cd_da_subset && cue_sheet->tracks[i].indices[j].offset % 588 != 0) { 474 if(violation) *violation = "CD-DA cue sheet track index offset must be evenly divisible by 588 samples"; 475 return false; 476 } 477 478 if(j > 0) { 479 if(cue_sheet->tracks[i].indices[j].number != cue_sheet->tracks[i].indices[j-1].number + 1) { 480 if(violation) *violation = "cue sheet track index numbers must increase by 1"; 481 return false; 482 } 483 } 484 } 485 } 486 487 return true; 488 } 489 490 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */ 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 flac_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 = safe_realloc_(object->parameters, sizeof(unsigned)*(1 << max_partition_order)))) 581 return false; 582 if(0 == (object->raw_bits = safe_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 } 590
