Huge Windows utf8 I/O patch.
[flac.git] / src / test_libs_common / file_utils_flac.c
1 /* test_libFLAC - Unit tester for libFLAC
2  * Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009  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 along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18
19 #if HAVE_CONFIG_H
20 #  include <config.h>
21 #endif
22
23 #include "FLAC/assert.h"
24 #include "FLAC/stream_encoder.h"
25 #include "test_libs_common/file_utils_flac.h"
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <sys/stat.h> /* for stat() */
29 #include "share/compat.h"
30
31 #ifdef min
32 #undef min
33 #endif
34 #define min(a,b) ((a)<(b)?(a):(b))
35
36 const long file_utils__ogg_serial_number = 12345;
37
38 #ifdef FLAC__VALGRIND_TESTING
39 static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
40 {
41         size_t ret = fwrite(ptr, size, nmemb, stream);
42         if(!ferror(stream))
43                 fflush(stream);
44         return ret;
45 }
46 #else
47 #define local__fwrite fwrite
48 #endif
49
50 typedef struct {
51         FILE *file;
52 } encoder_client_struct;
53
54 static FLAC__StreamEncoderWriteStatus encoder_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
55 {
56         encoder_client_struct *ecd = (encoder_client_struct*)client_data;
57
58         (void)encoder, (void)samples, (void)current_frame;
59
60         if(local__fwrite(buffer, 1, bytes, ecd->file) != bytes)
61                 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
62         else
63                 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
64 }
65
66 static void encoder_metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
67 {
68         (void)encoder, (void)metadata, (void)client_data;
69 }
70
71 FLAC__bool file_utils__generate_flacfile(FLAC__bool is_ogg, const char *output_filename, FLAC__off_t *output_filesize, unsigned length, const FLAC__StreamMetadata *streaminfo, FLAC__StreamMetadata **metadata, unsigned num_metadata)
72 {
73         FLAC__int32 samples[1024];
74         FLAC__StreamEncoder *encoder;
75         FLAC__StreamEncoderInitStatus init_status;
76         encoder_client_struct encoder_client_data;
77         unsigned i, n;
78
79         FLAC__ASSERT(0 != output_filename);
80         FLAC__ASSERT(0 != streaminfo);
81         FLAC__ASSERT(streaminfo->type == FLAC__METADATA_TYPE_STREAMINFO);
82         FLAC__ASSERT((streaminfo->is_last && num_metadata == 0) || (!streaminfo->is_last && num_metadata > 0));
83
84         if(0 == (encoder_client_data.file = flac_fopen(output_filename, "wb")))
85                 return false;
86
87         encoder = FLAC__stream_encoder_new();
88         if(0 == encoder) {
89                 fclose(encoder_client_data.file);
90                 return false;
91         }
92
93         FLAC__stream_encoder_set_ogg_serial_number(encoder, file_utils__ogg_serial_number);
94         FLAC__stream_encoder_set_verify(encoder, true);
95         FLAC__stream_encoder_set_streamable_subset(encoder, true);
96         FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false);
97         FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false);
98         FLAC__stream_encoder_set_channels(encoder, streaminfo->data.stream_info.channels);
99         FLAC__stream_encoder_set_bits_per_sample(encoder, streaminfo->data.stream_info.bits_per_sample);
100         FLAC__stream_encoder_set_sample_rate(encoder, streaminfo->data.stream_info.sample_rate);
101         FLAC__stream_encoder_set_blocksize(encoder, streaminfo->data.stream_info.min_blocksize);
102         FLAC__stream_encoder_set_max_lpc_order(encoder, 0);
103         FLAC__stream_encoder_set_qlp_coeff_precision(encoder, 0);
104         FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false);
105         FLAC__stream_encoder_set_do_escape_coding(encoder, false);
106         FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, false);
107         FLAC__stream_encoder_set_min_residual_partition_order(encoder, 0);
108         FLAC__stream_encoder_set_max_residual_partition_order(encoder, 0);
109         FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 0);
110         FLAC__stream_encoder_set_total_samples_estimate(encoder, streaminfo->data.stream_info.total_samples);
111         FLAC__stream_encoder_set_metadata(encoder, metadata, num_metadata);
112
113         if(is_ogg)
114                 init_status = FLAC__stream_encoder_init_ogg_stream(encoder, /*read_callback=*/0, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data);
115         else
116                 init_status = FLAC__stream_encoder_init_stream(encoder, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data);
117
118         if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
119                 fclose(encoder_client_data.file);
120                 return false;
121         }
122
123         /* init the dummy sample buffer */
124         for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
125                 samples[i] = i & 7;
126
127         while(length > 0) {
128                 n = min(length, sizeof(samples) / sizeof(FLAC__int32));
129
130                 if(!FLAC__stream_encoder_process_interleaved(encoder, samples, n)) {
131                         fclose(encoder_client_data.file);
132                         return false;
133                 }
134
135                 length -= n;
136         }
137
138         (void)FLAC__stream_encoder_finish(encoder);
139
140         fclose(encoder_client_data.file);
141
142         FLAC__stream_encoder_delete(encoder);
143
144         if(0 != output_filesize) {
145                 struct _flac_stat filestats;
146
147                 if(flac_stat(output_filename, &filestats) != 0)
148                         return false;
149                 else
150                         *output_filesize = filestats.st_size;
151         }
152
153         return true;
154 }