FLAC__bool test_format(void)
{
unsigned i;
printf("\n+++ libFLAC unit test: format\n\n");
for(i = 0; i < sizeof(SAMPLE_RATES)/sizeof(SAMPLE_RATES[0]); i++) {
printf("testing FLAC__format_sample_rate_is_valid(%u)... ", SAMPLE_RATES[i].rate);
if(FLAC__format_sample_rate_is_valid(SAMPLE_RATES[i].rate) != SAMPLE_RATES[i].valid) {
printf("FAILED, expected %s, got %s\n", true_false_string_[SAMPLE_RATES[i].valid], true_false_string_[!SAMPLE_RATES[i].valid]);
return false;
}
printf("OK\n");
}
for(i = 0; i < sizeof(VCENTRY_NAMES)/sizeof(VCENTRY_NAMES[0]); i++) {
printf("testing FLAC__format_vorbiscomment_entry_name_is_legal(\"%s\")... ", VCENTRY_NAMES[i].string);
if(FLAC__format_vorbiscomment_entry_name_is_legal(VCENTRY_NAMES[i].string) != VCENTRY_NAMES[i].valid) {
printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRY_NAMES[i].valid], true_false_string_[!VCENTRY_NAMES[i].valid]);
return false;
}
printf("OK\n");
}
for(i = 0; i < sizeof(VCENTRY_VALUES)/sizeof(VCENTRY_VALUES[0]); i++) {
printf("testing FLAC__format_vorbiscomment_entry_value_is_legal(\"%s\", %u)... ", VCENTRY_VALUES[i].string, VCENTRY_VALUES[i].length);
if(FLAC__format_vorbiscomment_entry_value_is_legal(VCENTRY_VALUES[i].string, VCENTRY_VALUES[i].length) != VCENTRY_VALUES[i].valid) {
printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRY_VALUES[i].valid], true_false_string_[!VCENTRY_VALUES[i].valid]);
return false;
}
printf("OK\n");
}
for(i = 0; i < sizeof(VCENTRY_VALUES_NT)/sizeof(VCENTRY_VALUES_NT[0]); i++) {
printf("testing FLAC__format_vorbiscomment_entry_value_is_legal(\"%s\", -1)... ", VCENTRY_VALUES_NT[i].string);
if(FLAC__format_vorbiscomment_entry_value_is_legal(VCENTRY_VALUES_NT[i].string, (unsigned)(-1)) != VCENTRY_VALUES_NT[i].valid) {
printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRY_VALUES_NT[i].valid], true_false_string_[!VCENTRY_VALUES_NT[i].valid]);
return false;
}
printf("OK\n");
}
for(i = 0; i < sizeof(VCENTRIES)/sizeof(VCENTRIES[0]); i++) {
printf("testing FLAC__format_vorbiscomment_entry_is_legal(\"%s\", %u)... ", VCENTRIES[i].string, VCENTRIES[i].length);
if(FLAC__format_vorbiscomment_entry_is_legal(VCENTRIES[i].string, VCENTRIES[i].length) != VCENTRIES[i].valid) {
printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRIES[i].valid], true_false_string_[!VCENTRIES[i].valid]);
return false;
}
printf("OK\n");
}
printf("\nPASSED!\n");
return true;
}
FLAC__bool FLAC__add_metadata_block(const FLAC__StreamMetadata *metadata, FLAC__BitWriter *bw)
{
unsigned i, j;
const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN))
return false;
/*
* First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string
*/
i = metadata->length;
if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry);
i -= metadata->data.vorbis_comment.vendor_string.length;
i += vendor_string_length;
}
FLAC__ASSERT(i < (1u << FLAC__STREAM_METADATA_LENGTH_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, i, FLAC__STREAM_METADATA_LENGTH_LEN))
return false;
switch(metadata->type) {
case FLAC__METADATA_TYPE_STREAMINFO:
FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.min_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN))
return false;
FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.max_blocksize, FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN))
return false;
FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.min_framesize, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN))
return false;
FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.max_framesize, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN))
return false;
FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.sample_rate, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN))
return false;
FLAC__ASSERT(metadata->data.stream_info.channels > 0);
FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.channels-1, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN))
return false;
FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0);
FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.stream_info.bits_per_sample-1, FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.stream_info.total_samples, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.stream_info.md5sum, 16))
return false;
break;
case FLAC__METADATA_TYPE_PADDING:
if(!FLAC__bitwriter_write_zeroes(bw, metadata->length * 8))
return false;
break;
case FLAC__METADATA_TYPE_APPLICATION:
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.application.id, FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.application.data, metadata->length - (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8)))
return false;
break;
case FLAC__METADATA_TYPE_SEEKTABLE:
for(i = 0; i < metadata->data.seek_table.num_points; i++) {
if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.seek_table.points[i].sample_number, FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.seek_table.points[i].stream_offset, FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.seek_table.points[i].frame_samples, FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN))
return false;
}
break;
case FLAC__METADATA_TYPE_VORBIS_COMMENT:
if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, vendor_string_length))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length))
return false;
if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.num_comments))
return false;
for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) {
if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.comments[i].length))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.vorbis_comment.comments[i].entry, metadata->data.vorbis_comment.comments[i].length))
return false;
}
break;
case FLAC__METADATA_TYPE_CUESHEET:
FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN % 8 == 0);
if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)metadata->data.cue_sheet.media_catalog_number, FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN/8))
return false;
if(!FLAC__bitwriter_write_raw_uint64(bw, metadata->data.cue_sheet.lead_in, FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.cue_sheet.is_cd? 1 : 0, FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN))
return false;
if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.cue_sheet.num_tracks, FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN))
return false;
for(i = 0; i < metadata->data.cue_sheet.num_tracks; i++) {
const FLAC__StreamMetadata_CueSheet_Track *track = metadata->data.cue_sheet.tracks + i;
if(!FLAC__bitwriter_write_raw_uint64(bw, track->offset, FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, track->number, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN))
return false;
FLAC__ASSERT(FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN % 8 == 0);
if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)track->isrc, FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN/8))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, track->type, FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, track->pre_emphasis, FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN))
return false;
if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, track->num_indices, FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN))
return false;
for(j = 0; j < track->num_indices; j++) {
const FLAC__StreamMetadata_CueSheet_Index *index = track->indices + j;
if(!FLAC__bitwriter_write_raw_uint64(bw, index->offset, FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, index->number, FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN))
return false;
if(!FLAC__bitwriter_write_zeroes(bw, FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN))
return false;
}
}
break;
case FLAC__METADATA_TYPE_PICTURE:
{
size_t len;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.type, FLAC__STREAM_METADATA_PICTURE_TYPE_LEN))
return false;
len = strlen(metadata->data.picture.mime_type);
if(!FLAC__bitwriter_write_raw_uint32(bw, len, FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)metadata->data.picture.mime_type, len))
return false;
len = strlen((const char *)metadata->data.picture.description);
if(!FLAC__bitwriter_write_raw_uint32(bw, len, FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.picture.description, len))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.width, FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.height, FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.depth, FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.colors, FLAC__STREAM_METADATA_PICTURE_COLORS_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->data.picture.data_length, FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN))
return false;
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.picture.data, metadata->data.picture.data_length))
return false;
}
break;
default:
if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.unknown.data, metadata->length))
return false;
break;
}
FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw));
return true;
}
FLAC__bool FLAC__frame_add_header(const FLAC__FrameHeader *header, FLAC__BitWriter *bw)
{
unsigned u, blocksize_hint, sample_rate_hint;
FLAC__byte crc;
FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw));
if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_RESERVED_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, (header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER)? 0 : 1, FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN))
return false;
FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE);
/* when this assertion holds true, any legal blocksize can be expressed in the frame header */
FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535u);
blocksize_hint = 0;
switch(header->blocksize) {
case 192: u = 1; break;
case 576: u = 2; break;
case 1152: u = 3; break;
case 2304: u = 4; break;
case 4608: u = 5; break;
case 256: u = 8; break;
case 512: u = 9; break;
case 1024: u = 10; break;
case 2048: u = 11; break;
case 4096: u = 12; break;
case 8192: u = 13; break;
case 16384: u = 14; break;
case 32768: u = 15; break;
default:
if(header->blocksize <= 0x100)
blocksize_hint = u = 6;
else
blocksize_hint = u = 7;
break;
}
if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN))
return false;
FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate));
sample_rate_hint = 0;
switch(header->sample_rate) {
case 88200: u = 1; break;
case 176400: u = 2; break;
case 192000: u = 3; break;
case 8000: u = 4; break;
case 16000: u = 5; break;
case 22050: u = 6; break;
case 24000: u = 7; break;
case 32000: u = 8; break;
case 44100: u = 9; break;
case 48000: u = 10; break;
case 96000: u = 11; break;
default:
if(header->sample_rate <= 255000 && header->sample_rate % 1000 == 0)
sample_rate_hint = u = 12;
else if(header->sample_rate % 10 == 0)
sample_rate_hint = u = 14;
else if(header->sample_rate <= 0xffff)
sample_rate_hint = u = 13;
else
u = 0;
break;
}
if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN))
return false;
FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS);
switch(header->channel_assignment) {
case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT:
u = header->channels - 1;
break;
case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE:
FLAC__ASSERT(header->channels == 2);
u = 8;
break;
case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE:
FLAC__ASSERT(header->channels == 2);
u = 9;
break;
case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE:
FLAC__ASSERT(header->channels == 2);
u = 10;
break;
default:
FLAC__ASSERT(0);
}
if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN))
return false;
FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN));
switch(header->bits_per_sample) {
case 8 : u = 1; break;
case 12: u = 2; break;
case 16: u = 4; break;
case 20: u = 5; break;
case 24: u = 6; break;
default: u = 0; break;
}
if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN))
return false;
if(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) {
if(!FLAC__bitwriter_write_utf8_uint32(bw, header->number.frame_number))
return false;
}
else {
if(!FLAC__bitwriter_write_utf8_uint64(bw, header->number.sample_number))
return false;
}
if(blocksize_hint)
if(!FLAC__bitwriter_write_raw_uint32(bw, header->blocksize-1, (blocksize_hint==6)? 8:16))
return false;
switch(sample_rate_hint) {
case 12:
if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 1000, 8))
return false;
break;
case 13:
if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate, 16))
return false;
break;
case 14:
if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 10, 16))
return false;
break;
}
/* write the CRC */
if(!FLAC__bitwriter_get_write_crc8(bw, &crc))
return false;
if(!FLAC__bitwriter_write_raw_uint32(bw, crc, FLAC__FRAME_HEADER_CRC_LEN))
return false;
return true;
}
FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options)
{
const char *opt = long_options_[option_index].name;
Operation *op;
Argument *arg;
FLAC__bool ok = true;
if(0 == strcmp(opt, "preserve-modtime")) {
options->preserve_modtime = true;
}
else if(0 == strcmp(opt, "with-filename")) {
options->prefix_with_filename = true;
}
else if(0 == strcmp(opt, "no-filename")) {
options->prefix_with_filename = false;
}
else if(0 == strcmp(opt, "no-utf8-convert")) {
options->utf8_convert = false;
}
else if(0 == strcmp(opt, "dont-use-padding")) {
options->use_padding = false;
}
else if(0 == strcmp(opt, "no-cued-seekpoints")) {
options->cued_seekpoints = false;
}
else if(0 == strcmp(opt, "show-md5sum")) {
(void) append_shorthand_operation(options, OP__SHOW_MD5SUM);
}
else if(0 == strcmp(opt, "show-min-blocksize")) {
(void) append_shorthand_operation(options, OP__SHOW_MIN_BLOCKSIZE);
}
else if(0 == strcmp(opt, "show-max-blocksize")) {
(void) append_shorthand_operation(options, OP__SHOW_MAX_BLOCKSIZE);
}
else if(0 == strcmp(opt, "show-min-framesize")) {
(void) append_shorthand_operation(options, OP__SHOW_MIN_FRAMESIZE);
}
else if(0 == strcmp(opt, "show-max-framesize")) {
(void) append_shorthand_operation(options, OP__SHOW_MAX_FRAMESIZE);
}
else if(0 == strcmp(opt, "show-sample-rate")) {
(void) append_shorthand_operation(options, OP__SHOW_SAMPLE_RATE);
}
else if(0 == strcmp(opt, "show-channels")) {
(void) append_shorthand_operation(options, OP__SHOW_CHANNELS);
}
else if(0 == strcmp(opt, "show-bps")) {
(void) append_shorthand_operation(options, OP__SHOW_BPS);
}
else if(0 == strcmp(opt, "show-total-samples")) {
(void) append_shorthand_operation(options, OP__SHOW_TOTAL_SAMPLES);
}
else if(0 == strcmp(opt, "set-md5sum")) {
op = append_shorthand_operation(options, OP__SET_MD5SUM);
FLAC__ASSERT(0 != option_argument);
if(!parse_md5(option_argument, op->argument.streaminfo_md5.value)) {
flac_fprintf(stderr, "ERROR (--%s): bad MD5 sum\n", opt);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-min-blocksize")) {
op = append_shorthand_operation(options, OP__SET_MIN_BLOCKSIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-max-blocksize")) {
op = append_shorthand_operation(options, OP__SET_MAX_BLOCKSIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-min-framesize")) {
op = append_shorthand_operation(options, OP__SET_MIN_FRAMESIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-max-framesize")) {
op = append_shorthand_operation(options, OP__SET_MAX_FRAMESIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-sample-rate")) {
op = append_shorthand_operation(options, OP__SET_SAMPLE_RATE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || !FLAC__format_sample_rate_is_valid(op->argument.streaminfo_uint32.value)) {
flac_fprintf(stderr, "ERROR (--%s): invalid sample rate\n", opt);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-channels")) {
op = append_shorthand_operation(options, OP__SET_CHANNELS);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value > FLAC__MAX_CHANNELS) {
flac_fprintf(stderr, "ERROR (--%s): value must be > 0 and <= %u\n", opt, FLAC__MAX_CHANNELS);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-bps")) {
op = append_shorthand_operation(options, OP__SET_BPS);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BITS_PER_SAMPLE || op->argument.streaminfo_uint32.value > FLAC__MAX_BITS_PER_SAMPLE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BITS_PER_SAMPLE, FLAC__MAX_BITS_PER_SAMPLE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-total-samples")) {
op = append_shorthand_operation(options, OP__SET_TOTAL_SAMPLES);
if(!parse_uint64(option_argument, &(op->argument.streaminfo_uint64.value)) || op->argument.streaminfo_uint64.value >= (((FLAC__uint64)1)<<FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "show-vendor-tag")) {
(void) append_shorthand_operation(options, OP__SHOW_VC_VENDOR);
}
else if(0 == strcmp(opt, "show-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__SHOW_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "remove-all-tags")) {
(void) append_shorthand_operation(options, OP__REMOVE_VC_ALL);
}
else if(0 == strcmp(opt, "remove-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "remove-first-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__REMOVE_VC_FIRSTFIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "set-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__SET_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
op->argument.vc_field.field_value_from_file = false;
if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "set-tag-from-file")) {
const char *violation;
op = append_shorthand_operation(options, OP__SET_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
op->argument.vc_field.field_value_from_file = true;
if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "import-tags-from")) {
op = append_shorthand_operation(options, OP__IMPORT_VC_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-tags-to")) {
op = append_shorthand_operation(options, OP__EXPORT_VC_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "import-cuesheet-from")) {
if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
flac_fprintf(stderr, "ERROR (--%s): may be specified only once\n", opt);
ok = false;
}
op = append_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.import_cuesheet_from.filename))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-cuesheet-to")) {
op = append_shorthand_operation(options, OP__EXPORT_CUESHEET_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "import-picture-from")) {
op = append_shorthand_operation(options, OP__IMPORT_PICTURE_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.specification.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing specification\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-picture-to")) {
arg = find_argument(options, ARG__BLOCK_NUMBER);
op = append_shorthand_operation(options, OP__EXPORT_PICTURE_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.export_picture_to.filename))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
op->argument.export_picture_to.block_number_link = arg? &(arg->value.block_number) : 0;
}
else if(0 == strcmp(opt, "add-seekpoint")) {
const char *violation;
char *spec;
FLAC__ASSERT(0 != option_argument);
if(!parse_add_seekpoint(option_argument, &spec, &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed seekpoint specification \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
else {
op = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
if(0 == op)
op = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
local_strcat(&(op->argument.add_seekpoint.specification), spec);
local_strcat(&(op->argument.add_seekpoint.specification), ";");
free(spec);
}
}
else if(0 == strcmp(opt, "add-replay-gain")) {
(void) append_shorthand_operation(options, OP__ADD_REPLAY_GAIN);
}
else if(0 == strcmp(opt, "remove-replay-gain")) {
const FLAC__byte * const tags[5] = {
GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS,
GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN,
GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK,
GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN,
GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK
};
size_t i;
for(i = 0; i < sizeof(tags)/sizeof(tags[0]); i++) {
op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
op->argument.vc_field_name.value = local_strdup((const char *)tags[i]);
}
}
else if(0 == strcmp(opt, "add-padding")) {
op = append_shorthand_operation(options, OP__ADD_PADDING);
FLAC__ASSERT(0 != option_argument);
if(!parse_add_padding(option_argument, &(op->argument.add_padding.length))) {
flac_fprintf(stderr, "ERROR (--%s): illegal length \"%s\", length must be >= 0 and < 2^%u\n", opt, option_argument, FLAC__STREAM_METADATA_LENGTH_LEN);
ok = false;
}
}
else if(0 == strcmp(opt, "help")) {
options->show_long_help = true;
}
else if(0 == strcmp(opt, "version")) {
options->show_version = true;
}
else if(0 == strcmp(opt, "list")) {
(void) append_major_operation(options, OP__LIST);
}
else if(0 == strcmp(opt, "append")) {
(void) append_major_operation(options, OP__APPEND);
}
else if(0 == strcmp(opt, "remove")) {
(void) append_major_operation(options, OP__REMOVE);
}
else if(0 == strcmp(opt, "remove-all")) {
(void) append_major_operation(options, OP__REMOVE_ALL);
}
else if(0 == strcmp(opt, "merge-padding")) {
(void) append_major_operation(options, OP__MERGE_PADDING);
}
else if(0 == strcmp(opt, "sort-padding")) {
(void) append_major_operation(options, OP__SORT_PADDING);
}
else if(0 == strcmp(opt, "block-number")) {
arg = append_argument(options, ARG__BLOCK_NUMBER);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_number(option_argument, &(arg->value.block_number))) {
flac_fprintf(stderr, "ERROR: malformed block number specification \"%s\"\n", option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "block-type")) {
arg = append_argument(options, ARG__BLOCK_TYPE);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_type(option_argument, &(arg->value.block_type))) {
flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
ok = false;
}
options->args.checks.has_block_type = true;
}
else if(0 == strcmp(opt, "except-block-type")) {
arg = append_argument(options, ARG__EXCEPT_BLOCK_TYPE);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_type(option_argument, &(arg->value.block_type))) {
flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
ok = false;
}
options->args.checks.has_except_block_type = true;
}
else if(0 == strcmp(opt, "data-format")) {
arg = append_argument(options, ARG__DATA_FORMAT);
FLAC__ASSERT(0 != option_argument);
if(!parse_data_format(option_argument, &(arg->value.data_format))) {
flac_fprintf(stderr, "ERROR (--%s): illegal data format \"%s\"\n", opt, option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "application-data-format")) {
FLAC__ASSERT(0 != option_argument);
if(!parse_application_data_format(option_argument, &(options->application_data_format_is_hexdump))) {
flac_fprintf(stderr, "ERROR (--%s): illegal application data format \"%s\"\n", opt, option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "from-file")) {
arg = append_argument(options, ARG__FROM_FILE);
FLAC__ASSERT(0 != option_argument);
arg->value.from_file.file_name = local_strdup(option_argument);
}
else {
FLAC__ASSERT(0);
}
return ok;
}
static int flac_output_open(const char *fname, const char *comment)
{
int fd;
int nch;
FLAC__StreamMetadata padding;
FLAC__StreamMetadata *metadata[4];
int num_metadata = 0;
#ifndef LEGACY_FLAC
FLAC__StreamEncoderInitStatus init_status;
#endif
FLAC_ctx *ctx;
if (flac_ctx == NULL)
flac_session_close();
if (!(flac_ctx = (FLAC_ctx *)calloc(sizeof(FLAC_ctx), 1))) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s", strerror(errno));
return -1;
}
ctx = flac_ctx;
ctx->in_bytes = ctx->out_bytes = 0;
if(strcmp(fname, "-") == 0) {
fd = 1; /* data to stdout */
if (comment == NULL)
comment = "(stdout)";
}
else {
/* Open the audio file */
fd = open(fname, FILE_OUTPUT_MODE);
if(fd < 0) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s",
fname, strerror(errno));
return -1;
}
if(comment == NULL)
comment = fname;
}
dpm.fd = fd;
nch = (dpm.encoding & PE_MONO) ? 1 : 2;
if (0 < flac_options.padding) {
padding.is_last = 0;
padding.type = FLAC__METADATA_TYPE_PADDING;
padding.length = flac_options.padding;
metadata[num_metadata++] = &padding;
}
#ifdef LEGACY_FLAC
#ifdef AU_OGGFLAC
if (flac_options.isogg) {
if ((ctx->encoder.ogg.stream = OggFLAC__stream_encoder_new()) == NULL) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create OggFLAC stream");
flac_session_close();
return -1;
}
OggFLAC__stream_encoder_set_channels(ctx->encoder.ogg.stream, nch);
/* 16bps only */
OggFLAC__stream_encoder_set_bits_per_sample(ctx->encoder.ogg.stream, 16);
/* set sequential number for serial */
serial_number++;
if (serial_number == 1) {
srand(time(NULL));
serial_number = rand();
}
OggFLAC__stream_encoder_set_serial_number(ctx->encoder.ogg.stream, serial_number);
OggFLAC__stream_encoder_set_verify(ctx->encoder.ogg.stream, flac_options.verify);
if (!FLAC__format_sample_rate_is_valid(dpm.rate)) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "invalid sampling rate %d",
dpm.rate);
flac_session_close();
return -1;
}
OggFLAC__stream_encoder_set_sample_rate(ctx->encoder.ogg.stream, dpm.rate);
OggFLAC__stream_encoder_set_qlp_coeff_precision(ctx->encoder.ogg.stream, flac_options.qlp_coeff_precision);
/* expensive! */
OggFLAC__stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.ogg.stream, flac_options.qlp_coeff_precision_search);
if (nch == 2) {
OggFLAC__stream_encoder_set_do_mid_side_stereo(ctx->encoder.ogg.stream, flac_options.mid_side);
OggFLAC__stream_encoder_set_loose_mid_side_stereo(ctx->encoder.ogg.stream, flac_options.adaptive_mid_side);
}
OggFLAC__stream_encoder_set_max_lpc_order(ctx->encoder.ogg.stream, flac_options.max_lpc_order);
OggFLAC__stream_encoder_set_min_residual_partition_order(ctx->encoder.ogg.stream, flac_options.min_residual_partition_order);
OggFLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.ogg.stream, flac_options.max_residual_partition_order);
OggFLAC__stream_encoder_set_blocksize(ctx->encoder.ogg.stream, flac_options.blocksize);
OggFLAC__stream_encoder_set_client_data(ctx->encoder.ogg.stream, ctx);
if (0 < num_metadata)
OggFLAC__stream_encoder_set_metadata(ctx->encoder.ogg.stream, metadata, num_metadata);
/* set callback */
OggFLAC__stream_encoder_set_write_callback(ctx->encoder.ogg.stream, ogg_stream_encoder_write_callback);
ctx->state.ogg = OggFLAC__stream_encoder_init(ctx->encoder.ogg.stream);
if (ctx->state.ogg != OggFLAC__STREAM_ENCODER_OK) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create OggFLAC state (%s)",
OggFLAC__StreamEncoderStateString[ctx->state.ogg]);
flac_session_close();
return -1;
}
}
else
#endif /* AU_OGGFLAC */
if (flac_options.seekable) {
if ((ctx->encoder.flac.s_stream = FLAC__seekable_stream_encoder_new()) == NULL) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC stream");
flac_session_close();
return -1;
}
FLAC__seekable_stream_encoder_set_channels(ctx->encoder.flac.s_stream, nch);
/* 16bps only */
FLAC__seekable_stream_encoder_set_bits_per_sample(ctx->encoder.flac.s_stream, 16);
FLAC__seekable_stream_encoder_set_verify(ctx->encoder.flac.s_stream, flac_options.verify);
if (!FLAC__format_sample_rate_is_valid(dpm.rate)) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "invalid sampling rate %d",
dpm.rate);
flac_session_close();
return -1;
}
FLAC__seekable_stream_encoder_set_sample_rate(ctx->encoder.flac.s_stream, dpm.rate);
FLAC__seekable_stream_encoder_set_qlp_coeff_precision(ctx->encoder.flac.s_stream, flac_options.qlp_coeff_precision);
/* expensive! */
FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.flac.s_stream, flac_options.qlp_coeff_precision_search);
if (nch == 2) {
FLAC__seekable_stream_encoder_set_do_mid_side_stereo(ctx->encoder.flac.s_stream, flac_options.mid_side);
FLAC__seekable_stream_encoder_set_loose_mid_side_stereo(ctx->encoder.flac.s_stream, flac_options.adaptive_mid_side);
}
FLAC__seekable_stream_encoder_set_max_lpc_order(ctx->encoder.flac.s_stream, flac_options.max_lpc_order);
FLAC__seekable_stream_encoder_set_min_residual_partition_order(ctx->encoder.flac.s_stream, flac_options.min_residual_partition_order);
FLAC__seekable_stream_encoder_set_max_residual_partition_order(ctx->encoder.flac.s_stream, flac_options.max_residual_partition_order);
FLAC__seekable_stream_encoder_set_blocksize(ctx->encoder.flac.s_stream, flac_options.blocksize);
FLAC__seekable_stream_encoder_set_client_data(ctx->encoder.flac.s_stream, ctx);
if (0 < num_metadata)
FLAC__seekable_stream_encoder_set_metadata(ctx->encoder.flac.s_stream, metadata, num_metadata);
/* set callback */
/* FLAC__seekable_stream_encoder_set_metadata_callback(ctx->encoder.flac.s_stream, flac_seekable_stream_encoder_metadata_callback); /* */
#if (!defined(__BORLANDC__) && !defined(__POCC__))
FLAC__stream_encoder_set_metadata_callback(ctx->encoder.flac.s_stream, flac_seekable_stream_encoder_metadata_callback); /* */
#endif
FLAC__seekable_stream_encoder_set_write_callback(ctx->encoder.flac.s_stream, flac_seekable_stream_encoder_write_callback);
ctx->state.s_flac = FLAC__seekable_stream_encoder_init(ctx->encoder.flac.s_stream);
if (ctx->state.s_flac != FLAC__SEEKABLE_STREAM_ENCODER_OK) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC state (%s)",
FLAC__SeekableStreamEncoderStateString[ctx->state.s_flac]);
flac_session_close();
return -1;
}
}
else
{
if ((ctx->encoder.flac.stream = FLAC__stream_encoder_new()) == NULL) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC stream");
flac_session_close();
return -1;
}
FLAC__stream_encoder_set_channels(ctx->encoder.flac.stream, nch);
/* 16bps only */
FLAC__stream_encoder_set_bits_per_sample(ctx->encoder.flac.stream, 16);
FLAC__stream_encoder_set_verify(ctx->encoder.flac.stream, flac_options.verify);
if (!FLAC__format_sample_rate_is_valid(dpm.rate)) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "invalid sampling rate %d",
dpm.rate);
flac_session_close();
return -1;
}
FLAC__stream_encoder_set_sample_rate(ctx->encoder.flac.stream, dpm.rate);
FLAC__stream_encoder_set_qlp_coeff_precision(ctx->encoder.flac.stream, flac_options.qlp_coeff_precision);
/* expensive! */
FLAC__stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.flac.stream, flac_options.qlp_coeff_precision_search);
if (nch == 2) {
FLAC__stream_encoder_set_do_mid_side_stereo(ctx->encoder.flac.stream, flac_options.mid_side);
FLAC__stream_encoder_set_loose_mid_side_stereo(ctx->encoder.flac.stream, flac_options.adaptive_mid_side);
}
FLAC__stream_encoder_set_max_lpc_order(ctx->encoder.flac.stream, flac_options.max_lpc_order);
FLAC__stream_encoder_set_min_residual_partition_order(ctx->encoder.flac.stream, flac_options.min_residual_partition_order);
FLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.flac.stream, flac_options.max_residual_partition_order);
FLAC__stream_encoder_set_blocksize(ctx->encoder.flac.stream, flac_options.blocksize);
FLAC__stream_encoder_set_client_data(ctx->encoder.flac.stream, ctx);
if (0 < num_metadata)
FLAC__stream_encoder_set_metadata(ctx->encoder.flac.stream, metadata, num_metadata);
/* set callback */
FLAC__stream_encoder_set_metadata_callback(ctx->encoder.flac.stream, flac_stream_encoder_metadata_callback);
FLAC__stream_encoder_set_write_callback(ctx->encoder.flac.stream, flac_stream_encoder_write_callback);
ctx->state.flac = FLAC__stream_encoder_init(ctx->encoder.flac.stream);
if (ctx->state.flac != FLAC__STREAM_ENCODER_OK) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC state (%s)",
FLAC__StreamEncoderStateString[ctx->state.flac]);
flac_session_close();
return -1;
}
}
#else /* !LEGACY_FLAC */
if ((ctx->encoder.flac.stream = FLAC__stream_encoder_new()) == NULL) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC stream");
flac_session_close();
return -1;
}
#ifdef AU_OGGFLAC
if (flac_options.isogg) {
/* set sequential number for serial */
serial_number++;
if (serial_number == 1) {
srand(time(NULL));
serial_number = rand();
}
FLAC__stream_encoder_set_ogg_serial_number(ctx->encoder.flac.stream, serial_number);
}
#endif /* AU_OGGFLAC */
FLAC__stream_encoder_set_channels(ctx->encoder.flac.stream, nch);
/* 16bps only */
FLAC__stream_encoder_set_bits_per_sample(ctx->encoder.flac.stream, 16);
FLAC__stream_encoder_set_verify(ctx->encoder.flac.stream, flac_options.verify);
if (!FLAC__format_sample_rate_is_valid(dpm.rate)) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "invalid sampling rate %d", dpm.rate);
flac_session_close();
return -1;
}
FLAC__stream_encoder_set_sample_rate(ctx->encoder.flac.stream, dpm.rate);
FLAC__stream_encoder_set_qlp_coeff_precision(ctx->encoder.flac.stream, flac_options.qlp_coeff_precision);
/* expensive! */
FLAC__stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.flac.stream, flac_options.qlp_coeff_precision_search);
if (nch == 2) {
FLAC__stream_encoder_set_do_mid_side_stereo(ctx->encoder.flac.stream, flac_options.mid_side);
FLAC__stream_encoder_set_loose_mid_side_stereo(ctx->encoder.flac.stream, flac_options.adaptive_mid_side);
}
FLAC__stream_encoder_set_max_lpc_order(ctx->encoder.flac.stream, flac_options.max_lpc_order);
FLAC__stream_encoder_set_min_residual_partition_order(ctx->encoder.flac.stream, flac_options.min_residual_partition_order);
FLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.flac.stream, flac_options.max_residual_partition_order);
FLAC__stream_encoder_set_blocksize(ctx->encoder.flac.stream, flac_options.blocksize);
if (0 < num_metadata)
FLAC__stream_encoder_set_metadata(ctx->encoder.flac.stream, metadata, num_metadata);
#ifdef AU_OGGFLAC
if (flac_options.isogg)
init_status = FLAC__stream_encoder_init_ogg_stream(ctx->encoder.flac.stream, flac_stream_encoder_write_callback, NULL, NULL, NULL, ctx);
else
#endif
init_status = FLAC__stream_encoder_init_stream(ctx->encoder.flac.stream, flac_stream_encoder_write_callback, NULL, NULL, NULL, ctx);
if (init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC encoder (init status: %s)", FLAC__StreamEncoderInitStatusString[init_status]);
flac_session_close();
return -1;
}
#endif
return 0;
}
