static int flac_session_close() { FLAC_ctx *ctx = flac_ctx; if (dpm.fd > 0) { close(dpm.fd); } dpm.fd = -1; if (ctx != NULL) { if (flac_options.isogg) { if (ctx->encoder.ogg.stream) { FLAC__stream_encoder_finish(ctx->encoder.ogg.stream); FLAC__stream_encoder_delete(ctx->encoder.ogg.stream); } } else if (flac_options.seekable) { if (ctx->encoder.flac.s_stream) { FLAC__stream_encoder_finish(ctx->encoder.flac.s_stream); FLAC__stream_encoder_delete(ctx->encoder.flac.s_stream); } } else { if (ctx->encoder.flac.stream) { FLAC__stream_encoder_finish(ctx->encoder.flac.stream); FLAC__stream_encoder_delete(ctx->encoder.flac.stream); } } free(ctx); flac_ctx = NULL; } return 0; }
void FinishStream() { if(inited) { if(!started) { StartStream(); } ASSERT(inited && started); FLAC__stream_encoder_finish(encoder); FLAC__stream_encoder_delete(encoder); encoder = nullptr; if(flac_metadata[0]) { FLAC__metadata_object_delete(flac_metadata[0]); flac_metadata[0] = nullptr; } started = false; inited = false; } ASSERT(!inited && !started); }
ACFLACEncoder::~ACFLACEncoder() { if (mEncoder != NULL) { FLAC__stream_encoder_delete(mEncoder); mEncoder = NULL; } }
SoftFlacEncoder::~SoftFlacEncoder() { ALOGV("SoftFlacEncoder::~SoftFlacEncoder()"); if (mFlacStreamEncoder != NULL) { FLAC__stream_encoder_delete(mFlacStreamEncoder); mFlacStreamEncoder = NULL; } free(mInputBufferPcm32); mInputBufferPcm32 = NULL; }
static void flac_session_close() { FLAC_ctx *ctx = flac_ctx; if (dpm.fd > 0) { close(dpm.fd); } dpm.fd = -1; if (ctx != NULL) { #ifdef LEGACY_FLAC #ifdef AU_OGGFLAC if (flac_options.isogg) { if (ctx->encoder.ogg.stream) { OggFLAC__stream_encoder_finish(ctx->encoder.ogg.stream); OggFLAC__stream_encoder_delete(ctx->encoder.ogg.stream); } } else #endif /* AU_OGGFLAC */ if (flac_options.seekable) { if (ctx->encoder.flac.s_stream) { FLAC__seekable_stream_encoder_finish(ctx->encoder.flac.s_stream); FLAC__seekable_stream_encoder_delete(ctx->encoder.flac.s_stream); } } else { if (ctx->encoder.flac.stream) { FLAC__stream_encoder_finish(ctx->encoder.flac.stream); FLAC__stream_encoder_delete(ctx->encoder.flac.stream); } } #else if (ctx->encoder.flac.stream) { FLAC__stream_encoder_finish(ctx->encoder.flac.stream); FLAC__stream_encoder_delete(ctx->encoder.flac.stream); } #endif free(ctx); flac_ctx = NULL; } }
static void flac_encoder_close(struct encoder *_encoder) { struct flac_encoder *encoder = (struct flac_encoder *)_encoder; FLAC__stream_encoder_delete(encoder->fse); pcm_buffer_deinit(&encoder->buffer); pcm_buffer_deinit(&encoder->expand_buffer); }
void SoundFileWriterFlac::close() { if (m_encoder) { // Close the output stream FLAC__stream_encoder_finish(m_encoder); // Destroy the encoder FLAC__stream_encoder_delete(m_encoder); m_encoder = NULL; } }
CEncoderFlac::~CEncoderFlac() { // free the metadata if (m_metadata[0]) FLAC__metadata_object_delete(m_metadata[0]); if (m_metadata[1]) FLAC__metadata_object_delete(m_metadata[1]); // free the encoder if (m_encoder) FLAC__stream_encoder_delete(m_encoder); }
OggFLAC_API void OggFLAC__seekable_stream_encoder_delete(OggFLAC__SeekableStreamEncoder *encoder) { FLAC__ASSERT(0 != encoder); FLAC__ASSERT(0 != encoder->protected_); FLAC__ASSERT(0 != encoder->private_); FLAC__ASSERT(0 != encoder->private_->FLAC_stream_encoder); (void)OggFLAC__seekable_stream_encoder_finish(encoder); FLAC__stream_encoder_delete(encoder->private_->FLAC_stream_encoder); free(encoder->private_); free(encoder->protected_); free(encoder); }
void FlacAudioEncoder::tear_down() { if (not FLAC__stream_encoder_finish(_encoder)) { THROW_EXCEPTION(AudioEncoderException, "ERROR: could not finish encoding"); } FLAC__metadata_object_delete(_metadata[0]); FLAC__metadata_object_delete(_metadata[1]); if (_encoder) { FLAC__stream_encoder_delete(_encoder); _encoder = nullptr; } }
int __stdcall WWFlacRW_EncodeEnd(int id) { FlacEncodeInfo *fei = FlacTInfoFindById<FlacEncodeInfo>(g_flacEncodeInfoMap, id); if (NULL == fei) { return FRT_IdNotFound; } if (NULL != fei->encoder) { FLAC__stream_encoder_delete(fei->encoder); fei->encoder = NULL; } FlacTInfoDelete<FlacEncodeInfo>(g_flacEncodeInfoMap, fei); return FRT_Success; }
static int stop_write(sox_format_t * const ft) { priv_t * p = (priv_t *)ft->priv; FLAC__StreamEncoderState state = FLAC__stream_encoder_get_state(p->encoder); unsigned i; FLAC__stream_encoder_finish(p->encoder); FLAC__stream_encoder_delete(p->encoder); for (i = 0; i < p->num_metadata; ++i) FLAC__metadata_object_delete(p->metadata[i]); free(p->decoded_samples); if (state != FLAC__STREAM_ENCODER_OK) { lsx_fail_errno(ft, SOX_EINVAL, "FLAC ERROR: failed to encode to end of stream"); return SOX_EOF; } return SOX_SUCCESS; }
void Free(void *ctx) { flac_context *context = (flac_context*)ctx; if (context) { // free the metadata if (context->metadata[0]) FLAC__metadata_object_delete(context->metadata[0]); if (context->metadata[1]) FLAC__metadata_object_delete(context->metadata[1]); // free the encoder if (context->encoder) FLAC__stream_encoder_delete(context->encoder); delete context; } }
int WFLACEncoder::Uninitialize() { if(c_fReady) { FLAC__stream_encoder_finish(c_encoder); FLAC__stream_encoder_delete(c_encoder); c_encoder = NULL; } if(c_pcm) free(c_pcm); c_pcm = NULL; c_pcm_size = 0; c_fReady = 0; return 1; }
static bool DecodeFLAC(FILE *f, FILE *of) { fseek(f, 0, SEEK_SET); FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new(); if(decoder == nullptr) { return false; } FLAC__stream_decoder_set_metadata_respond_all(decoder); FLACClientData client; client.of = of; client.started = false; client.encoder = FLAC__stream_encoder_new(); FLAC__StreamDecoderInitStatus initStatus = FLAC__stream_decoder_init_FILE(decoder, f, write_cb, metadata_cb, error_cb, &client); if(initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK || client.encoder == nullptr) { FLAC__stream_decoder_delete(decoder); return false; } FLAC__stream_decoder_process_until_end_of_stream(decoder); FLAC__stream_decoder_finish(decoder); FLAC__stream_decoder_delete(decoder); FLAC__stream_encoder_finish(client.encoder); FLAC__stream_encoder_delete(client.encoder); for(auto m = client.metadata.begin(); m != client.metadata.end(); m++) { FLAC__metadata_object_delete(*m); } return client.started; }
int main(int argc, char *argv[]) { FLAC__bool ok = true; FLAC__StreamEncoder *encoder = 0; FLAC__StreamEncoderInitStatus init_status; FLAC__StreamMetadata *metadata[2]; FLAC__StreamMetadata_VorbisComment_Entry entry; FILE *fin; unsigned sample_rate = 0; unsigned channels = 0; unsigned bps = 0; if(argc != 3) { fprintf(stderr, "usage: %s infile.wav outfile.flac\n", argv[0]); return 1; } if((fin = fopen(argv[1], "rb")) == NULL) { fprintf(stderr, "ERROR: opening %s for output\n", argv[1]); return 1; } /* read wav header and validate it */ if( fread(buffer, 1, 44, fin) != 44 || memcmp(buffer, "RIFF", 4) || memcmp(buffer+8, "WAVEfmt \020\000\000\000\001\000\002\000", 16) || memcmp(buffer+32, "\004\000\020\000data", 8) ) { fprintf(stderr, "ERROR: invalid/unsupported WAVE file, only 16bps stereo WAVE in canonical form allowed\n"); fclose(fin); return 1; } sample_rate = ((((((unsigned)buffer[27] << 8) | buffer[26]) << 8) | buffer[25]) << 8) | buffer[24]; channels = 2; bps = 16; total_samples = (((((((unsigned)buffer[43] << 8) | buffer[42]) << 8) | buffer[41]) << 8) | buffer[40]) / 4; /* allocate the encoder */ if((encoder = FLAC__stream_encoder_new()) == NULL) { fprintf(stderr, "ERROR: allocating encoder\n"); fclose(fin); return 1; } ok &= FLAC__stream_encoder_set_verify(encoder, true); ok &= FLAC__stream_encoder_set_compression_level(encoder, 5); ok &= FLAC__stream_encoder_set_channels(encoder, channels); ok &= FLAC__stream_encoder_set_bits_per_sample(encoder, bps); ok &= FLAC__stream_encoder_set_sample_rate(encoder, sample_rate); ok &= FLAC__stream_encoder_set_total_samples_estimate(encoder, total_samples); /* now add some metadata; we'll add some tags and a padding block */ if(ok) { if( (metadata[0] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)) == NULL || (metadata[1] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)) == NULL || /* there are many tag (vorbiscomment) functions but these are convenient for this particular use: */ !FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "ARTIST", "Some Artist") || !FLAC__metadata_object_vorbiscomment_append_comment(metadata[0], entry, /*copy=*/false) || /* copy=false: let metadata object take control of entry's allocated string */ !FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "YEAR", "1984") || !FLAC__metadata_object_vorbiscomment_append_comment(metadata[0], entry, /*copy=*/false) ) { fprintf(stderr, "ERROR: out of memory or tag error\n"); ok = false; } metadata[1]->length = 1234; /* set the padding length */ ok = FLAC__stream_encoder_set_metadata(encoder, metadata, 2); } /* initialize encoder */ if(ok) { init_status = FLAC__stream_encoder_init_file(encoder, argv[2], progress_callback, /*client_data=*/NULL); if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { fprintf(stderr, "ERROR: initializing encoder: %s\n", FLAC__StreamEncoderInitStatusString[init_status]); ok = false; } } /* read blocks of samples from WAVE file and feed to encoder */ if(ok) { size_t left = (size_t)total_samples; while(ok && left) { size_t need = (left>READSIZE? (size_t)READSIZE : (size_t)left); if(fread(buffer, channels*(bps/8), need, fin) != need) { fprintf(stderr, "ERROR: reading from WAVE file\n"); ok = false; } else { /* convert the packed little-endian 16-bit PCM samples from WAVE into an interleaved FLAC__int32 buffer for libFLAC */ size_t i; for(i = 0; i < need*channels; i++) { /* inefficient but simple and works on big- or little-endian machines */ pcm[i] = (FLAC__int32)(((FLAC__int16)(FLAC__int8)buffer[2*i+1] << 8) | (FLAC__int16)buffer[2*i]); } /* feed samples to encoder */ ok = FLAC__stream_encoder_process_interleaved(encoder, pcm, need); } left -= need; } } ok &= FLAC__stream_encoder_finish(encoder); fprintf(stderr, "encoding: %s\n", ok? "succeeded" : "FAILED"); fprintf(stderr, " state: %s\n", FLAC__StreamEncoderStateString[FLAC__stream_encoder_get_state(encoder)]); /* now that encoding is finished, the metadata can be freed */ FLAC__metadata_object_delete(metadata[0]); FLAC__metadata_object_delete(metadata[1]); FLAC__stream_encoder_delete(encoder); fclose(fin); return 0; }
int WFLACEncoder::Initialize(unsigned int nSampleRate, unsigned int nNumberOfChannels, unsigned int nBitPerSample, unsigned int custom_value, TEncoderReadCallback read_callback, TEncoderWriteCallback write_callback, TEncoderSeekCallback seek_callback, TEncoderTellCallback tell_callback) { c_nSampleRate = nSampleRate; c_nNumberOfChannels = nNumberOfChannels; c_nBitBerSample = nBitPerSample; c_read_calllback = read_callback; c_write_callback = write_callback; c_seek_callback = seek_callback; c_tell_callback = tell_callback; c_user_data = (void*) custom_value; if((c_encoder = FLAC__stream_encoder_new()) == NULL) { err(ENCODER_INITIALIZATION_ERROR); return 0; } FLAC__bool ok = true; ok &= FLAC__stream_encoder_set_verify(c_encoder, false); ok &= FLAC__stream_encoder_set_compression_level(c_encoder, 5); ok &= FLAC__stream_encoder_set_channels(c_encoder, c_nNumberOfChannels); ok &= FLAC__stream_encoder_set_bits_per_sample(c_encoder, c_nBitBerSample); ok &= FLAC__stream_encoder_set_sample_rate(c_encoder, c_nSampleRate); ok &= FLAC__stream_encoder_set_total_samples_estimate(c_encoder, 0); if(!ok) { FLAC__stream_encoder_delete(c_encoder); c_encoder = NULL; err(ENCODER_INITIALIZATION_ERROR); return 0; } if(c_fOgg) { if(FLAC__stream_encoder_init_ogg_stream(c_encoder, f_read_callback, f_write_callback, f_seek_callback, f_tell_callback, NULL, this) != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { FLAC__stream_encoder_delete(c_encoder); c_encoder = NULL; err(ENCODER_FILEOPEN_ERROR); return 0; } } else { if(FLAC__stream_encoder_init_stream(c_encoder, f_write_callback, f_seek_callback, f_tell_callback, NULL, this) != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { FLAC__stream_encoder_delete(c_encoder); c_encoder = NULL; err(ENCODER_FILEOPEN_ERROR); return 0; } } c_fReady = 1; return 1; }
QString & SampleBuffer::toBase64( QString & _dst ) const { #ifdef LMMS_HAVE_FLAC_STREAM_ENCODER_H const f_cnt_t FRAMES_PER_BUF = 1152; FLAC__StreamEncoder * flac_enc = FLAC__stream_encoder_new(); FLAC__stream_encoder_set_channels( flac_enc, DEFAULT_CHANNELS ); FLAC__stream_encoder_set_blocksize( flac_enc, FRAMES_PER_BUF ); /* FLAC__stream_encoder_set_do_exhaustive_model_search( flac_enc, true ); FLAC__stream_encoder_set_do_mid_side_stereo( flac_enc, true );*/ FLAC__stream_encoder_set_sample_rate( flac_enc, engine::mixer()->sampleRate() ); QBuffer ba_writer; ba_writer.open( QBuffer::WriteOnly ); FLAC__stream_encoder_set_write_callback( flac_enc, flacStreamEncoderWriteCallback ); FLAC__stream_encoder_set_metadata_callback( flac_enc, flacStreamEncoderMetadataCallback ); FLAC__stream_encoder_set_client_data( flac_enc, &ba_writer ); if( FLAC__stream_encoder_init( flac_enc ) != FLAC__STREAM_ENCODER_OK ) { printf( "error within FLAC__stream_encoder_init()!\n" ); } f_cnt_t frame_cnt = 0; while( frame_cnt < m_frames ) { f_cnt_t remaining = qMin<f_cnt_t>( FRAMES_PER_BUF, m_frames - frame_cnt ); FLAC__int32 buf[FRAMES_PER_BUF * DEFAULT_CHANNELS]; for( f_cnt_t f = 0; f < remaining; ++f ) { for( ch_cnt_t ch = 0; ch < DEFAULT_CHANNELS; ++ch ) { buf[f*DEFAULT_CHANNELS+ch] = (FLAC__int32)( Mixer::clip( m_data[f+frame_cnt][ch] ) * OUTPUT_SAMPLE_MULTIPLIER ); } } FLAC__stream_encoder_process_interleaved( flac_enc, buf, remaining ); frame_cnt += remaining; } FLAC__stream_encoder_finish( flac_enc ); FLAC__stream_encoder_delete( flac_enc ); printf("%d %d\n", frame_cnt, (int)ba_writer.size() ); ba_writer.close(); base64::encode( ba_writer.buffer().data(), ba_writer.buffer().size(), _dst ); #else /* LMMS_HAVE_FLAC_STREAM_ENCODER_H */ base64::encode( (const char *) m_data, m_frames * sizeof( sampleFrame ), _dst ); #endif /* LMMS_HAVE_FLAC_STREAM_ENCODER_H */ return _dst; }
int __stdcall WWFlacRW_EncodeInit(const WWFlacMetadata &meta) { FLAC__bool ok = true; FLAC__StreamMetadata_VorbisComment_Entry entry; FlacEncodeInfo *fei = FlacTInfoNew<FlacEncodeInfo>(g_flacEncodeInfoMap); if (NULL == fei) { return FRT_OtherError; } fei->errorCode = FRT_Success; fei->sampleRate = meta.sampleRate; fei->channels = meta.channels; fei->bitsPerSample = meta.bitsPerSample; fei->totalSamples = meta.totalSamples; fei->totalBytesPerChannel = meta.totalSamples * fei->bitsPerSample/8; fei->pictureBytes = meta.pictureBytes; assert(NULL == fei->buffPerChannel); fei->buffPerChannel = new uint8_t*[fei->channels]; if (NULL == fei->buffPerChannel) { return FRT_MemoryExhausted; } memset(fei->buffPerChannel, 0, sizeof(uint8_t*)*fei->channels); WCTOUTF8(titleStr); WCTOUTF8(artistStr); WCTOUTF8(albumStr); WCTOUTF8(albumArtistStr); WCTOUTF8(genreStr); WCTOUTF8(dateStr); WCTOUTF8(trackNumberStr); WCTOUTF8(discNumberStr); WCTOUTF8(pictureMimeTypeStr); WCTOUTF8(pictureDescriptionStr); if((fei->encoder = FLAC__stream_encoder_new()) == NULL) { dprintf("FLAC__stream_encoder_new failed\n"); fei->errorCode = FRT_OtherError; goto end; } ok &= FLAC__stream_encoder_set_verify(fei->encoder, true); ok &= FLAC__stream_encoder_set_compression_level(fei->encoder, 5); ok &= FLAC__stream_encoder_set_channels(fei->encoder, fei->channels); ok &= FLAC__stream_encoder_set_bits_per_sample(fei->encoder, fei->bitsPerSample); ok &= FLAC__stream_encoder_set_sample_rate(fei->encoder, fei->sampleRate); ok &= FLAC__stream_encoder_set_total_samples_estimate(fei->encoder, fei->totalSamples); if(!ok) { dprintf("FLAC__stream_encoder_set_??? failed\n"); fei->errorCode = FRT_OtherError; goto end; } if((fei->flacMetaArray[FMT_VorbisComment] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)) == NULL) { dprintf("FLAC__metadata_object_new vorbis comment failed\n"); fei->errorCode = FRT_OtherError; goto end; } if((fei->flacMetaArray[FMT_Picture] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE)) == NULL) { dprintf("FLAC__metadata_object_new picture failed\n"); fei->errorCode = FRT_OtherError; goto end; } fei->flacMetaCount = 1; ADD_TAG(titleStr, "TITLE"); ADD_TAG(artistStr, "ARTIST"); ADD_TAG(albumStr, "ALBUM"); ADD_TAG(albumArtistStr, "ALBUMARTIST"); ADD_TAG(genreStr, "GENRE"); ADD_TAG(dateStr, "DATE"); ADD_TAG(trackNumberStr, "TRACKNUMBER"); ADD_TAG(discNumberStr, "DISCNUMBER"); end: if (fei->errorCode < 0) { if (NULL != fei->encoder) { FLAC__stream_encoder_delete(fei->encoder); fei->encoder = NULL; } DeleteFlacMetaArray(fei); int result = fei->errorCode; FlacTInfoDelete<FlacEncodeInfo>(g_flacEncodeInfoMap, fei); fei = NULL; return result; } return fei->id; }
int __stdcall WWFlacRW_EncodeRun(int id, const wchar_t *path) { FILE *fp = NULL; errno_t ercd; int64_t left; int64_t readPos; int64_t writePos; FLAC__bool ok = true; FLAC__int32 *pcm = NULL; if (NULL == path || wcslen(path) == 0) { return FRT_BadParams; } FLAC__StreamEncoderInitStatus initStatus = FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; FlacEncodeInfo *fei = FlacTInfoFindById<FlacEncodeInfo>(g_flacEncodeInfoMap, id); if (NULL == fei) { return FRT_IdNotFound; } if (0 < fei->pictureBytes && fei->pictureData == NULL) { dprintf("%s picture data is not set yet.\n", __FUNCTION__); return FRT_DataNotReady; } assert(fei->buffPerChannel); ok = FLAC__stream_encoder_set_metadata(fei->encoder, &fei->flacMetaArray[0], fei->flacMetaCount); if(!ok) { dprintf("FLAC__stream_encoder_set_metadata failed\n"); fei->errorCode = FRT_OtherError; goto end; } for (int ch=0; ch<fei->channels; ++ch) { if (fei->buffPerChannel[ch] == NULL){ dprintf("%s pcm buffer is not set yet.\n", __FUNCTION__); return FRT_DataNotReady; } } if (fei->bitsPerSample != 16 && fei->bitsPerSample != 24) { return FRT_InvalidBitsPerSample; } pcm = new FLAC__int32[FLACENCODE_READFRAMES * fei->channels]; if (pcm == NULL) { return FRT_MemoryExhausted; } // Windowsでは、この方法でファイルを開かなければならぬ。 wcsncpy_s(fei->path, path, (sizeof fei->path)/2-1); ercd = _wfopen_s(&fp, fei->path, L"wb"); if (ercd != 0 || NULL == fp) { fei->errorCode = FRT_FileOpenError; goto end; } initStatus = FLAC__stream_encoder_init_FILE(fei->encoder, fp, ProgressCallback, fei); if(initStatus != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { dprintf("FLAC__stream_encoder_init_FILE failed %s\n", FLAC__StreamEncoderInitStatusString[initStatus]); switch (initStatus) { case FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR: { FLAC__StreamDecoderState state = FLAC__stream_encoder_get_verify_decoder_state(fei->encoder); dprintf("decoderState=%d\n", state); } fei->errorCode = FRT_EncoderError; goto end; case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS: fei->errorCode = FRT_InvalidNumberOfChannels; goto end; case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE: fei->errorCode = FRT_InvalidBitsPerSample; goto end; case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE: fei->errorCode = FRT_InvalidSampleRate; goto end; case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA: fei->errorCode = FRT_InvalidMetadata; goto end; case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS: case FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED: case FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER: case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE: case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER: case FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION: case FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER: case FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE: default: fei->errorCode = FRT_OtherError; goto end; } } fp = NULL; readPos = 0; left = fei->totalSamples; while(ok && left) { uint32_t need = left>FLACENCODE_READFRAMES ? FLACENCODE_READFRAMES : (unsigned int)left; // create interleaved PCM samples to pcm[] writePos = 0; switch (fei->bitsPerSample) { case 16: for (uint32_t i=0; i<need; ++i) { for (int ch=0; ch<fei->channels;++ch) { uint8_t *p = &fei->buffPerChannel[ch][readPos]; int v = (p[0]<<16) + (p[1]<<24); pcm[writePos] = v>>16; ++writePos; } readPos += 2; } break; case 24: for (uint32_t i=0; i<need; ++i) { for (int ch=0; ch<fei->channels;++ch) { uint8_t *p = &fei->buffPerChannel[ch][readPos]; int v = (p[0]<<8) + (p[1]<<16) + (p[2]<<24); pcm[writePos] = v >> 8; ++writePos; } readPos += 3; } break; default: assert(0); break; } ok = FLAC__stream_encoder_process_interleaved(fei->encoder, pcm, need); left -= need; } if (!ok) { dprintf("FLAC__stream_encoder_process_interleaved failed"); fei->errorCode = FRT_EncoderProcessFailed; } end: delete [] pcm; pcm = NULL; if (NULL != fp) { fclose(fp); fp = NULL; } if (NULL != fei->encoder) { if (initStatus == FLAC__STREAM_ENCODER_INIT_STATUS_OK) { FLAC__stream_encoder_finish(fei->encoder); } DeleteFlacMetaArray(fei); FLAC__stream_encoder_delete(fei->encoder); fei->encoder = NULL; } if (fei->errorCode < 0) { int result = fei->errorCode; FlacTInfoDelete<FlacEncodeInfo>(g_flacEncodeInfoMap, fei); fei = NULL; return result; } return fei->id; }
const char* _edje_multisense_encode_to_flac(char *snd_path, SF_INFO sfinfo) { unsigned int total_samples = 0; /* can use a 32-bit number due to WAVE size limitations */ FLAC__bool ok = 1; FLAC__StreamEncoder *encoder = 0; FLAC__StreamEncoderInitStatus init_status; FLAC__StreamMetadata *metadata[2]; FLAC__StreamMetadata_VorbisComment_Entry entry; SNDFILE *sfile; sf_count_t size; char *tmp; sfile = sf_open(snd_path, SFM_READ, &sfinfo); if (!sfile) return NULL; if (!sf_format_check(&sfinfo)) { sf_close(sfile); return NULL; } size = sf_seek(sfile, 0, SEEK_END); sf_seek(sfile, 0, SEEK_SET); tmp = malloc(strlen(snd_path) + 1 + 5); if (!tmp) { sf_close(sfile); return NULL; } strcpy(tmp, snd_path); snd_path = tmp; strcat(snd_path, ".flac"); total_samples = size; /* allocate the encoder */ if ((encoder = FLAC__stream_encoder_new()) == NULL) { ERR("ERROR: Creating FLAC encoder\n"); free(snd_path); sf_close(sfile); return NULL; } /* Verify it's own encoded output. This will slow the encoding process. */ ok &= FLAC__stream_encoder_set_verify(encoder, 1); //Levels range from 0 (fastest, least compression) to 8 (slowest, most compression). //A value larger than 8 will be treated as 8. //5 is used for good compression and moderate compression/decompression speed. ok &= FLAC__stream_encoder_set_compression_level(encoder, 5); ok &= FLAC__stream_encoder_set_channels(encoder, sfinfo.channels); ok &= FLAC__stream_encoder_set_bits_per_sample(encoder, 16); ok &= FLAC__stream_encoder_set_sample_rate(encoder, sfinfo.samplerate); ok &= FLAC__stream_encoder_set_total_samples_estimate(encoder, total_samples); /* now add some metadata; we'll add some tags and a padding block */ if (ok) { if ((metadata[0] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)) == NULL || (metadata[1] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)) == NULL || !FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "Encoder", "flac") || !FLAC__metadata_object_vorbiscomment_append_comment(metadata[0], entry, 0)) { ERR("ERROR: out of memory error or tag error\n"); ok = 0; } metadata[1]->length = 16; /* set the padding length */ ok = FLAC__stream_encoder_set_metadata(encoder, metadata, 2); } /* initialize encoder */ if (ok) { init_status = FLAC__stream_encoder_init_file(encoder, snd_path, NULL, (void *)(long)(total_samples)); if (init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { ERR("ERROR: unable to initialize FLAC encoder: %s\n", FLAC__StreamEncoderInitStatusString[init_status]); ok = 0; } } /* read blocks of samples from WAVE file and feed to encoder */ while (ok) { FLAC__int32 readbuffer[READBUF * 2]; sf_count_t count; int i; count = sf_readf_int(sfile, readbuffer, READBUF); if (count <= 0) break; for (i = 0; i < (count * sfinfo.channels); i++) readbuffer[i] = readbuffer[i] >> 16; ok = FLAC__stream_encoder_process_interleaved(encoder, readbuffer, count); } FLAC__stream_encoder_finish(encoder); /* now that encoding is finished, the metadata can be freed */ FLAC__metadata_object_delete(metadata[0]); FLAC__metadata_object_delete(metadata[1]); FLAC__stream_encoder_delete(encoder); sf_close(sfile); return (snd_path); }
FLAC__bool file_utils__generate_flacfile(FLAC__bool is_ogg, const char *output_filename, off_t *output_filesize, unsigned length, const FLAC__StreamMetadata *streaminfo, FLAC__StreamMetadata **metadata, unsigned num_metadata) { FLAC__int32 samples[1024]; FLAC__StreamEncoder *encoder; FLAC__StreamEncoderInitStatus init_status; encoder_client_struct encoder_client_data; unsigned i, n; FLAC__ASSERT(0 != output_filename); FLAC__ASSERT(0 != streaminfo); FLAC__ASSERT(streaminfo->type == FLAC__METADATA_TYPE_STREAMINFO); FLAC__ASSERT((streaminfo->is_last && num_metadata == 0) || (!streaminfo->is_last && num_metadata > 0)); if(0 == (encoder_client_data.file = fopen(output_filename, "wb"))) return false; encoder = FLAC__stream_encoder_new(); if(0 == encoder) { fclose(encoder_client_data.file); return false; } FLAC__stream_encoder_set_ogg_serial_number(encoder, file_utils__ogg_serial_number); FLAC__stream_encoder_set_verify(encoder, true); FLAC__stream_encoder_set_streamable_subset(encoder, true); FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false); FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false); FLAC__stream_encoder_set_channels(encoder, streaminfo->data.stream_info.channels); FLAC__stream_encoder_set_bits_per_sample(encoder, streaminfo->data.stream_info.bits_per_sample); FLAC__stream_encoder_set_sample_rate(encoder, streaminfo->data.stream_info.sample_rate); FLAC__stream_encoder_set_blocksize(encoder, streaminfo->data.stream_info.min_blocksize); FLAC__stream_encoder_set_max_lpc_order(encoder, 0); FLAC__stream_encoder_set_qlp_coeff_precision(encoder, 0); FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false); FLAC__stream_encoder_set_do_escape_coding(encoder, false); FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, false); FLAC__stream_encoder_set_min_residual_partition_order(encoder, 0); FLAC__stream_encoder_set_max_residual_partition_order(encoder, 0); FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 0); FLAC__stream_encoder_set_total_samples_estimate(encoder, streaminfo->data.stream_info.total_samples); FLAC__stream_encoder_set_metadata(encoder, metadata, num_metadata); if(is_ogg) init_status = FLAC__stream_encoder_init_ogg_stream(encoder, /*read_callback=*/0, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data); else init_status = FLAC__stream_encoder_init_stream(encoder, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data); if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { fclose(encoder_client_data.file); return false; } /* init the dummy sample buffer */ for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++) samples[i] = i & 7; while(length > 0) { n = min(length, sizeof(samples) / sizeof(FLAC__int32)); if(!FLAC__stream_encoder_process_interleaved(encoder, samples, n)) { fclose(encoder_client_data.file); return false; } length -= n; } (void)FLAC__stream_encoder_finish(encoder); fclose(encoder_client_data.file); FLAC__stream_encoder_delete(encoder); if(0 != output_filesize) { struct stat filestats; if(stat(output_filename, &filestats) != 0) return false; else *output_filesize = filestats.st_size; } return true; }
static bool flac_encoder_open(struct encoder *_encoder, struct audio_format *audio_format, GError **error) { struct flac_encoder *encoder = (struct flac_encoder *)_encoder; unsigned bits_per_sample; encoder->audio_format = *audio_format; /* FIXME: flac should support 32bit as well */ switch (audio_format->format) { case SAMPLE_FORMAT_S8: bits_per_sample = 8; break; case SAMPLE_FORMAT_S16: bits_per_sample = 16; break; case SAMPLE_FORMAT_S24_P32: bits_per_sample = 24; break; default: bits_per_sample = 24; audio_format->format = SAMPLE_FORMAT_S24_P32; } /* allocate the encoder */ encoder->fse = FLAC__stream_encoder_new(); if (encoder->fse == NULL) { g_set_error(error, flac_encoder_quark(), 0, "flac_new() failed"); return false; } if (!flac_encoder_setup(encoder, bits_per_sample, error)) { FLAC__stream_encoder_delete(encoder->fse); return false; } encoder->buffer_length = 0; pcm_buffer_init(&encoder->buffer); pcm_buffer_init(&encoder->expand_buffer); /* this immediately outputs data through callback */ #if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7 { FLAC__StreamEncoderState init_status; FLAC__stream_encoder_set_write_callback(encoder->fse, flac_write_callback); init_status = FLAC__stream_encoder_init(encoder->fse); if (init_status != FLAC__STREAM_ENCODER_OK) { g_set_error(error, flac_encoder_quark(), 0, "failed to initialize encoder: %s\n", FLAC__StreamEncoderStateString[init_status]); flac_encoder_close(_encoder); return false; } } #else { FLAC__StreamEncoderInitStatus init_status; init_status = FLAC__stream_encoder_init_stream(encoder->fse, flac_write_callback, NULL, NULL, NULL, encoder); if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { g_set_error(error, flac_encoder_quark(), 0, "failed to initialize encoder: %s\n", FLAC__StreamEncoderInitStatusString[init_status]); flac_encoder_close(_encoder); return false; } } #endif return true; }
int convertWavToFlac(const char *wave_file, const char *flac_file, int split_interval_seconds, char** out_flac_files) { FILE *fin; if((fin = fopen(wave_file, "rb")) == NULL) { fprintf(stderr, "ERROR: opening %s for output\n", wave_file); return 1; } // read wav header and validate it, note this will most likely fail for WAVE files not created by Apple if(fread(buffer, 1, 44, fin) != 44 || memcmp(buffer, "RIFF", 4) || memcmp(buffer+36, "FLLR", 4)) { fprintf(stderr, "ERROR: invalid/unsupported WAVE file\n"); fclose(fin); return 1; } unsigned num_channels = ((unsigned)buffer[23] << 8) | buffer[22];; unsigned sample_rate = ((((((unsigned)buffer[27] << 8) | buffer[26]) << 8) | buffer[25]) << 8) | buffer[24]; //unsigned byte_rate = ((((((unsigned)buffer[31] << 8) | buffer[30]) << 8) | buffer[29]) << 8) | buffer[28]; //unsigned block_align = ((unsigned)buffer[33] << 8) | buffer[32]; unsigned bps = ((unsigned)buffer[35] << 8) | buffer[34]; //Apple puts the number of filler bytes in the 2 bytes following FLLR in the filler chunk //get the int value of the hex unsigned filler_byte_count = ((unsigned)buffer[41] << 8) | buffer[40]; //swallow the filler bytes, exiting if there were not enough if(fread(buffer, 1, filler_byte_count, fin) != filler_byte_count) { fprintf(stderr, "ERROR: invalid number of filler bytes\n"); return 1; } //swallow the beginning of the data chunk, i.e. the word 'data' unsigned data_subchunk_size = 0; if(fread(buffer, 1, 8, fin) != 8 || memcmp(buffer, "data", 4)) { fprintf(stderr, "ERROR: bad data start section\n"); return 1; } else { //Subchunk2Size == NumSamples * NumChannels * BitsPerSample/8 data_subchunk_size = ((((((unsigned)buffer[7] << 8) | buffer[6]) << 8) | buffer[5]) << 8) | buffer[4]; } //create the flac encoder FLAC__StreamEncoder *encoder = FLAC__stream_encoder_new(); FLAC__stream_encoder_set_verify(encoder, true); FLAC__stream_encoder_set_compression_level(encoder, 5); FLAC__stream_encoder_set_channels(encoder, num_channels); FLAC__stream_encoder_set_bits_per_sample(encoder, bps); FLAC__stream_encoder_set_sample_rate(encoder, sample_rate); //unknown total samples FLAC__stream_encoder_set_total_samples_estimate(encoder, 0); char* next_flac_file = malloc(sizeof(char) * 1024); sprintf(next_flac_file, "%s.flac", flac_file); //fprintf(stderr, "writing to new flac file %s\n", next_flac_file); FLAC__stream_encoder_init_file(encoder, next_flac_file, progress_callback, NULL); long total_bytes_read = 0; int did_split_at_interval[1024]; for(int i = 0; i < 1024; i++) { did_split_at_interval[i] = 0; } //read the wav file data chunk until we reach the end of the file. size_t bytes_read = 0; size_t need = (size_t)READSIZE; int flac_file_index = 0; while((bytes_read = fread(buffer, num_channels * (bps/8), need, fin)) != 0) { /* convert the packed little-endian 16-bit PCM samples from WAVE into an interleaved FLAC__int32 buffer for libFLAC */ size_t i; for(i = 0; i < bytes_read*num_channels; i++) { /* inefficient but simple and works on big- or little-endian machines */ pcm[i] = (FLAC__int32)(((FLAC__int16)(FLAC__int8)buffer[2*i+1] << 8) | (FLAC__int16)buffer[2*i]); } /* feed samples to encoder */ FLAC__stream_encoder_process_interleaved(encoder, pcm, bytes_read); total_bytes_read += bytes_read; if(split_interval_seconds > 0) { double elapsed_time_seconds = (total_bytes_read * 16) / (bps * sample_rate); int interval = elapsed_time_seconds / split_interval_seconds; if(interval > 0) { if(!did_split_at_interval[interval-1]) { //finish encoding the current flac file FLAC__stream_encoder_finish(encoder); FLAC__stream_encoder_delete(encoder); //add the flac file to the out_flac_files output parameter *(out_flac_files + flac_file_index) = next_flac_file; flac_file_index += 1; //get a new flac file name //free(next_flac_file); next_flac_file = malloc(sizeof(char) * 1024); sprintf(next_flac_file, "%s_%d.flac", flac_file, interval); //fprintf(stderr, "writing to new flac file %s\n", next_flac_file); //create a new encoder encoder = FLAC__stream_encoder_new(); FLAC__stream_encoder_set_verify(encoder, true); FLAC__stream_encoder_set_compression_level(encoder, 5); FLAC__stream_encoder_set_channels(encoder, num_channels); FLAC__stream_encoder_set_bits_per_sample(encoder, bps); FLAC__stream_encoder_set_sample_rate(encoder, sample_rate); FLAC__stream_encoder_set_total_samples_estimate(encoder, 0); FLAC__stream_encoder_init_file(encoder, next_flac_file, progress_callback, NULL); //mark the interval as split did_split_at_interval[interval-1] = 1; } } } } //fprintf(stderr, "total bytes read: %ld\nbits per sample: %d\nsample rate: %d\n", total_bytes_read, bps, sample_rate); *(out_flac_files + flac_file_index) = next_flac_file; //cleanup FLAC__stream_encoder_finish(encoder); FLAC__stream_encoder_delete(encoder); fclose(fin); return 0; }
bool ofxFlacEncoder::encode(string wavInput, string flacOutput) { //ofLog(OF_LOG_VERBOSE, "init encoding (device%d)",deviceId); FLAC__bool ok = true; FLAC__StreamEncoder *encoder = 0; FLAC__StreamEncoderInitStatus init_status; FILE *fin; unsigned sample_rate = 0; unsigned channels = 0; unsigned bps = 0; if((fin = fopen(ofToDataPath(wavInput).c_str(), "rb")) == NULL){ //ofLog(OF_LOG_ERROR, "ERROR: opening %s for output\n", wavFile); return false; } // read and validate wav header if(fread(buffer, 1, 44, fin) != 44 || memcmp(buffer, "RIFF", 4) || memcmp(buffer + 8, "WAVEfmt \020\000\000\000\001\000\002\000", 16) || memcmp(buffer + 32, "\004\000\020\000data", 8)){ ofLog(OF_LOG_ERROR, "invalid/unsupported WAVE file, only 16bps stereo WAVE in canonical form allowed"); //fclose(fin); //return false; } sample_rate = ((((((unsigned) buffer[27] << 8) | buffer[26]) << 8) | buffer[25]) << 8) | buffer[24]; channels = 2; bps = 16; total_samples = (((((((unsigned) buffer[43] << 8) | buffer[42]) << 8) | buffer[41]) << 8) | buffer[40]) / 4; // allocate the encoder if((encoder = FLAC__stream_encoder_new()) == NULL){ ofLog(OF_LOG_ERROR, " allocating encoder\n"); fclose(fin); return false; } ok &= FLAC__stream_encoder_set_verify(encoder, true); ok &= FLAC__stream_encoder_set_compression_level(encoder, 5); ok &= FLAC__stream_encoder_set_channels(encoder, channels); ok &= FLAC__stream_encoder_set_bits_per_sample(encoder, bps); ok &= FLAC__stream_encoder_set_sample_rate(encoder, sample_rate); ok &= FLAC__stream_encoder_set_total_samples_estimate(encoder, total_samples); // initialize encoder if(ok){ init_status = FLAC__stream_encoder_init_file(encoder, ofToDataPath(flacOutput).c_str(), NULL, NULL); if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK){ ofLog(OF_LOG_ERROR, "initializing encoder: "); ofLog(OF_LOG_ERROR, FLAC__StreamEncoderInitStatusString[init_status]); ok = false; } } //ofLog(OF_LOG_VERBOSE, "start encoding (device%d)",deviceId); /* read blocks of samples from WAVE file and feed to encoder */ if(ok){ size_t left = (size_t) total_samples; while(ok && left){ size_t need = (left > READSIZE ? (size_t) READSIZE : (size_t) left); if(fread(buffer, channels * (bps / 8), need, fin) != need){ ofLog(OF_LOG_ERROR, "reading from WAVE file"); ok = false; }else{ /* convert the packed little-endian 16-bit PCM samples from WAVE into an interleaved FLAC__int32 buffer for libFLAC */ size_t i; for(i = 0; i < need * channels; i++){ /* inefficient but simple and works on big- or little-endian machines */ pcm[i] = (FLAC__int32) (((FLAC__int16) (FLAC__int8) buffer[2 * i + 1] << 8) | (FLAC__int16) buffer[2 * i]); } /* feed samples to encoder */ ok = FLAC__stream_encoder_process_interleaved(encoder, pcm, need); } left -= need; } } ok &= FLAC__stream_encoder_finish(encoder); // fprintf(stderr, "encoding: %s\n", ok ? "succeeded" : "FAILED"); // fprintf(stderr, // " state: %s\n", // FLAC__StreamEncoderStateString[FLAC__stream_encoder_get_state(encoder)]); FLAC__stream_encoder_delete(encoder); fclose(fin); return ok; }
static void flac_close(void) { FLAC__stream_encoder_finish(flac_encoder); FLAC__stream_encoder_delete(flac_encoder); }
void CompressionTool::encodeRaw(const char *rawData, int length, int samplerate, const char *outname, AudioFormat compmode) { print(" - len=%ld, ch=%d, rate=%d, %dbits", length, (rawAudioType.isStereo ? 2 : 1), samplerate, rawAudioType.bitsPerSample); #ifdef USE_VORBIS if (compmode == AUDIO_VORBIS) { char outputString[256] = ""; int numChannels = (rawAudioType.isStereo ? 2 : 1); int totalSamples = length / ((rawAudioType.bitsPerSample / 8) * numChannels); int samplesLeft = totalSamples; int eos = 0; int totalBytes = 0; vorbis_info vi; vorbis_comment vc; vorbis_dsp_state vd; vorbis_block vb; ogg_stream_state os; ogg_page og; ogg_packet op; ogg_packet header; ogg_packet header_comm; ogg_packet header_code; Common::File outputOgg(outname, "wb"); vorbis_info_init(&vi); if (oggparms.nominalBitr > 0) { int result = 0; /* Input is in kbps, function takes bps */ result = vorbis_encode_setup_managed(&vi, numChannels, samplerate, (oggparms.maxBitr > 0 ? 1000 * oggparms.maxBitr : -1), (1000 * oggparms.nominalBitr), (oggparms.minBitr > 0 ? 1000 * oggparms.minBitr : -1)); if (result == OV_EFAULT) { vorbis_info_clear(&vi); error("Error: Internal Logic Fault"); } else if ((result == OV_EINVAL) || (result == OV_EIMPL)) { vorbis_info_clear(&vi); error("Error: Invalid bitrate parameters"); } if (!oggparms.silent) { sprintf(outputString, "Encoding to\n \"%s\"\nat average bitrate %i kbps (", outname, oggparms.nominalBitr); if (oggparms.minBitr > 0) { sprintf(outputString + strlen(outputString), "min %i kbps, ", oggparms.minBitr); } else { sprintf(outputString + strlen(outputString), "no min, "); } if (oggparms.maxBitr > 0) { sprintf(outputString + strlen(outputString), "max %i kbps),\nusing full bitrate management engine\nSet optional hard quality restrictions\n", oggparms.maxBitr); } else { sprintf(outputString + strlen(outputString), "no max),\nusing full bitrate management engine\nSet optional hard quality restrictions\n"); } } } else { int result = 0; /* Quality input is -1 - 10, function takes -0.1 through 1.0 */ result = vorbis_encode_setup_vbr(&vi, numChannels, samplerate, oggparms.quality * 0.1f); if (result == OV_EFAULT) { vorbis_info_clear(&vi); error("Internal Logic Fault"); } else if ((result == OV_EINVAL) || (result == OV_EIMPL)) { vorbis_info_clear(&vi); error("Invalid bitrate parameters"); } if (!oggparms.silent) { sprintf(outputString, "Encoding to\n \"%s\"\nat quality %2.2f", outname, oggparms.quality); } if ((oggparms.minBitr > 0) || (oggparms.maxBitr > 0)) { struct ovectl_ratemanage_arg extraParam; vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_GET, &extraParam); extraParam.bitrate_hard_min = (oggparms.minBitr > 0 ? (1000 * oggparms.minBitr) : -1); extraParam.bitrate_hard_max = (oggparms.maxBitr > 0 ? (1000 * oggparms.maxBitr) : -1); extraParam.management_active = 1; vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_SET, &extraParam); if (!oggparms.silent) { sprintf(outputString + strlen(outputString), " using constrained VBR ("); if (oggparms.minBitr != -1) { sprintf(outputString + strlen(outputString), "min %i kbps, ", oggparms.minBitr); } else { sprintf(outputString + strlen(outputString), "no min, "); } if (oggparms.maxBitr != -1) { sprintf(outputString + strlen(outputString), "max %i kbps)\nSet optional hard quality restrictions\n", oggparms.maxBitr); } else { sprintf(outputString + strlen(outputString), "no max)\nSet optional hard quality restrictions\n"); } } } else { sprintf(outputString + strlen(outputString), "\n"); } } puts(outputString); vorbis_encode_setup_init(&vi); vorbis_comment_init(&vc); vorbis_analysis_init(&vd, &vi); vorbis_block_init(&vd, &vb); ogg_stream_init(&os, 0); vorbis_analysis_headerout(&vd, &vc, &header, &header_comm, &header_code); ogg_stream_packetin(&os, &header); ogg_stream_packetin(&os, &header_comm); ogg_stream_packetin(&os, &header_code); while (!eos) { int result = ogg_stream_flush(&os,&og); if (result == 0) { break; } outputOgg.write(og.header, og.header_len); outputOgg.write(og.body, og.body_len); } while (!eos) { int numSamples = ((samplesLeft < 2048) ? samplesLeft : 2048); float **buffer = vorbis_analysis_buffer(&vd, numSamples); /* We must tell the encoder that we have reached the end of the stream */ if (numSamples == 0) { vorbis_analysis_wrote(&vd, 0); } else { /* Adapted from oggenc 1.1.1 */ if (rawAudioType.bitsPerSample == 8) { const byte *rawDataUnsigned = (const byte *)rawData; for (int i = 0; i < numSamples; i++) { for (int j = 0; j < numChannels; j++) { buffer[j][i] = ((int)(rawDataUnsigned[i * numChannels + j]) - 128) / 128.0f; } } } else if (rawAudioType.bitsPerSample == 16) { if (rawAudioType.isLittleEndian) { for (int i = 0; i < numSamples; i++) { for (int j = 0; j < numChannels; j++) { buffer[j][i] = ((rawData[(i * 2 * numChannels) + (2 * j) + 1] << 8) | (rawData[(i * 2 * numChannels) + (2 * j)] & 0xff)) / 32768.0f; } } } else { for (int i = 0; i < numSamples; i++) { for (int j = 0; j < numChannels; j++) { buffer[j][i] = ((rawData[(i * 2 * numChannels) + (2 * j)] << 8) | (rawData[(i * 2 * numChannels) + (2 * j) + 1] & 0xff)) / 32768.0f; } } } } vorbis_analysis_wrote(&vd, numSamples); } while (vorbis_analysis_blockout(&vd, &vb) == 1) { vorbis_analysis(&vb, NULL); vorbis_bitrate_addblock(&vb); while (vorbis_bitrate_flushpacket(&vd, &op)) { ogg_stream_packetin(&os, &op); while (!eos) { int result = ogg_stream_pageout(&os, &og); if (result == 0) { break; } totalBytes += outputOgg.write(og.header, og.header_len); totalBytes += outputOgg.write(og.body, og.body_len); if (ogg_page_eos(&og)) { eos = 1; } } } } rawData += 2048 * (rawAudioType.bitsPerSample / 8) * numChannels; samplesLeft -= 2048; } ogg_stream_clear(&os); vorbis_block_clear(&vb); vorbis_dsp_clear(&vd); vorbis_info_clear(&vi); if (!oggparms.silent) { print("\nDone encoding file \"%s\"", outname); print("\n\tFile length: %dm %ds", (int)(totalSamples / samplerate / 60), (totalSamples / samplerate % 60)); print("\tAverage bitrate: %.1f kb/s\n", (8.0 * (double)totalBytes / 1000.0) / ((double)totalSamples / (double)samplerate)); } } #endif #ifdef USE_FLAC if (compmode == AUDIO_FLAC) { int i; int numChannels = (rawAudioType.isStereo ? 2 : 1); int samplesPerChannel = length / ((rawAudioType.bitsPerSample / 8) * numChannels); FLAC__StreamEncoder *encoder; FLAC__StreamEncoderInitStatus initStatus; FLAC__int32 *flacData; flacData = (FLAC__int32 *)malloc(samplesPerChannel * numChannels * sizeof(FLAC__int32)); if (rawAudioType.bitsPerSample == 8) { for (i = 0; i < samplesPerChannel * numChannels; i++) { FLAC__uint8 *rawDataUnsigned; rawDataUnsigned = (FLAC__uint8 *)rawData; flacData[i] = (FLAC__int32)rawDataUnsigned[i] - 0x80; } } else if (rawAudioType.bitsPerSample == 16) { /* The rawData pointer is an 8-bit char so we must create a new pointer to access 16-bit samples */ FLAC__int16 *rawData16; rawData16 = (FLAC__int16 *)rawData; for (i = 0; i < samplesPerChannel * numChannels; i++) { flacData[i] = (FLAC__int32)rawData16[i]; } } if (!flacparms.silent) { print("Encoding to\n \"%s\"\nat compression level %d using blocksize %d\n", outname, flacparms.compressionLevel, flacparms.blocksize); } encoder = FLAC__stream_encoder_new(); FLAC__stream_encoder_set_bits_per_sample(encoder, rawAudioType.bitsPerSample); FLAC__stream_encoder_set_blocksize(encoder, flacparms.blocksize); FLAC__stream_encoder_set_channels(encoder, numChannels); FLAC__stream_encoder_set_compression_level(encoder, flacparms.compressionLevel); FLAC__stream_encoder_set_sample_rate(encoder, samplerate); FLAC__stream_encoder_set_streamable_subset(encoder, false); FLAC__stream_encoder_set_total_samples_estimate(encoder, samplesPerChannel); FLAC__stream_encoder_set_verify(encoder, flacparms.verify); initStatus = FLAC__stream_encoder_init_file(encoder, outname, NULL, NULL); if (initStatus != FLAC__STREAM_ENCODER_INIT_STATUS_OK) { char buf[2048]; sprintf(buf, "Error in FLAC encoder. (check the parameters)\nExact error was:%s", FLAC__StreamEncoderInitStatusString[initStatus]); free(flacData); throw ToolException(buf); } else { FLAC__stream_encoder_process_interleaved(encoder, flacData, samplesPerChannel); } FLAC__stream_encoder_finish(encoder); FLAC__stream_encoder_delete(encoder); free(flacData); if (!flacparms.silent) { print("\nDone encoding file \"%s\"", outname); print("\n\tFile length: %dm %ds\n", (int)(samplesPerChannel / samplerate / 60), (samplesPerChannel / samplerate % 60)); } } #endif }