libFLAC: Add function safe_realloc_()
[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/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         /* sort the seekpoints */
279         qsort(seek_table->points, seek_table->num_points, sizeof(FLAC__StreamMetadata_SeekPoint), (int (*)(const void *, const void *))seekpoint_compare_);
280
281         /* uniquify the seekpoints */
282         first = true;
283         for(i = j = 0; i < seek_table->num_points; i++) {
284                 if(seek_table->points[i].sample_number != FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER) {
285                         if(!first) {
286                                 if(seek_table->points[i].sample_number == seek_table->points[j-1].sample_number)
287                                         continue;
288                         }
289                 }
290                 first = false;
291                 seek_table->points[j++] = seek_table->points[i];
292         }
293
294         for(i = j; i < seek_table->num_points; i++) {
295                 seek_table->points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
296                 seek_table->points[i].stream_offset = 0;
297                 seek_table->points[i].frame_samples = 0;
298         }
299
300         return j;
301 }
302
303 /*
304  * also disallows non-shortest-form encodings, c.f.
305  *   http://www.unicode.org/versions/corrigendum1.html
306  * and a more clear explanation at the end of this section:
307  *   http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
308  */
309 static unsigned utf8len_(const FLAC__byte *utf8)
310 {
311         FLAC__ASSERT(0 != utf8);
312         if ((utf8[0] & 0x80) == 0) {
313                 return 1;
314         }
315         else if ((utf8[0] & 0xE0) == 0xC0 && (utf8[1] & 0xC0) == 0x80) {
316                 if ((utf8[0] & 0xFE) == 0xC0) /* overlong sequence check */
317                         return 0;
318                 return 2;
319         }
320         else if ((utf8[0] & 0xF0) == 0xE0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80) {
321                 if (utf8[0] == 0xE0 && (utf8[1] & 0xE0) == 0x80) /* overlong sequence check */
322                         return 0;
323                 /* illegal surrogates check (U+D800...U+DFFF and U+FFFE...U+FFFF) */
324                 if (utf8[0] == 0xED && (utf8[1] & 0xE0) == 0xA0) /* D800-DFFF */
325                         return 0;
326                 if (utf8[0] == 0xEF && utf8[1] == 0xBF && (utf8[2] & 0xFE) == 0xBE) /* FFFE-FFFF */
327                         return 0;
328                 return 3;
329         }
330         else if ((utf8[0] & 0xF8) == 0xF0 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80) {
331                 if (utf8[0] == 0xF0 && (utf8[1] & 0xF0) == 0x80) /* overlong sequence check */
332                         return 0;
333                 return 4;
334         }
335         else if ((utf8[0] & 0xFC) == 0xF8 && (utf8[1] & 0xC0) == 0x80 && (utf8[2] & 0xC0) == 0x80 && (utf8[3] & 0xC0) == 0x80 && (utf8[4] & 0xC0) == 0x80) {
336                 if (utf8[0] == 0xF8 && (utf8[1] & 0xF8) == 0x80) /* overlong sequence check */
337                         return 0;
338                 return 5;
339         }
340         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) {
341                 if (utf8[0] == 0xFC && (utf8[1] & 0xFC) == 0x80) /* overlong sequence check */
342                         return 0;
343                 return 6;
344         }
345         else {
346                 return 0;
347         }
348 }
349
350 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *name)
351 {
352         char c;
353         for(c = *name; c; c = *(++name))
354                 if(c < 0x20 || c == 0x3d || c > 0x7d)
355                         return false;
356         return true;
357 }
358
359 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, unsigned length)
360 {
361         if(length == (unsigned)(-1)) {
362                 while(*value) {
363                         unsigned n = utf8len_(value);
364                         if(n == 0)
365                                 return false;
366                         value += n;
367                 }
368         }
369         else {
370                 const FLAC__byte *end = value + length;
371                 while(value < end) {
372                         unsigned n = utf8len_(value);
373                         if(n == 0)
374                                 return false;
375                         value += n;
376                 }
377                 if(value != end)
378                         return false;
379         }
380         return true;
381 }
382
383 FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, unsigned length)
384 {
385         const FLAC__byte *s, *end;
386
387         for(s = entry, end = s + length; s < end && *s != '='; s++) {
388                 if(*s < 0x20 || *s > 0x7D)
389                         return false;
390         }
391         if(s == end)
392                 return false;
393
394         s++; /* skip '=' */
395
396         while(s < end) {
397                 unsigned n = utf8len_(s);
398                 if(n == 0)
399                         return false;
400                 s += n;
401         }
402         if(s != end)
403                 return false;
404
405         return true;
406 }
407
408 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
409 FLAC_API FLAC__bool FLAC__format_cuesheet_is_legal(const FLAC__StreamMetadata_CueSheet *cue_sheet, FLAC__bool check_cd_da_subset, const char **violation)
410 {
411         unsigned i, j;
412
413         if(check_cd_da_subset) {
414                 if(cue_sheet->lead_in < 2 * 44100) {
415                         if(violation) *violation = "CD-DA cue sheet must have a lead-in length of at least 2 seconds";
416                         return false;
417                 }
418                 if(cue_sheet->lead_in % 588 != 0) {
419                         if(violation) *violation = "CD-DA cue sheet lead-in length must be evenly divisible by 588 samples";
420                         return false;
421                 }
422         }
423
424         if(cue_sheet->num_tracks == 0) {
425                 if(violation) *violation = "cue sheet must have at least one track (the lead-out)";
426                 return false;
427         }
428
429         if(check_cd_da_subset && cue_sheet->tracks[cue_sheet->num_tracks-1].number != 170) {
430                 if(violation) *violation = "CD-DA cue sheet must have a lead-out track number 170 (0xAA)";
431                 return false;
432         }
433
434         for(i = 0; i < cue_sheet->num_tracks; i++) {
435                 if(cue_sheet->tracks[i].number == 0) {
436                         if(violation) *violation = "cue sheet may not have a track number 0";
437                         return false;
438                 }
439
440                 if(check_cd_da_subset) {
441                         if(!((cue_sheet->tracks[i].number >= 1 && cue_sheet->tracks[i].number <= 99) || cue_sheet->tracks[i].number == 170)) {
442                                 if(violation) *violation = "CD-DA cue sheet track number must be 1-99 or 170";
443                                 return false;
444                         }
445                 }
446
447                 if(check_cd_da_subset && cue_sheet->tracks[i].offset % 588 != 0) {
448                         if(violation) {
449                                 if(i == cue_sheet->num_tracks-1) /* the lead-out track... */
450                                         *violation = "CD-DA cue sheet lead-out offset must be evenly divisible by 588 samples";
451                                 else
452                                         *violation = "CD-DA cue sheet track offset must be evenly divisible by 588 samples";
453                         }
454                         return false;
455                 }
456
457                 if(i < cue_sheet->num_tracks - 1) {
458                         if(cue_sheet->tracks[i].num_indices == 0) {
459                                 if(violation) *violation = "cue sheet track must have at least one index point";
460                                 return false;
461                         }
462
463                         if(cue_sheet->tracks[i].indices[0].number > 1) {
464                                 if(violation) *violation = "cue sheet track's first index number must be 0 or 1";
465                                 return false;
466                         }
467                 }
468
469                 for(j = 0; j < cue_sheet->tracks[i].num_indices; j++) {
470                         if(check_cd_da_subset && cue_sheet->tracks[i].indices[j].offset % 588 != 0) {
471                                 if(violation) *violation = "CD-DA cue sheet track index offset must be evenly divisible by 588 samples";
472                                 return false;
473                         }
474
475                         if(j > 0) {
476                                 if(cue_sheet->tracks[i].indices[j].number != cue_sheet->tracks[i].indices[j-1].number + 1) {
477                                         if(violation) *violation = "cue sheet track index numbers must increase by 1";
478                                         return false;
479                                 }
480                         }
481                 }
482         }
483
484         return true;
485 }
486
487 /* @@@@ add to unit tests; it is already indirectly tested by the metadata_object tests */
488 FLAC_API FLAC__bool FLAC__format_picture_is_legal(const FLAC__StreamMetadata_Picture *picture, const char **violation)
489 {
490         char *p;
491         FLAC__byte *b;
492
493         for(p = picture->mime_type; *p; p++) {
494                 if(*p < 0x20 || *p > 0x7e) {
495                         if(violation) *violation = "MIME type string must contain only printable ASCII characters (0x20-0x7e)";
496                         return false;
497                 }
498         }
499
500         for(b = picture->description; *b; ) {
501                 unsigned n = utf8len_(b);
502                 if(n == 0) {
503                         if(violation) *violation = "description string must be valid UTF-8";
504                         return false;
505                 }
506                 b += n;
507         }
508
509         return true;
510 }
511
512 /*
513  * These routines are private to libFLAC
514  */
515 unsigned FLAC__format_get_max_rice_partition_order(unsigned blocksize, unsigned predictor_order)
516 {
517         return
518                 FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(
519                         FLAC__format_get_max_rice_partition_order_from_blocksize(blocksize),
520                         blocksize,
521                         predictor_order
522                 );
523 }
524
525 unsigned FLAC__format_get_max_rice_partition_order_from_blocksize(unsigned blocksize)
526 {
527         unsigned max_rice_partition_order = 0;
528         while(!(blocksize & 1)) {
529                 max_rice_partition_order++;
530                 blocksize >>= 1;
531         }
532         return flac_min(FLAC__MAX_RICE_PARTITION_ORDER, max_rice_partition_order);
533 }
534
535 unsigned FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(unsigned limit, unsigned blocksize, unsigned predictor_order)
536 {
537         unsigned max_rice_partition_order = limit;
538
539         while(max_rice_partition_order > 0 && (blocksize >> max_rice_partition_order) <= predictor_order)
540                 max_rice_partition_order--;
541
542         FLAC__ASSERT(
543                 (max_rice_partition_order == 0 && blocksize >= predictor_order) ||
544                 (max_rice_partition_order > 0 && blocksize >> max_rice_partition_order > predictor_order)
545         );
546
547         return max_rice_partition_order;
548 }
549
550 void FLAC__format_entropy_coding_method_partitioned_rice_contents_init(FLAC__EntropyCodingMethod_PartitionedRiceContents *object)
551 {
552         FLAC__ASSERT(0 != object);
553
554         object->parameters = 0;
555         object->raw_bits = 0;
556         object->capacity_by_order = 0;
557 }
558
559 void FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(FLAC__EntropyCodingMethod_PartitionedRiceContents *object)
560 {
561         FLAC__ASSERT(0 != object);
562
563         if(0 != object->parameters)
564                 free(object->parameters);
565         if(0 != object->raw_bits)
566                 free(object->raw_bits);
567         FLAC__format_entropy_coding_method_partitioned_rice_contents_init(object);
568 }
569
570 FLAC__bool FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(FLAC__EntropyCodingMethod_PartitionedRiceContents *object, unsigned max_partition_order)
571 {
572         FLAC__ASSERT(0 != object);
573
574         FLAC__ASSERT(object->capacity_by_order > 0 || (0 == object->parameters && 0 == object->raw_bits));
575
576         if(object->capacity_by_order < max_partition_order) {
577                 if(0 == (object->parameters = safe_realloc_(object->parameters, sizeof(unsigned)*(1 << max_partition_order))))
578                         return false;
579                 if(0 == (object->raw_bits = safe_realloc_(object->raw_bits, sizeof(unsigned)*(1 << max_partition_order))))
580                         return false;
581                 memset(object->raw_bits, 0, sizeof(unsigned)*(1 << max_partition_order));
582                 object->capacity_by_order = max_partition_order;
583         }
584
585         return true;
586 }