← Back to branch summary

~ubuntu-branches/ubuntu/hoary/flac/hoary

« back to all changes in this revision

Viewing changes to src/libFLAC/stream_encoder_framing.c

  • Committer: Bazaar Package Importer
  • Author(s): Matt Zimmerman
  • Date: 2004-04-16 15:14:31 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040416151431-eyloggqxpwbwpogz
Tags: 1.1.0-11
Ensure that libFLAC is linked with -lm on all architectures, and
regardless of whether nasm is present

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libFLAC/stream_encoder_framing.c
1
1
/* libFLAC - Free Lossless Audio Codec library
2
 
 * Copyright (C) 2000,2001  Josh Coalson
 
2
 * Copyright (C) 2000,2001,2002,2003  Josh Coalson
3
3
 *
4
4
 * This library is free software; you can redistribute it and/or
5
5
 * modify it under the terms of the GNU Library General Public
18
18
 */
19
19
 
20
20
#include <stdio.h>
 
21
#include <string.h> /* for strlen() */
21
22
#include "private/stream_encoder_framing.h"
22
23
#include "private/crc.h"
23
24
#include "FLAC/assert.h"
27
28
#endif
28
29
#define max(x,y) ((x)>(y)?(x):(y))
29
30
 
30
 
static FLAC__bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method);
31
 
static FLAC__bool subframe_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);
 
31
static FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method);
 
32
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);
32
33
 
33
 
FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetaData *metadata, FLAC__BitBuffer *bb)
 
34
FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitBuffer *bb)
34
35
{
35
 
        unsigned i;
 
36
        unsigned i, j;
 
37
        const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
36
38
 
37
39
        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN))
38
40
                return false;
40
42
        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN))
41
43
                return false;
42
44
 
43
 
        FLAC__ASSERT(metadata->length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
44
 
        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->length, FLAC__STREAM_METADATA_LENGTH_LEN))
 
45
        /*
 
46
         * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string
 
47
         */
 
48
        i = metadata->length;
 
49
        if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
 
50
                FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry);
 
51
                i -= metadata->data.vorbis_comment.vendor_string.length;
 
52
                i += vendor_string_length;
 
53
        }
 
54
        FLAC__ASSERT(i < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
 
55
        if(!FLAC__bitbuffer_write_raw_uint32(bb, i, FLAC__STREAM_METADATA_LENGTH_LEN))
45
56
                return false;
46
57
 
47
58
        switch(metadata->type) {
58
69
                        FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN));
59
70
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN))
60
71
                                return false;
61
 
                        FLAC__ASSERT(metadata->data.stream_info.sample_rate > 0);
62
 
                        FLAC__ASSERT(metadata->data.stream_info.sample_rate < (1u << FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN));
 
72
                        FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate));
63
73
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN))
64
74
                                return false;
65
75
                        FLAC__ASSERT(metadata->data.stream_info.channels > 0);
72
82
                                return false;
73
83
                        if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
74
84
                                return false;
75
 
                        for(i = 0; i < 16; i++) {
76
 
                                if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.stream_info.md5sum[i], 8))
77
 
                                        return false;
78
 
                        }
 
85
                        if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.stream_info.md5sum, 16))
 
86
                                return false;
79
87
                        break;
80
88
                case FLAC__METADATA_TYPE_PADDING:
81
89
                        if(!FLAC__bitbuffer_write_zeroes(bb, metadata->length * 8))
82
90
                                return false;
83
91
                        break;
84
92
                case FLAC__METADATA_TYPE_APPLICATION:
85
 
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.application.id[0], 8))
86
 
                                return false;
87
 
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.application.id[1], 8))
88
 
                                return false;
89
 
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.application.id[2], 8))
90
 
                                return false;
91
 
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.application.id[3], 8))
92
 
                                return false;
93
 
                        for(i = 0; i < metadata->length; i++) {
94
 
                                if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.application.data[i], 8))
95
 
                                        return false;
96
 
                        }
 
93
                        if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))
 
94
                                return false;
 
95
                        if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)))
 
96
                                return false;
97
97
                        break;
98
98
                case FLAC__METADATA_TYPE_SEEKTABLE:
99
99
                        for(i = 0; i < metadata->data.seek_table.num_points; i++) {
105
105
                                        return false;
106
106
                        }
107
107
                        break;
 
108
                case FLAC__METADATA_TYPE_VORBIS_COMMENT:
 
109
                        if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, vendor_string_length))
 
110
                                return false;
 
111
                        if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length))
 
112
                                return false;
 
113
                        if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.num_comments))
 
114
                                return false;
 
115
                        for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
 
116
                                if(!FLAC__bitbuffer_write_raw_uint32_little_endian(bb, metadata->data.vorbis_comment.comments[i].length))
 
117
                                        return false;
 
118
                                if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length))
 
119
                                        return false;
 
120
                        }
 
121
                        break;
 
122
                case FLAC__METADATA_TYPE_CUESHEET:
 
123
                        FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
 
124
                        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))
 
125
                                return false;
 
126
                        if(!FLAC__bitbuffer_write_raw_uint64(bb, metadata->data.cue_sheet.lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN))
 
127
                                return false;
 
128
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.cue_sheet.is_cd? 1 : 0, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN))
 
129
                                return false;
 
130
                        if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN))
 
131
                                return false;
 
132
                        if(!FLAC__bitbuffer_write_raw_uint32(bb, metadata->data.cue_sheet.num_tracks, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN))
 
133
                                return false;
 
