📄 decode.c
字号:
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
}
}
if(wide_samples > 0) {
decoder_session->samples_processed += wide_samples;
decoder_session->frame_counter++;
if(!(decoder_session->frame_counter & 0x3f))
print_stats(decoder_session);
if(decoder_session->analysis_mode) {
flac__analyze_frame(frame, decoder_session->frame_counter-1, decoder_session->aopts, fout);
}
else if(!decoder_session->test_only) {
if (decoder_session->replaygain.apply) {
bytes_to_write = FLAC__replaygain_synthesis__apply_gain(
u8buffer,
!is_big_endian,
is_unsigned_samples,
buffer,
wide_samples,
channels,
bps, /* source_bps */
bps, /* target_bps */
decoder_session->replaygain.scale,
decoder_session->replaygain.spec.limiter == RGSS_LIMIT__HARD, /* hard_limit */
decoder_session->replaygain.spec.noise_shaping != NOISE_SHAPING_NONE, /* do_dithering */
&decoder_session->replaygain.dither_context
);
}
else if(bps == 8) {
if(is_unsigned_samples) {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
u8buffer[sample] = (FLAC__uint8)(buffer[channel][wide_sample] + 0x80);
}
else {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
s8buffer[sample] = (FLAC__int8)(buffer[channel][wide_sample]);
}
bytes_to_write = sample;
}
else if(bps == 16) {
if(is_unsigned_samples) {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
u16buffer[sample] = (FLAC__uint16)(buffer[channel][wide_sample] + 0x8000);
}
else {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
s16buffer[sample] = (FLAC__int16)(buffer[channel][wide_sample]);
}
if(is_big_endian != is_big_endian_host_) {
unsigned char tmp;
const unsigned bytes = sample * 2;
for(byte = 0; byte < bytes; byte += 2) {
tmp = u8buffer[byte];
u8buffer[byte] = u8buffer[byte+1];
u8buffer[byte+1] = tmp;
}
}
bytes_to_write = 2 * sample;
}
else if(bps == 24) {
if(is_unsigned_samples) {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
u32buffer[sample] = buffer[channel][wide_sample] + 0x800000;
}
else {
for(sample = wide_sample = 0; wide_sample < wide_samples; wide_sample++)
for(channel = 0; channel < channels; channel++, sample++)
s32buffer[sample] = buffer[channel][wide_sample];
}
if(is_big_endian != is_big_endian_host_) {
unsigned char tmp;
const unsigned bytes = sample * 4;
for(byte = 0; byte < bytes; byte += 4) {
tmp = u8buffer[byte];
u8buffer[byte] = u8buffer[byte+3];
u8buffer[byte+3] = tmp;
tmp = u8buffer[byte+1];
u8buffer[byte+1] = u8buffer[byte+2];
u8buffer[byte+2] = tmp;
}
}
if(is_big_endian) {
unsigned lbyte;
const unsigned bytes = sample * 4;
for(lbyte = byte = 0; byte < bytes; ) {
byte++;
u8buffer[lbyte++] = u8buffer[byte++];
u8buffer[lbyte++] = u8buffer[byte++];
u8buffer[lbyte++] = u8buffer[byte++];
}
}
else {
unsigned lbyte;
const unsigned bytes = sample * 4;
for(lbyte = byte = 0; byte < bytes; ) {
u8buffer[lbyte++] = u8buffer[byte++];
u8buffer[lbyte++] = u8buffer[byte++];
u8buffer[lbyte++] = u8buffer[byte++];
byte++;
}
}
bytes_to_write = 3 * sample;
}
else {
FLAC__ASSERT(0);
}
}
}
if(bytes_to_write > 0) {
if(flac__utils_fwrite(u8buffer, 1, bytes_to_write, fout) != bytes_to_write) {
/* if a pipe closed when writing to stdout, we let it go without an error message */
if(errno == EPIPE && decoder_session->fout == stdout)
decoder_session->aborting_due_to_until = true;
decoder_session->abort_flag = true;
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
}
}
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
void metadata_callback(const void *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
DecoderSession *decoder_session = (DecoderSession*)client_data;
(void)decoder;
if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
FLAC__uint64 skip, until;
decoder_session->bps = metadata->data.stream_info.bits_per_sample;
decoder_session->channels = metadata->data.stream_info.channels;
decoder_session->sample_rate = metadata->data.stream_info.sample_rate;
flac__utils_canonicalize_skip_until_specification(decoder_session->skip_specification, decoder_session->sample_rate);
FLAC__ASSERT(decoder_session->skip_specification->value.samples >= 0);
skip = (FLAC__uint64)decoder_session->skip_specification->value.samples;
/* remember, metadata->data.stream_info.total_samples can be 0, meaning 'unknown' */
if(metadata->data.stream_info.total_samples > 0 && skip >= metadata->data.stream_info.total_samples) {
flac__utils_printf(stderr, 1, "%s: ERROR trying to --skip more samples than in stream\n", decoder_session->inbasefilename);
decoder_session->abort_flag = true;
return;
}
else if(metadata->data.stream_info.total_samples == 0 && skip > 0) {
flac__utils_printf(stderr, 1, "%s: ERROR, can't --skip when FLAC metadata has total sample count of 0\n", decoder_session->inbasefilename);
decoder_session->abort_flag = true;
return;
}
FLAC__ASSERT(skip == 0 || 0 == decoder_session->cue_specification);
decoder_session->total_samples = metadata->data.stream_info.total_samples - skip;
/* note that we use metadata->data.stream_info.total_samples instead of decoder_session->total_samples */
if(!canonicalize_until_specification(decoder_session->until_specification, decoder_session->inbasefilename, decoder_session->sample_rate, skip, metadata->data.stream_info.total_samples)) {
decoder_session->abort_flag = true;
return;
}
FLAC__ASSERT(decoder_session->until_specification->value.samples >= 0);
until = (FLAC__uint64)decoder_session->until_specification->value.samples;
if(until > 0) {
FLAC__ASSERT(decoder_session->total_samples != 0);
FLAC__ASSERT(0 == decoder_session->cue_specification);
decoder_session->total_samples -= (metadata->data.stream_info.total_samples - until);
}
if(decoder_session->bps != 8 && decoder_session->bps != 16 && decoder_session->bps != 24) {
flac__utils_printf(stderr, 1, "%s: ERROR: bits per sample is not 8/16/24\n", decoder_session->inbasefilename);
decoder_session->abort_flag = true;
return;
}
}
else if(metadata->type == FLAC__METADATA_TYPE_CUESHEET) {
/* remember, at this point, decoder_session->total_samples can be 0, meaning 'unknown' */
if(decoder_session->total_samples == 0) {
flac__utils_printf(stderr, 1, "%s: ERROR can't use --cue when FLAC metadata has total sample count of 0\n", decoder_session->inbasefilename);
decoder_session->abort_flag = true;
return;
}
flac__utils_canonicalize_cue_specification(decoder_session->cue_specification, &metadata->data.cue_sheet, decoder_session->total_samples, decoder_session->skip_specification, decoder_session->until_specification);
FLAC__ASSERT(!decoder_session->skip_specification->is_relative);
FLAC__ASSERT(decoder_session->skip_specification->value_is_samples);
FLAC__ASSERT(!decoder_session->until_specification->is_relative);
FLAC__ASSERT(decoder_session->until_specification->value_is_samples);
FLAC__ASSERT(decoder_session->skip_specification->value.samples >= 0);
FLAC__ASSERT(decoder_session->until_specification->value.samples >= 0);
FLAC__ASSERT((FLAC__uint64)decoder_session->until_specification->value.samples <= decoder_session->total_samples);
FLAC__ASSERT(decoder_session->skip_specification->value.samples <= decoder_session->until_specification->value.samples);
decoder_session->total_samples = decoder_session->until_specification->value.samples - decoder_session->skip_specification->value.samples;
}
else if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
if (decoder_session->replaygain.spec.apply) {
double gain, peak;
if (!(decoder_session->replaygain.apply = grabbag__replaygain_load_from_vorbiscomment(metadata, decoder_session->replaygain.spec.use_album_gain, &gain, &peak))) {
flac__utils_printf(stderr, 1, "%s: WARNING: can't get %s ReplayGain tag\n", decoder_session->inbasefilename, decoder_session->replaygain.spec.use_album_gain? "album":"track");
}
else {
const char *ls[] = { "no", "peak", "hard" };
const char *ns[] = { "no", "low", "medium", "high" };
decoder_session->replaygain.scale = grabbag__replaygain_compute_scale_factor(peak, gain, decoder_session->replaygain.spec.preamp, decoder_session->replaygain.spec.limiter == RGSS_LIMIT__PEAK);
FLAC__ASSERT(decoder_session->bps > 0 && decoder_session->bps <= 32);
FLAC__replaygain_synthesis__init_dither_context(&decoder_session->replaygain.dither_context, decoder_session->bps, decoder_session->replaygain.spec.noise_shaping);
flac__utils_printf(stderr, 1, "%s: INFO: applying %s ReplayGain (gain=%0.2fdB+preamp=%0.1fdB, %s noise shaping, %s limiting) to output\n", decoder_session->inbasefilename, decoder_session->replaygain.spec.use_album_gain? "album":"track", gain, decoder_session->replaygain.spec.preamp, ns[decoder_session->replaygain.spec.noise_shaping], ls[decoder_session->replaygain.spec.limiter]);
flac__utils_printf(stderr, 1, "%s: WARNING: applying ReplayGain is not lossless\n", decoder_session->inbasefilename);
}
}
}
}
void error_callback(const void *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
{
DecoderSession *decoder_session = (DecoderSession*)client_data;
(void)decoder;
flac__utils_printf(stderr, 1, "%s: *** Got error code %d:%s\n", decoder_session->inbasefilename, status, FLAC__StreamDecoderErrorStatusString[status]);
if(!decoder_session->continue_through_decode_errors)
decoder_session->abort_flag = true;
}
void print_error_with_state(const DecoderSession *d, const char *message)
{
const int ilen = strlen(d->inbasefilename) + 1;
const char *state_string;
flac__utils_printf(stderr, 1, "\n%s: %s\n", d->inbasefilename, message);
#ifdef FLAC__HAS_OGG
if(d->is_ogg) {
state_string = OggFLAC__file_decoder_get_resolved_state_string(d->decoder.ogg.file);
}
else
#endif
{
state_string = FLAC__file_decoder_get_resolved_state_string(d->decoder.flac.file);
}
flac__utils_printf(stderr, 1, "%*s state = %s\n", ilen, "", state_string);
/* print out some more info for some errors: */
if (0 == strcmp(state_string, FLAC__StreamDecoderStateString[FLAC__STREAM_DECODER_UNPARSEABLE_STREAM])) {
flac__utils_printf(stderr, 1,
"\n"
"The FLAC stream may have been created by a more advanced encoder. Try\n"
" metaflac --show-vendor-tag %s\n"
"If the version number is greater than %s, this decoder is probably\n"
"not able to decode the file. If the version number is not, the file\n"
"may be corrupted, or you may have found a bug. In this case please\n"
"submit a bug report to\n"
" http://sourceforge.net/bugs/?func=addbug&group_id=13478\n"
"Make sure to include an email contact in the comment and/or use the\n"
"\"Monitor\" feature to monitor the bug status.\n",
d->inbasefilename, FLAC__VERSION_STRING
);
}
else if (
0 == strcmp(state_string, FLAC__FileDecoderStateString[FLAC__FILE_DECODER_ERROR_OPENING_FILE])
#ifdef FLAC__HAS_OGG
|| 0 == strcmp(state_string, OggFLAC__FileDecoderStateString[OggFLAC__FILE_DECODER_ERROR_OPENING_FILE])
#endif
) {
flac__utils_printf(stderr, 1,
"\n"
"An error occurred opening the input file; it is likely that it does not exist\n"
"or is not readable.\n"
);
}
}
void print_stats(const DecoderSession *decoder_session)
{
if(flac__utils_verbosity_ >= 2) {
#if defined _MSC_VER || defined __MINGW32__
/* with MSVC you have to spoon feed it the casting */
const double progress = (double)(FLAC__int64)decoder_session->samples_processed / (double)(FLAC__int64)decoder_session->total_samples * 100.0;
#else
const double progress = (double)decoder_session->samples_processed / (double)decoder_session->total_samples * 100.0;
#endif
if(decoder_session->total_samples > 0) {
fprintf(stderr, "\r%s: %s%u%% complete",
decoder_session->inbasefilename,
decoder_session->test_only? "testing, " : decoder_session->analysis_mode? "analyzing, " : "",
(unsigned)floor(progress + 0.5)
);
}
else {
fprintf(stderr, "\r%s: %s %u samples",
decoder_session->inbasefilename,
decoder_session->test_only? "tested" : decoder_session->analysis_mode? "analyzed" : "wrote",
(unsigned)decoder_session->samples_processed
);
}
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -