diff options
author | Dave Chapman <dave@dchapman.com> | 2005-02-16 19:33:19 +0000 |
---|---|---|
committer | Dave Chapman <dave@dchapman.com> | 2005-02-16 19:33:19 +0000 |
commit | aa97e4d4981d61808a558c5ab36be6d3bcc2c4f6 (patch) | |
tree | a66b2fcd87f37b26e2d4f360e6c2a9db53eb1b5b /apps/codecs/libFLAC/stream_encoder_framing.c | |
parent | 9b32a1988f848145d96ba2be8cba86e837196df3 (diff) | |
download | rockbox-aa97e4d4981d61808a558c5ab36be6d3bcc2c4f6.tar.gz rockbox-aa97e4d4981d61808a558c5ab36be6d3bcc2c4f6.zip |
Initial import of libFLAC from flac-1.1.2.tar.gz
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@5983 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/codecs/libFLAC/stream_encoder_framing.c')
-rw-r--r-- | apps/codecs/libFLAC/stream_encoder_framing.c | 499 |
1 files changed, 499 insertions, 0 deletions
diff --git a/apps/codecs/libFLAC/stream_encoder_framing.c b/apps/codecs/libFLAC/stream_encoder_framing.c new file mode 100644 index 0000000000..36bf952456 --- /dev/null +++ b/apps/codecs/libFLAC/stream_encoder_framing.c | |||
@@ -0,0 +1,499 @@ | |||
1 | /* libFLAC - Free Lossless Audio Codec library | ||
2 | * Copyright (C) 2000,2001,2002,2003,2004,2005 Josh Coalson | ||
3 | * | ||
4 | * Redistribution and use in source and binary forms, with or without | ||
5 | * modification, are permitted provided that the following conditions | ||
6 | * are met: | ||
7 | * | ||
8 | * - Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * | ||
11 | * - Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * | ||
15 | * - Neither the name of the Xiph.org Foundation nor the names of its | ||
16 | * contributors may be used to endorse or promote products derived from | ||
17 | * this software without specific prior written permission. | ||
18 | * | ||
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
20 | * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
22 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR | ||
23 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
24 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
25 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
26 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
27 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
28 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
29 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
30 | */ | ||
31 | |||
32 | #include <stdio.h> | ||
33 | #include <string.h> /* for strlen() */ | ||
34 | #include "private/stream_encoder_framing.h" | ||
35 | #include "private/crc.h" | ||
36 | #include "FLAC/assert.h" | ||
37 | |||
38 | #ifdef max | ||
39 | #undef max | ||
40 | #endif | ||
41 | #define max(x,y) ((x)>(y)?(x):(y)) | ||
42 | |||
43 | static FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method); | ||
44 | static FLAC__bool add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order); | ||
45 | |||
46 | FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitBuffer *bb) | ||
47 | { | ||
48 | unsigned i, j; | ||
49 | const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING); | ||
50 | |||
51 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN)) | ||
52 | return false; | ||
53 | |||
54 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN)) | ||
55 | return false; | ||
56 | |||
57 | /* | ||
58 | * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string | ||
59 | */ | ||
60 | i = metadata->length; | ||
61 | if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { | ||
62 | FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry); | ||
63 | i -= metadata->data.vorbis_comment.vendor_string.length; | ||
64 | i += vendor_string_length; | ||
65 | } | ||
66 | FLAC__ASSERT(i < (1u << FLAC__STREAM_METADATA_LENGTH_LEN)); | ||
67 | if(!FLAC__bitbuffer_write_raw_uint32(bb, i, FLAC__STREAM_METADATA_LENGTH_LEN)) | ||
68 | return false; | ||
69 | |||
70 | switch(metadata->type) { | ||
71 | case FLAC__METADATA_TYPE_STREAMINFO: | ||
72 | FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)); | ||
73 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)) | ||
74 | return false; | ||
75 | FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)); | ||
76 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)) | ||
77 | return false; | ||
78 | FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)); | ||
79 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) | ||
80 | return false; | ||
81 | FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)); | ||
82 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) | ||
83 | return false; | ||
84 | FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate)); | ||
85 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)) | ||
86 | return false; | ||
87 | FLAC__ASSERT(metadata->data.stream_info.channels > 0); | ||
88 | FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)); | ||
89 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)) | ||
90 | return false; | ||
91 | FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0); | ||
92 | FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); | ||
93 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)) | ||
94 | return false; | ||
95 | if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) | ||
96 | return false; | ||
97 | if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.stream_info.md5sum, 16)) | ||
98 | return false; | ||
99 | break; | ||
100 | case FLAC__METADATA_TYPE_PADDING: | ||
101 | if(!FLAC__bitbuffer_write_zeroes(bb, metadata->length * 8)) | ||
102 | return false; | ||
103 | break; | ||
104 | case FLAC__METADATA_TYPE_APPLICATION: | ||
105 | if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)) | ||
106 | return false; | ||
107 | if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))) | ||
108 | return false; | ||
109 | break; | ||
110 | case FLAC__METADATA_TYPE_SEEKTABLE: | ||
111 | for(i = 0; i < metadata->data.seek_table.num_points; i++) { | ||
112 | if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.seek_table.points[i].sample_number, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN)) | ||
113 | return false; | ||
114 | if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.seek_table.points[i].stream_offset, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN)) | ||
115 | return false; | ||
116 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.seek_table.points[i].frame_samples, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN)) | ||
117 | return false; | ||
118 | } | ||
119 | break; | ||
120 | case FLAC__METADATA_TYPE_VORBIS_COMMENT: | ||
121 | if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, vendor_string_length)) | ||
122 | return false; | ||
123 | if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length)) | ||
124 | return false; | ||
125 | if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.num_comments)) | ||
126 | return false; | ||
127 | for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) { | ||
128 | if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.comments[i].length)) | ||
129 | return false; | ||
130 | if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length)) | ||
131 | return false; | ||
132 | } | ||
133 | break; | ||
134 | case FLAC__METADATA_TYPE_CUESHEET: | ||
135 | FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0); | ||
136 | if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)metadata->data.cue_sheet.media_catalog_number, FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN/8)) | ||
137 | return false; | ||
138 | if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.cue_sheet.lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN)) | ||
139 | return false; | ||
140 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.cue_sheet.is_cd? 1 : 0, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN)) | ||
141 | return false; | ||
142 | if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN)) | ||
143 | return false; | ||
144 | if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.cue_sheet.num_tracks, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN)) | ||
145 | return false; | ||
146 | for(i = 0; i < metadata->data.cue_sheet.num_tracks; i++) { | ||
147 | const FLAC__StreamMetadata_CueSheet_Track *track = metadata->data.cue_sheet.tracks + i; | ||
148 | |||
149 | if(!FLAC__bitbuffer_write_raw_uint64(bb, track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN)) | ||
150 | return false; | ||
151 | if(!FLAC__bitbuffer_write_raw_uint32(bb, track->number, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN)) | ||
152 | return false; | ||
153 | FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0); | ||
154 | if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8)) | ||
155 | return false; | ||
156 | if(!FLAC__bitbuffer_write_raw_uint32(bb, track->type, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN)) | ||
157 | return false; | ||
158 | if(!FLAC__bitbuffer_write_raw_uint32(bb, track->pre_emphasis, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN)) | ||
159 | return false; | ||
160 | if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN)) | ||
161 | return false; | ||
162 | if(!FLAC__bitbuffer_write_raw_uint32(bb, track->num_indices, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN)) | ||
163 | return false; | ||
164 | for(j = 0; j < track->num_indices; j++) { | ||
165 | const FLAC__StreamMetadata_CueSheet_Index *index = track->indices + j; | ||
166 | |||
167 | if(!FLAC__bitbuffer_write_raw_uint64(bb, index->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN)) | ||
168 | return false; | ||
169 | if(!FLAC__bitbuffer_write_raw_uint32(bb, index->number, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN)) | ||
170 | return false; | ||
171 | if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN)) | ||
172 | return false; | ||
173 | } | ||
174 | } | ||
175 | break; | ||
176 | default: | ||
177 | if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.unknown.data, metadata->length)) | ||
178 | return false; | ||
179 | break; | ||
180 | } | ||
181 | |||
182 | FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb)); | ||
183 | return true; | ||
184 | } | ||
185 | |||
186 | FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__bool streamable_subset, FLAC__BitBuffer *bb) | ||
187 | { | ||
188 | unsigned u, blocksize_hint, sample_rate_hint; | ||
189 | |||
190 | FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb)); | ||
191 | |||
192 | if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN)) | ||
193 | return false; | ||
194 | |||
195 | if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_RESERVED_LEN)) | ||
196 | return false; | ||
197 | |||
198 | FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE); | ||
199 | /* when this assertion holds true, any legal blocksize can be expressed in the frame header */ | ||
200 | FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535u); | ||
201 | blocksize_hint = 0; | ||
202 | switch(header->blocksize) { | ||
203 | case 192: u = 1; break; | ||
204 | case 576: u = 2; break; | ||
205 | case 1152: u = 3; break; | ||
206 | case 2304: u = 4; break; | ||
207 | case 4608: u = 5; break; | ||
208 | case 256: u = 8; break; | ||
209 | case 512: u = 9; break; | ||
210 | case 1024: u = 10; break; | ||
211 | case 2048: u = 11; break; | ||
212 | case 4096: u = 12; break; | ||
213 | case 8192: u = 13; break; | ||
214 | case 16384: u = 14; break; | ||
215 | case 32768: u = 15; break; | ||
216 | default: | ||
217 | if(header->blocksize <= 0x100) | ||
218 | blocksize_hint = u = 6; | ||
219 | else if(header->blocksize <= 0x10000) | ||
220 | blocksize_hint = u = 7; | ||
221 | else { | ||
222 | FLAC__ASSERT(0); | ||
223 | return false; | ||
224 | } | ||
225 | break; | ||
226 | } | ||
227 | if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN)) | ||
228 | return false; | ||
229 | |||
230 | FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate)); | ||
231 | sample_rate_hint = 0; | ||
232 | switch(header->sample_rate) { | ||
233 | case 8000: u = 4; break; | ||
234 | case 16000: u = 5; break; | ||
235 | case 22050: u = 6; break; | ||
236 | case 24000: u = 7; break; | ||
237 | case 32000: u = 8; break; | ||
238 | case 44100: u = 9; break; | ||
239 | case 48000: u = 10; break; | ||
240 | case 96000: u = 11; break; | ||
241 | default: | ||
242 | if(header->sample_rate <= 255000 && header->sample_rate % 1000 == 0) | ||
243 | sample_rate_hint = u = 12; | ||
244 | else if(header->sample_rate % 10 == 0) | ||
245 | sample_rate_hint = u = 14; | ||
246 | else if(header->sample_rate <= 0xffff) | ||
247 | sample_rate_hint = u = 13; | ||
248 | else if(streamable_subset) { | ||
249 | FLAC__ASSERT(0); | ||
250 | return false; | ||
251 | } | ||
252 | else | ||
253 | u = 0; | ||
254 | break; | ||
255 | } | ||
256 | if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN)) | ||
257 | return false; | ||
258 | |||
259 | FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS); | ||
260 | switch(header->channel_assignment) { | ||
261 | case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: | ||
262 | u = header->channels - 1; | ||
263 | break; | ||
264 | case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: | ||
265 | FLAC__ASSERT(header->channels == 2); | ||
266 | u = 8; | ||
267 | break; | ||
268 | case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: | ||
269 | FLAC__ASSERT(header->channels == 2); | ||
270 | u = 9; | ||
271 | break; | ||
272 | case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: | ||
273 | FLAC__ASSERT(header->channels == 2); | ||
274 | u = 10; | ||
275 | break; | ||
276 | default: | ||
277 | FLAC__ASSERT(0); | ||
278 | } | ||
279 | if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN)) | ||
280 | return false; | ||
281 | |||
282 | FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); | ||
283 | switch(header->bits_per_sample) { | ||
284 | case 8 : u = 1; break; | ||
285 | case 12: u = 2; break; | ||
286 | case 16: u = 4; break; | ||
287 | case 20: u = 5; break; | ||
288 | case 24: u = 6; break; | ||
289 | default: u = 0; break; | ||
290 | } | ||
291 | if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN)) | ||
292 | return false; | ||
293 | |||
294 | if(!FLAC__bitbuffer_write_raw_uint32(bb, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN)) | ||
295 | return false; | ||
296 | |||
297 | FLAC__ASSERT(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER); | ||
298 | if(!FLAC__bitbuffer_write_utf8_uint32(bb, header->number.frame_number)) | ||
299 | return false; | ||
300 | |||
301 | if(blocksize_hint) | ||
302 | if(!FLAC__bitbuffer_write_raw_uint32(bb, header->blocksize-1, (blocksize_hint==6)? 8:16)) | ||
303 | return false; | ||
304 | |||
305 | switch(sample_rate_hint) { | ||
306 | case 12: | ||
307 | if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate / 1000, 8)) | ||
308 | return false; | ||
309 | break; | ||
310 | case 13: | ||
311 | if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate, 16)) | ||
312 | return false; | ||
313 | break; | ||
314 | case 14: | ||
315 | if(!FLAC__bitbuffer_write_raw_uint32(bb, header->sample_rate / 10, 16)) | ||
316 | return false; | ||
317 | break; | ||
318 | } | ||
319 | |||
320 | /* write the CRC */ | ||
321 | if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__bitbuffer_get_write_crc8(bb), FLAC__FRAME_HEADER_CRC_LEN)) | ||
322 | return false; | ||
323 | |||
324 | return true; | ||
325 | } | ||
326 | |||
327 | FLAC__bool FLAC__subframe_add_constant(const FLAC__Subframe_Constant *subframe, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb) | ||
328 | { | ||
329 | FLAC__bool ok; | ||
330 | |||
331 | ok = | ||
332 | FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN) && | ||
333 | (wasted_bits? FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1) : true) && | ||
334 | FLAC__bitbuffer_write_raw_int32(bb, subframe->value, subframe_bps) | ||
335 | ; | ||
336 | |||
337 | return ok; | ||
338 | } | ||
339 | |||
340 | FLAC__bool FLAC__subframe_add_fixed(const FLAC__Subframe_Fixed *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb) | ||
341 | { | ||
342 | unsigned i; | ||
343 | |||
344 | if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK | (subframe->order<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN)) | ||
345 | return false; | ||
346 | if(wasted_bits) | ||
347 | if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1)) | ||
348 | return false; | ||
349 | |||
350 | for(i = 0; i < subframe->order; i++) | ||
351 | if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps)) | ||
352 | return false; | ||
353 | |||
354 | if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method)) | ||
355 | return false; | ||
356 | switch(subframe->entropy_coding_method.type) { | ||
357 | case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: | ||
358 | if(!add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, subframe->entropy_coding_method.data.partitioned_rice.order)) | ||
359 | return false; | ||
360 | break; | ||
361 | default: | ||
362 | FLAC__ASSERT(0); | ||
363 | } | ||
364 | |||
365 | return true; | ||
366 | } | ||
367 | |||
368 | FLAC__bool FLAC__subframe_add_lpc(const FLAC__Subframe_LPC *subframe, unsigned residual_samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb) | ||
369 | { | ||
370 | unsigned i; | ||
371 | |||
372 | if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK | ((subframe->order-1)<<1) | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN)) | ||
373 | return false; | ||
374 | if(wasted_bits) | ||
375 | if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1)) | ||
376 | return false; | ||
377 | |||
378 | for(i = 0; i < subframe->order; i++) | ||
379 | if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps)) | ||
380 | return false; | ||
381 | |||
382 | if(!FLAC__bitbuffer_write_raw_uint32(bb, subframe->qlp_coeff_precision-1, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN)) | ||
383 | return false; | ||
384 | if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN)) | ||
385 | return false; | ||
386 | for(i = 0; i < subframe->order; i++) | ||
387 | if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->qlp_coeff[i], subframe->qlp_coeff_precision)) | ||
388 | return false; | ||
389 | |||
390 | if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method)) | ||
391 | return false; | ||
392 | switch(subframe->entropy_coding_method.type) { | ||
393 | case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: | ||
394 | if(!add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, subframe->entropy_coding_method.data.partitioned_rice.order)) | ||
395 | return false; | ||
396 | break; | ||
397 | default: | ||
398 | FLAC__ASSERT(0); | ||
399 | } | ||
400 | |||
401 | return true; | ||
402 | } | ||
403 | |||
404 | FLAC__bool FLAC__subframe_add_verbatim(const FLAC__Subframe_Verbatim *subframe, unsigned samples, unsigned subframe_bps, unsigned wasted_bits, FLAC__BitBuffer *bb) | ||
405 | { | ||
406 | unsigned i; | ||
407 | const FLAC__int32 *signal = subframe->data; | ||
408 | |||
409 | if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK | (wasted_bits? 1:0), FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN)) | ||
410 | return false; | ||
411 | if(wasted_bits) | ||
412 | if(!FLAC__bitbuffer_write_unary_unsigned(bb, wasted_bits-1)) | ||
413 | return false; | ||
414 | |||
415 | for(i = 0; i < samples; i++) | ||
416 | if(!FLAC__bitbuffer_write_raw_int32(bb, signal[i], subframe_bps)) | ||
417 | return false; | ||
418 | |||
419 | return true; | ||
420 | } | ||
421 | |||
422 | FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method) | ||
423 | { | ||
424 | if(!FLAC__bitbuffer_write_raw_uint32(bb, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) | ||
425 | return false; | ||
426 | switch(method->type) { | ||
427 | case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: | ||
428 | if(!FLAC__bitbuffer_write_raw_uint32(bb, method->data.partitioned_rice.order, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) | ||
429 | return false; | ||
430 | break; | ||
431 | default: | ||
432 | FLAC__ASSERT(0); | ||
433 | } | ||
434 | return true; | ||
435 | } | ||
436 | |||
437 | FLAC__bool add_residual_partitioned_rice_(FLAC__BitBuffer *bb, const FLAC__int32 residual[], const unsigned residual_samples, const unsigned predictor_order, const unsigned rice_parameters[], const unsigned raw_bits[], const unsigned partition_order) | ||
438 | { | ||
439 | if(partition_order == 0) { | ||
440 | unsigned i; | ||
441 | |||
442 | if(!FLAC__bitbuffer_write_raw_uint32(bb, rice_parameters[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN)) | ||
443 | return false; | ||
444 | if(rice_parameters[0] < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
445 | for(i = 0; i < residual_samples; i++) { | ||
446 | #ifdef FLAC__SYMMETRIC_RICE | ||
447 | if(!FLAC__bitbuffer_write_symmetric_rice_signed(bb, residual[i], rice_parameters[0])) | ||
448 | return false; | ||
449 | #else | ||
450 | if(!FLAC__bitbuffer_write_rice_signed(bb, residual[i], rice_parameters[0])) | ||
451 | return false; | ||
452 | #endif | ||
453 | } | ||
454 | } | ||
455 | else { | ||
456 | if(!FLAC__bitbuffer_write_raw_uint32(bb, raw_bits[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN)) | ||
457 | return false; | ||
458 | for(i = 0; i < residual_samples; i++) { | ||
459 | if(!FLAC__bitbuffer_write_raw_int32(bb, residual[i], raw_bits[0])) | ||
460 | return false; | ||
461 | } | ||
462 | } | ||
463 | return true; | ||
464 | } | ||
465 | else { | ||
466 | unsigned i, j, k = 0, k_last = 0; | ||
467 | unsigned partition_samples; | ||
468 | const unsigned default_partition_samples = (residual_samples+predictor_order) >> partition_order; | ||
469 | for(i = 0; i < (1u<<partition_order); i++) { | ||
470 | if(!FLAC__bitbuffer_write_raw_uint32(bb, rice_parameters[i], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN)) | ||
471 | return false; | ||
472 | partition_samples = default_partition_samples; | ||
473 | if(i == 0) | ||
474 | partition_samples -= predictor_order; | ||
475 | k += partition_samples; | ||
476 | if(rice_parameters[i] < FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { | ||
477 | for(j = k_last; j < k; j++) { | ||
478 | #ifdef FLAC__SYMMETRIC_RICE | ||
479 | if(!FLAC__bitbuffer_write_symmetric_rice_signed(bb, residual[j], rice_parameters[i])) | ||
480 | return false; | ||
481 | #else | ||
482 | if(!FLAC__bitbuffer_write_rice_signed(bb, residual[j], rice_parameters[i])) | ||
483 | return false; | ||
484 | #endif | ||
485 | } | ||
486 | } | ||
487 | else { | ||
488 | if(!FLAC__bitbuffer_write_raw_uint32(bb, raw_bits[i], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN)) | ||
489 | return false; | ||
490 | for(j = k_last; j < k; j++) { | ||
491 | if(!FLAC__bitbuffer_write_raw_int32(bb, residual[j], raw_bits[i])) | ||
492 | return false; | ||
493 | } | ||
494 | } | ||
495 | k_last = k; | ||
496 | } | ||
497 | return true; | ||
498 | } | ||
499 | } | ||