134
                        for(i = 0; i < metadata->data.cue_sheet.num_tracks; i++) {
 
135
                                const FLAC__StreamMetadata_CueSheet_Track *track = metadata->data.cue_sheet.tracks + i;
 
136
 
 
137
                                if(!FLAC__bitbuffer_write_raw_uint64(bb, track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN))
 
138
                                        return false;
 
139
                                if(!FLAC__bitbuffer_write_raw_uint32(bb, track->number, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN))
 
140
                                        return false;
 
141
                                FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
 
142
                                if(!FLAC__bitbuffer_write_byte_block(bb, (const FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8))
 
143
                                        return false;
 
144
                                if(!FLAC__bitbuffer_write_raw_uint32(bb, track->type, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN))
 
145
                                        return false;
 
146
                                if(!FLAC__bitbuffer_write_raw_uint32(bb, track->pre_emphasis, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN))
 
147
                                        return false;
 
148
                                if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN))
 
149
                                        return false;
 
150
                                if(!FLAC__bitbuffer_write_raw_uint32(bb, track->num_indices, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN))
 
151
                                        return false;
 
152
                                for(j = 0; j < track->num_indices; j++) {
 
153
                                        const FLAC__StreamMetadata_CueSheet_Index *index = track->indices + j;
 
154
 
 
155
                                        if(!FLAC__bitbuffer_write_raw_uint64(bb, index->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN))
 
156
                                                return false;
 
157
                                        if(!FLAC__bitbuffer_write_raw_uint32(bb, index->number, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN))
 
158
                                                return false;
 
159
                                        if(!FLAC__bitbuffer_write_zeroes(bb, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN))
 
160
                                                return false;
 
161
                                }
 
162
                        }
 
163
                        break;
108
164
                default:
109
 
                        FLAC__ASSERT(0);
 
165
                        if(!FLAC__bitbuffer_write_byte_block(bb, metadata->data.unknown.data, metadata->length))
 
166
                                return false;
 
167
                        break;
110
168
        }
111
169
 
 
170
        FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb));
112
171
        return true;
113
172
}
114
173
 
115
174
FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__bool streamable_subset, FLAC__bool is_last_block, FLAC__BitBuffer *bb)
116
175
{
117
 
        unsigned u, crc8_start, blocksize_hint, sample_rate_hint;
118
 
        FLAC__byte crc8;
119
 
 
120
 
        FLAC__ASSERT(bb->bits == 0); /* assert that we're byte-aligned before writing */
121
 
 
122
 
        crc8_start = bb->bytes;
 
176
        unsigned u, blocksize_hint, sample_rate_hint;
 
177
 
 
178
        FLAC__ASSERT(FLAC__bitbuffer_is_byte_aligned(bb));
123
179
 
124
180
        if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN))
125
181
                return false;
157
213
        if(!FLAC__bitbuffer_write_raw_uint32(bb, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN))
158
214
                return false;
159
215
 
160
 
        FLAC__ASSERT(header->sample_rate > 0 && header->sample_rate < (1u << FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN));
 
216
        FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate));
161
217
        sample_rate_hint = 0;
162
218
        switch(header->sample_rate) {
163
219
                case  8000: u = 4; break;
246
302
        }
247
303
 
248
304
        /* write the CRC */
249
 
        FLAC__ASSERT(bb->buffer[crc8_start] == 0xff); /* MAGIC NUMBER for the first byte of the sync code */
250
 
        FLAC__ASSERT(bb->bits == 0); /* assert that we're byte-aligned */
251
 
        crc8 = FLAC__crc8(bb->buffer+crc8_start, bb->bytes-crc8_start);
252
 
        if(!FLAC__bitbuffer_write_raw_uint32(bb, crc8, FLAC__FRAME_HEADER_CRC_LEN))
 
305
        if(!FLAC__bitbuffer_write_raw_uint32(bb, FLAC__bitbuffer_get_write_crc8(bb), FLAC__FRAME_HEADER_CRC_LEN))
253
306
                return false;
254
307
 
255
308
        return true;
282
335
                if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->warmup[i], subframe_bps))
283
336
                        return false;
284
337
 
285
 
        if(!subframe_add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
 
338
        if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
286
339
                return false;
287
340
        switch(subframe->entropy_coding_method.type) {
288
341
                case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
289
 
                        if(!subframe_add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.parameters, subframe->entropy_coding_method.data.partitioned_rice.raw_bits, subframe->entropy_coding_method.data.partitioned_rice.order))
 
342
                        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))
290
343
                                return false;
291
344
                        break;
292
345
                default:
318
371
                if(!FLAC__bitbuffer_write_raw_int32(bb, subframe->qlp_coeff[i], subframe->qlp_coeff_precision))
319
372
                        return false;
320
373
 
321
 
        if(!subframe_add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
 
374
        if(!add_entropy_coding_method_(bb, &subframe->entropy_coding_method))
322
375
                return false;
323
376
        switch(subframe->entropy_coding_method.type) {
324
377
                case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE:
325
 
                        if(!subframe_add_residual_partitioned_rice_(bb, subframe->residual, residual_samples, subframe->order, subframe->entropy_coding_method.data.partitioned_rice.parameters, subframe->entropy_coding_method.data.partitioned_rice.raw_bits, subframe->entropy_coding_method.data.partitioned_rice.order))
 
378
                        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))
326
379
                                return false;
327
380
                        break;
328
381
                default:
350
403
        return true;
351
404
}
352
405
 
353
 
FLAC__bool subframe_add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method)
 
406
FLAC__bool add_entropy_coding_method_(FLAC__BitBuffer *bb, const FLAC__EntropyCodingMethod *method)
354
407
{
355
408
        if(!FLAC__bitbuffer_write_raw_uint32(bb, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN))
356
409
                return false;
365
418
        return true;
366
419
}
367
420
 
368
 
FLAC__bool subframe_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)
 
421
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)
369
422
{
370
423
        if(partition_order == 0) {
371
424
                unsigned i;