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