minor syntax
[flac.git] / src / test_libOggFLAC / metadata_utils.c
1 /* test_libFLAC - Unit tester for libFLAC
2  * Copyright (C) 2002  Josh Coalson
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17  */
18
19 /*
20  * These are not tests, just utility functions used by the metadata tests
21  */
22
23 #include "metadata_utils.h"
24 #include "FLAC/metadata.h"
25 #include <stdio.h>
26 #include <stdlib.h> /* for malloc() */
27 #include <string.h> /* for memcmp() */
28
29 FLAC__bool compare_block_data_streaminfo_(const FLAC__StreamMetadata_StreamInfo *block, const FLAC__StreamMetadata_StreamInfo *blockcopy)
30 {
31         if(blockcopy->min_blocksize != block->min_blocksize) {
32                 printf("FAILED, min_blocksize mismatch, expected %u, got %u\n", block->min_blocksize, blockcopy->min_blocksize);
33                 return false;
34         }
35         if(blockcopy->max_blocksize != block->max_blocksize) {
36                 printf("FAILED, max_blocksize mismatch, expected %u, got %u\n", block->max_blocksize, blockcopy->max_blocksize);
37                 return false;
38         }
39         if(blockcopy->min_framesize != block->min_framesize) {
40                 printf("FAILED, min_framesize mismatch, expected %u, got %u\n", block->min_framesize, blockcopy->min_framesize);
41                 return false;
42         }
43         if(blockcopy->max_framesize != block->max_framesize) {
44                 printf("FAILED, max_framesize mismatch, expected %u, got %u\n", block->max_framesize, blockcopy->max_framesize);
45                 return false;
46         }
47         if(blockcopy->sample_rate != block->sample_rate) {
48                 printf("FAILED, sample_rate mismatch, expected %u, got %u\n", block->sample_rate, blockcopy->sample_rate);
49                 return false;
50         }
51         if(blockcopy->channels != block->channels) {
52                 printf("FAILED, channels mismatch, expected %u, got %u\n", block->channels, blockcopy->channels);
53                 return false;
54         }
55         if(blockcopy->bits_per_sample != block->bits_per_sample) {
56                 printf("FAILED, bits_per_sample mismatch, expected %u, got %u\n", block->bits_per_sample, blockcopy->bits_per_sample);
57                 return false;
58         }
59         if(blockcopy->total_samples != block->total_samples) {
60                 printf("FAILED, total_samples mismatch, expected %llu, got %llu\n", block->total_samples, blockcopy->total_samples);
61                 return false;
62         }
63         if(0 != memcmp(blockcopy->md5sum, block->md5sum, sizeof(block->md5sum))) {
64                 printf("FAILED, md5sum mismatch, expected %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X, got %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
65                         (unsigned)block->md5sum[0],
66                         (unsigned)block->md5sum[1],
67                         (unsigned)block->md5sum[2],
68                         (unsigned)block->md5sum[3],
69                         (unsigned)block->md5sum[4],
70                         (unsigned)block->md5sum[5],
71                         (unsigned)block->md5sum[6],
72                         (unsigned)block->md5sum[7],
73                         (unsigned)block->md5sum[8],
74                         (unsigned)block->md5sum[9],
75                         (unsigned)block->md5sum[10],
76                         (unsigned)block->md5sum[11],
77                         (unsigned)block->md5sum[12],
78                         (unsigned)block->md5sum[13],
79                         (unsigned)block->md5sum[14],
80                         (unsigned)block->md5sum[15],
81                         (unsigned)blockcopy->md5sum[0],
82                         (unsigned)blockcopy->md5sum[1],
83                         (unsigned)blockcopy->md5sum[2],
84                         (unsigned)blockcopy->md5sum[3],
85                         (unsigned)blockcopy->md5sum[4],
86                         (unsigned)blockcopy->md5sum[5],
87                         (unsigned)blockcopy->md5sum[6],
88                         (unsigned)blockcopy->md5sum[7],
89                         (unsigned)blockcopy->md5sum[8],
90                         (unsigned)blockcopy->md5sum[9],
91                         (unsigned)blockcopy->md5sum[10],
92                         (unsigned)blockcopy->md5sum[11],
93                         (unsigned)blockcopy->md5sum[12],
94                         (unsigned)blockcopy->md5sum[13],
95                         (unsigned)blockcopy->md5sum[14],
96                         (unsigned)blockcopy->md5sum[15]
97                 );
98                 return false;
99         }
100         return true;
101 }
102
103 FLAC__bool compare_block_data_padding_(const FLAC__StreamMetadata_Padding *block, const FLAC__StreamMetadata_Padding *blockcopy, unsigned block_length)
104 {
105         /* we don't compare the padding guts */
106         (void)block, (void)blockcopy, (void)block_length;
107         return true;
108 }
109
110 FLAC__bool compare_block_data_application_(const FLAC__StreamMetadata_Application *block, const FLAC__StreamMetadata_Application *blockcopy, unsigned block_length)
111 {
112         if(block_length < sizeof(block->id)) {
113                 printf("FAILED, bad block length = %u\n", block_length);
114                 return false;
115         }
116         if(0 != memcmp(blockcopy->id, block->id, sizeof(block->id))) {
117                 printf("FAILED, id mismatch, expected %02X%02X%02X%02X, got %02X%02X%02X%02X\n",
118                         (unsigned)block->id[0],
119                         (unsigned)block->id[1],
120                         (unsigned)block->id[2],
121                         (unsigned)block->id[3],
122                         (unsigned)blockcopy->id[0],
123                         (unsigned)blockcopy->id[1],
124                         (unsigned)blockcopy->id[2],
125                         (unsigned)blockcopy->id[3]
126                 );
127                 return false;
128         }
129         if(0 == block->data || 0 == blockcopy->data) {
130                 if(block->data != blockcopy->data) {
131                         printf("FAILED, data mismatch (%s's data pointer is null)\n", 0==block->data?"original":"copy");
132                         return false;
133                 }
134                 else if(block_length - sizeof(block->id) > 0) {
135                         printf("FAILED, data pointer is null but block length is not 0\n");
136                         return false;
137                 }
138         }
139         else {
140                 if(block_length - sizeof(block->id) == 0) {
141                         printf("FAILED, data pointer is not null but block length is 0\n");
142                         return false;
143                 }
144                 else if(0 != memcmp(blockcopy->data, block->data, block_length - sizeof(block->id))) {
145                         printf("FAILED, data mismatch\n");
146                         return false;
147                 }
148         }
149         return true;
150 }
151
152 FLAC__bool compare_block_data_seektable_(const FLAC__StreamMetadata_SeekTable *block, const FLAC__StreamMetadata_SeekTable *blockcopy)
153 {
154         unsigned i;
155         if(blockcopy->num_points != block->num_points) {
156                 printf("FAILED, num_points mismatch, expected %u, got %u\n", block->num_points, blockcopy->num_points);
157                 return false;
158         }
159         for(i = 0; i < block->num_points; i++) {
160                 if(blockcopy->points[i].sample_number != block->points[i].sample_number) {
161                         printf("FAILED, points[%u].sample_number mismatch, expected %llu, got %llu\n", i, block->points[i].sample_number, blockcopy->points[i].sample_number);
162                         return false;
163                 }
164                 if(blockcopy->points[i].stream_offset != block->points[i].stream_offset) {
165                         printf("FAILED, points[%u].stream_offset mismatch, expected %llu, got %llu\n", i, block->points[i].stream_offset, blockcopy->points[i].stream_offset);
166                         return false;
167                 }
168                 if(blockcopy->points[i].frame_samples != block->points[i].frame_samples) {
169                         printf("FAILED, points[%u].frame_samples mismatch, expected %u, got %u\n", i, block->points[i].frame_samples, blockcopy->points[i].frame_samples);
170                         return false;
171                 }
172         }
173         return true;
174 }
175
176 FLAC__bool compare_block_data_vorbiscomment_(const FLAC__StreamMetadata_VorbisComment *block, const FLAC__StreamMetadata_VorbisComment *blockcopy)
177 {
178         unsigned i;
179         if(blockcopy->vendor_string.length != block->vendor_string.length) {
180                 printf("FAILED, vendor_string.length mismatch, expected %u, got %u\n", block->vendor_string.length, blockcopy->vendor_string.length);
181                 return false;
182         }
183         if(0 == block->vendor_string.entry || 0 == blockcopy->vendor_string.entry) {
184                 if(block->vendor_string.entry != blockcopy->vendor_string.entry) {
185                         printf("FAILED, vendor_string.entry mismatch\n");
186                         return false;
187                 }
188         }
189         else if(0 != memcmp(blockcopy->vendor_string.entry, block->vendor_string.entry, block->vendor_string.length)) {
190                 printf("FAILED, vendor_string.entry mismatch\n");
191                 return false;
192         }
193         if(blockcopy->num_comments != block->num_comments) {
194                 printf("FAILED, num_comments mismatch, expected %u, got %u\n", block->num_comments, blockcopy->num_comments);
195                 return false;
196         }
197         for(i = 0; i < block->num_comments; i++) {
198                 if(blockcopy->comments[i].length != block->comments[i].length) {
199                         printf("FAILED, comments[%u].length mismatch, expected %u, got %u\n", i, block->comments[i].length, blockcopy->comments[i].length);
200                         return false;
201                 }
202                 if(0 == block->comments[i].entry || 0 == blockcopy->comments[i].entry) {
203                         if(block->comments[i].entry != blockcopy->comments[i].entry) {
204                                 printf("FAILED, comments[%u].entry mismatch\n", i);
205                                 return false;
206                         }
207                 }
208                 else {
209                         if(0 != memcmp(blockcopy->comments[i].entry, block->comments[i].entry, block->comments[i].length)) {
210                                 printf("FAILED, comments[%u].entry mismatch\n", i);
211                                 return false;
212                         }
213                 }
214         }
215         return true;
216 }
217
218 FLAC__bool compare_block_data_cuesheet_(const FLAC__StreamMetadata_CueSheet *block, const FLAC__StreamMetadata_CueSheet *blockcopy)
219 {
220         unsigned i, j;
221
222         if(0 != strcmp(blockcopy->media_catalog_number, block->media_catalog_number)) {
223                 printf("FAILED, media_catalog_number mismatch, expected %s, got %s\n", block->media_catalog_number, blockcopy->media_catalog_number);
224                 return false;
225         }
226         if(blockcopy->lead_in != block->lead_in) {
227                 printf("FAILED, lead_in mismatch, expected %llu, got %llu\n", block->lead_in, blockcopy->lead_in);
228                 return false;
229         }
230         if(blockcopy->is_cd != block->is_cd) {
231                 printf("FAILED, is_cd mismatch, expected %u, got %u\n", (unsigned)block->is_cd, (unsigned)blockcopy->is_cd);
232                 return false;
233         }
234         if(blockcopy->num_tracks != block->num_tracks) {
235                 printf("FAILED, num_tracks mismatch, expected %u, got %u\n", block->num_tracks, blockcopy->num_tracks);
236                 return false;
237         }
238         for(i = 0; i < block->num_tracks; i++) {
239                 if(blockcopy->tracks[i].offset != block->tracks[i].offset) {
240                         printf("FAILED, tracks[%u].offset mismatch, expected %llu, got %llu\n", i, block->tracks[i].offset, blockcopy->tracks[i].offset);
241                         return false;
242                 }
243                 if(blockcopy->tracks[i].number != block->tracks[i].number) {
244                         printf("FAILED, tracks[%u].number mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].number, (unsigned)blockcopy->tracks[i].number);
245                         return false;
246                 }
247                 if(blockcopy->tracks[i].num_indices != block->tracks[i].num_indices) {
248                         printf("FAILED, tracks[%u].num_indices mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].num_indices, (unsigned)blockcopy->tracks[i].num_indices);
249                         return false;
250                 }
251                 /* num_indices == 0 means lead-out track so only the track offset and number are valid */
252                 if(block->tracks[i].num_indices > 0) {
253                         if(0 != strcmp(blockcopy->tracks[i].isrc, block->tracks[i].isrc)) {
254                                 printf("FAILED, tracks[%u].isrc mismatch, expected %s, got %s\n", i, block->tracks[i].isrc, blockcopy->tracks[i].isrc);
255                                 return false;
256                         }
257                         if(blockcopy->tracks[i].type != block->tracks[i].type) {
258                                 printf("FAILED, tracks[%u].type mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].type, (unsigned)blockcopy->tracks[i].type);
259                                 return false;
260                         }
261                         if(blockcopy->tracks[i].pre_emphasis != block->tracks[i].pre_emphasis) {
262                                 printf("FAILED, tracks[%u].pre_emphasis mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].pre_emphasis, (unsigned)blockcopy->tracks[i].pre_emphasis);
263                                 return false;
264                         }
265                         if(0 == block->tracks[i].indices || 0 == blockcopy->tracks[i].indices) {
266                                 if(block->tracks[i].indices != blockcopy->tracks[i].indices) {
267                                         printf("FAILED, tracks[%u].indices mismatch\n", i);
268                                         return false;
269                                 }
270                         }
271                         else {
272                                 for(j = 0; j < block->tracks[i].num_indices; j++) {
273                                         if(blockcopy->tracks[i].indices[j].offset != block->tracks[i].indices[j].offset) {
274                                                 printf("FAILED, tracks[%u].indices[%u].offset mismatch, expected %llu, got %llu\n", i, j, block->tracks[i].indices[j].offset, blockcopy->tracks[i].indices[j].offset);
275                                                 return false;
276                                         }
277                                         if(blockcopy->tracks[i].indices[j].number != block->tracks[i].indices[j].number) {
278                                                 printf("FAILED, tracks[%u].indices[%u].number mismatch, expected %u, got %u\n", i, j, (unsigned)block->tracks[i].indices[j].number, (unsigned)blockcopy->tracks[i].indices[j].number);
279                                                 return false;
280                                         }
281                                 }
282                         }
283                 }
284         }
285         return true;
286 }
287
288 FLAC__bool compare_block_(const FLAC__StreamMetadata *block, const FLAC__StreamMetadata *blockcopy)
289 {
290         if(blockcopy->type != block->type) {
291                 printf("FAILED, type mismatch, expected %s, got %s\n", FLAC__MetadataTypeString[block->type], FLAC__MetadataTypeString[blockcopy->type]);
292                 return false;
293         }
294         if(blockcopy->is_last != block->is_last) {
295                 printf("FAILED, is_last mismatch, expected %u, got %u\n", (unsigned)block->is_last, (unsigned)blockcopy->is_last);
296                 return false;
297         }
298         if(blockcopy->length != block->length) {
299                 printf("FAILED, length mismatch, expected %u, got %u\n", block->length, blockcopy->length);
300                 return false;
301         }
302         switch(block->type) {
303                 case FLAC__METADATA_TYPE_STREAMINFO:
304                         return compare_block_data_streaminfo_(&block->data.stream_info, &blockcopy->data.stream_info);
305                 case FLAC__METADATA_TYPE_PADDING:
306                         return compare_block_data_padding_(&block->data.padding, &blockcopy->data.padding, block->length);
307                 case FLAC__METADATA_TYPE_APPLICATION:
308                         return compare_block_data_application_(&block->data.application, &blockcopy->data.application, block->length);
309                 case FLAC__METADATA_TYPE_SEEKTABLE:
310                         return compare_block_data_seektable_(&block->data.seek_table, &blockcopy->data.seek_table);
311                 case FLAC__METADATA_TYPE_VORBIS_COMMENT:
312                         return compare_block_data_vorbiscomment_(&block->data.vorbis_comment, &blockcopy->data.vorbis_comment);
313                 case FLAC__METADATA_TYPE_CUESHEET:
314                         return compare_block_data_cuesheet_(&block->data.cue_sheet, &blockcopy->data.cue_sheet);
315                 default:
316                         printf("FAILED, invalid block type %u\n", (unsigned)block->type);
317                         return false;
318         }
319 }