SoftFlacEncoder.cpp revision 2f74ef3cdc192f817ee1121f41765f0852c1d81e
1/* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17//#define LOG_NDEBUG 0 18#define LOG_TAG "SoftFlacEncoder" 19#include <utils/Log.h> 20 21#include "SoftFlacEncoder.h" 22 23#include <media/stagefright/foundation/ADebug.h> 24#include <media/stagefright/MediaDefs.h> 25 26#define FLAC_COMPRESSION_LEVEL_MIN 0 27#define FLAC_COMPRESSION_LEVEL_DEFAULT 5 28#define FLAC_COMPRESSION_LEVEL_MAX 8 29 30namespace android { 31 32template<class T> 33static void InitOMXParams(T *params) { 34 params->nSize = sizeof(T); 35 params->nVersion.s.nVersionMajor = 1; 36 params->nVersion.s.nVersionMinor = 0; 37 params->nVersion.s.nRevision = 0; 38 params->nVersion.s.nStep = 0; 39} 40 41SoftFlacEncoder::SoftFlacEncoder( 42 const char *name, 43 const OMX_CALLBACKTYPE *callbacks, 44 OMX_PTR appData, 45 OMX_COMPONENTTYPE **component) 46 : SimpleSoftOMXComponent(name, callbacks, appData, component), 47 mSignalledError(false), 48 mNumChannels(1), 49 mSampleRate(44100), 50 mCompressionLevel(FLAC_COMPRESSION_LEVEL_DEFAULT), 51 mEncoderWriteData(false), 52 mEncoderReturnedEncodedData(false), 53 mEncoderReturnedNbBytes(0), 54 mInputBufferPcm32(NULL) 55#ifdef WRITE_FLAC_HEADER_IN_FIRST_BUFFER 56 , mHeaderOffset(0) 57 , mWroteHeader(false) 58#endif 59{ 60 ALOGV("SoftFlacEncoder::SoftFlacEncoder(name=%s)", name); 61 initPorts(); 62 63 mFlacStreamEncoder = FLAC__stream_encoder_new(); 64 if (mFlacStreamEncoder == NULL) { 65 ALOGE("SoftFlacEncoder::SoftFlacEncoder(name=%s) error instantiating FLAC encoder", name); 66 mSignalledError = true; 67 } 68 69 if (!mSignalledError) { // no use allocating input buffer if we had an error above 70 mInputBufferPcm32 = (FLAC__int32*) malloc(sizeof(FLAC__int32) * 2 * kMaxNumSamplesPerFrame); 71 if (mInputBufferPcm32 == NULL) { 72 ALOGE("SoftFlacEncoder::SoftFlacEncoder(name=%s) error allocating internal input buffer", name); 73 mSignalledError = true; 74 } 75 } 76} 77 78SoftFlacEncoder::~SoftFlacEncoder() { 79 ALOGV("SoftFlacEncoder::~SoftFlacEncoder()"); 80 if (mFlacStreamEncoder != NULL) { 81 FLAC__stream_encoder_delete(mFlacStreamEncoder); 82 mFlacStreamEncoder = NULL; 83 } 84 free(mInputBufferPcm32); 85 mInputBufferPcm32 = NULL; 86} 87 88OMX_ERRORTYPE SoftFlacEncoder::initCheck() const { 89 if (mSignalledError) { 90 if (mFlacStreamEncoder == NULL) { 91 ALOGE("initCheck() failed due to NULL encoder"); 92 } else if (mInputBufferPcm32 == NULL) { 93 ALOGE("initCheck() failed due to error allocating internal input buffer"); 94 } 95 return OMX_ErrorUndefined; 96 } else { 97 return SimpleSoftOMXComponent::initCheck(); 98 } 99} 100 101void SoftFlacEncoder::initPorts() { 102 ALOGV("SoftFlacEncoder::initPorts()"); 103 104 OMX_PARAM_PORTDEFINITIONTYPE def; 105 InitOMXParams(&def); 106 107 // configure input port of the encoder 108 def.nPortIndex = 0; 109 def.eDir = OMX_DirInput; 110 def.nBufferCountMin = kNumBuffers;// TODO verify that 1 is enough 111 def.nBufferCountActual = def.nBufferCountMin; 112 def.nBufferSize = kMaxNumSamplesPerFrame * sizeof(int16_t) * 2; 113 def.bEnabled = OMX_TRUE; 114 def.bPopulated = OMX_FALSE; 115 def.eDomain = OMX_PortDomainAudio; 116 def.bBuffersContiguous = OMX_FALSE; 117 def.nBufferAlignment = 2; 118 119 def.format.audio.cMIMEType = const_cast<char *>("audio/raw"); 120 def.format.audio.pNativeRender = NULL; 121 def.format.audio.bFlagErrorConcealment = OMX_FALSE; 122 def.format.audio.eEncoding = OMX_AUDIO_CodingPCM; 123 124 addPort(def); 125 126 // configure output port of the encoder 127 def.nPortIndex = 1; 128 def.eDir = OMX_DirOutput; 129 def.nBufferCountMin = kNumBuffers;// TODO verify that 1 is enough 130 def.nBufferCountActual = def.nBufferCountMin; 131 def.nBufferSize = kMaxOutputBufferSize; 132 def.bEnabled = OMX_TRUE; 133 def.bPopulated = OMX_FALSE; 134 def.eDomain = OMX_PortDomainAudio; 135 def.bBuffersContiguous = OMX_FALSE; 136 def.nBufferAlignment = 1; 137 138 def.format.audio.cMIMEType = const_cast<char *>(MEDIA_MIMETYPE_AUDIO_FLAC); 139 def.format.audio.pNativeRender = NULL; 140 def.format.audio.bFlagErrorConcealment = OMX_FALSE; 141 def.format.audio.eEncoding = OMX_AUDIO_CodingFLAC; 142 143 addPort(def); 144} 145 146OMX_ERRORTYPE SoftFlacEncoder::internalGetParameter( 147 OMX_INDEXTYPE index, OMX_PTR params) { 148 ALOGV("SoftFlacEncoder::internalGetParameter(index=0x%x)", index); 149 150 switch (index) { 151 case OMX_IndexParamAudioPcm: 152 { 153 OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams = 154 (OMX_AUDIO_PARAM_PCMMODETYPE *)params; 155 156 if (pcmParams->nPortIndex > 1) { 157 return OMX_ErrorUndefined; 158 } 159 160 pcmParams->eNumData = OMX_NumericalDataSigned; 161 pcmParams->eEndian = OMX_EndianBig; 162 pcmParams->bInterleaved = OMX_TRUE; 163 pcmParams->nBitPerSample = 16; 164 pcmParams->ePCMMode = OMX_AUDIO_PCMModeLinear; 165 pcmParams->eChannelMapping[0] = OMX_AUDIO_ChannelLF; 166 pcmParams->eChannelMapping[1] = OMX_AUDIO_ChannelRF; 167 168 pcmParams->nChannels = mNumChannels; 169 pcmParams->nSamplingRate = mSampleRate; 170 171 return OMX_ErrorNone; 172 } 173 174 case OMX_IndexParamAudioFlac: 175 { 176 OMX_AUDIO_PARAM_FLACTYPE *flacParams = (OMX_AUDIO_PARAM_FLACTYPE *)params; 177 flacParams->nCompressionLevel = mCompressionLevel; 178 flacParams->nChannels = mNumChannels; 179 flacParams->nSampleRate = mSampleRate; 180 return OMX_ErrorNone; 181 } 182 183 default: 184 return SimpleSoftOMXComponent::internalGetParameter(index, params); 185 } 186} 187 188OMX_ERRORTYPE SoftFlacEncoder::internalSetParameter( 189 OMX_INDEXTYPE index, const OMX_PTR params) { 190 switch (index) { 191 case OMX_IndexParamAudioPcm: 192 { 193 ALOGV("SoftFlacEncoder::internalSetParameter(OMX_IndexParamAudioPcm)"); 194 OMX_AUDIO_PARAM_PCMMODETYPE *pcmParams = (OMX_AUDIO_PARAM_PCMMODETYPE *)params; 195 196 if (pcmParams->nPortIndex != 0 && pcmParams->nPortIndex != 1) { 197 ALOGE("SoftFlacEncoder::internalSetParameter() Error #1"); 198 return OMX_ErrorUndefined; 199 } 200 201 if (pcmParams->nChannels < 1 || pcmParams->nChannels > 2) { 202 return OMX_ErrorUndefined; 203 } 204 205 mNumChannels = pcmParams->nChannels; 206 mSampleRate = pcmParams->nSamplingRate; 207 ALOGV("will encode %ld channels at %ldHz", mNumChannels, mSampleRate); 208 209 return configureEncoder(); 210 } 211 212 case OMX_IndexParamStandardComponentRole: 213 { 214 ALOGV("SoftFlacEncoder::internalSetParameter(OMX_IndexParamStandardComponentRole)"); 215 const OMX_PARAM_COMPONENTROLETYPE *roleParams = 216 (const OMX_PARAM_COMPONENTROLETYPE *)params; 217 218 if (strncmp((const char *)roleParams->cRole, 219 "audio_encoder.flac", 220 OMX_MAX_STRINGNAME_SIZE - 1)) { 221 ALOGE("SoftFlacEncoder::internalSetParameter(OMX_IndexParamStandardComponentRole)" 222 "error"); 223 return OMX_ErrorUndefined; 224 } 225 226 return OMX_ErrorNone; 227 } 228 229 case OMX_IndexParamAudioFlac: 230 { 231 // used only for setting the compression level 232 OMX_AUDIO_PARAM_FLACTYPE *flacParams = (OMX_AUDIO_PARAM_FLACTYPE *)params; 233 mCompressionLevel = flacParams->nCompressionLevel; // range clamping done inside encoder 234 return OMX_ErrorNone; 235 } 236 237 default: 238 ALOGV("SoftFlacEncoder::internalSetParameter(default)"); 239 return SimpleSoftOMXComponent::internalSetParameter(index, params); 240 } 241} 242 243void SoftFlacEncoder::onQueueFilled(OMX_U32 portIndex) { 244 245 ALOGV("SoftFlacEncoder::onQueueFilled(portIndex=%ld)", portIndex); 246 247 if (mSignalledError) { 248 return; 249 } 250 251 List<BufferInfo *> &inQueue = getPortQueue(0); 252 List<BufferInfo *> &outQueue = getPortQueue(1); 253 254 while (!inQueue.empty() && !outQueue.empty()) { 255 BufferInfo *inInfo = *inQueue.begin(); 256 OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader; 257 258 BufferInfo *outInfo = *outQueue.begin(); 259 OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; 260 261 if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) { 262 inQueue.erase(inQueue.begin()); 263 inInfo->mOwnedByUs = false; 264 notifyEmptyBufferDone(inHeader); 265 266 outHeader->nFilledLen = 0; 267 outHeader->nFlags = OMX_BUFFERFLAG_EOS; 268 269 outQueue.erase(outQueue.begin()); 270 outInfo->mOwnedByUs = false; 271 notifyFillBufferDone(outHeader); 272 273 return; 274 } 275 276 if (inHeader->nFilledLen > kMaxNumSamplesPerFrame * sizeof(FLAC__int32) * 2) { 277 ALOGE("input buffer too large (%ld).", inHeader->nFilledLen); 278 mSignalledError = true; 279 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 280 return; 281 } 282 283 assert(mNumChannels != 0); 284 mEncoderWriteData = true; 285 mEncoderReturnedEncodedData = false; 286 mEncoderReturnedNbBytes = 0; 287 mCurrentInputTimeStamp = inHeader->nTimeStamp; 288 289 const unsigned nbInputFrames = inHeader->nFilledLen / (2 * mNumChannels); 290 const unsigned nbInputSamples = inHeader->nFilledLen / 2; 291 const OMX_S16 * const pcm16 = reinterpret_cast<OMX_S16 *>(inHeader->pBuffer); 292 293 for (unsigned i=0 ; i < nbInputSamples ; i++) { 294 mInputBufferPcm32[i] = (FLAC__int32) pcm16[i]; 295 } 296 ALOGV(" about to encode %u samples per channel", nbInputFrames); 297 FLAC__bool ok = FLAC__stream_encoder_process_interleaved( 298 mFlacStreamEncoder, 299 mInputBufferPcm32, 300 nbInputFrames /*samples per channel*/ ); 301 302 if (ok) { 303 if (mEncoderReturnedEncodedData && (mEncoderReturnedNbBytes != 0)) { 304 ALOGV(" dequeueing buffer on output port after writing data"); 305 outInfo->mOwnedByUs = false; 306 outQueue.erase(outQueue.begin()); 307 outInfo = NULL; 308 notifyFillBufferDone(outHeader); 309 outHeader = NULL; 310 mEncoderReturnedEncodedData = false; 311 } else { 312 ALOGV(" encoder process_interleaved returned without data to write"); 313 } 314 } else { 315 ALOGE(" error encountered during encoding"); 316 mSignalledError = true; 317 notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL); 318 return; 319 } 320 321 inInfo->mOwnedByUs = false; 322 inQueue.erase(inQueue.begin()); 323 inInfo = NULL; 324 notifyEmptyBufferDone(inHeader); 325 inHeader = NULL; 326 } 327} 328 329 330FLAC__StreamEncoderWriteStatus SoftFlacEncoder::onEncodedFlacAvailable( 331 const FLAC__byte buffer[], 332 size_t bytes, unsigned samples, unsigned current_frame) { 333 ALOGV("SoftFlacEncoder::onEncodedFlacAvailable(bytes=%d, samples=%d, curr_frame=%d)", 334 bytes, samples, current_frame); 335 336#ifdef WRITE_FLAC_HEADER_IN_FIRST_BUFFER 337 if (samples == 0) { 338 ALOGI(" saving %d bytes of header", bytes); 339 memcpy(mHeader + mHeaderOffset, buffer, bytes); 340 mHeaderOffset += bytes;// will contain header size when finished receiving header 341 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 342 } 343 344#endif 345 346 if ((samples == 0) || !mEncoderWriteData) { 347 // called by the encoder because there's header data to save, but it's not the role 348 // of this component (unless WRITE_FLAC_HEADER_IN_FIRST_BUFFER is defined) 349 ALOGV("ignoring %d bytes of header data (samples=%d)", bytes, samples); 350 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 351 } 352 353 List<BufferInfo *> &outQueue = getPortQueue(1); 354 CHECK(!outQueue.empty()); 355 BufferInfo *outInfo = *outQueue.begin(); 356 OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader; 357 358#ifdef WRITE_FLAC_HEADER_IN_FIRST_BUFFER 359 if (!mWroteHeader) { 360 ALOGI(" writing %d bytes of header on output port", mHeaderOffset); 361 memcpy(outHeader->pBuffer + outHeader->nOffset + outHeader->nFilledLen, 362 mHeader, mHeaderOffset); 363 outHeader->nFilledLen += mHeaderOffset; 364 outHeader->nOffset += mHeaderOffset; 365 mWroteHeader = true; 366 } 367#endif 368 369 // write encoded data 370 ALOGV(" writing %d bytes of encoded data on output port", bytes); 371 if (bytes > outHeader->nAllocLen - outHeader->nOffset - outHeader->nFilledLen) { 372 ALOGE(" not enough space left to write encoded data, dropping %u bytes", bytes); 373 // a fatal error would stop the encoding 374 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 375 } 376 memcpy(outHeader->pBuffer + outHeader->nOffset, buffer, bytes); 377 378 outHeader->nTimeStamp = mCurrentInputTimeStamp; 379 outHeader->nOffset = 0; 380 outHeader->nFilledLen += bytes; 381 outHeader->nFlags = 0; 382 383 mEncoderReturnedEncodedData = true; 384 mEncoderReturnedNbBytes += bytes; 385 386 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 387} 388 389 390OMX_ERRORTYPE SoftFlacEncoder::configureEncoder() { 391 ALOGV("SoftFlacEncoder::configureEncoder() numChannel=%ld, sampleRate=%ld", 392 mNumChannels, mSampleRate); 393 394 if (mSignalledError || (mFlacStreamEncoder == NULL)) { 395 ALOGE("can't configure encoder: no encoder or invalid state"); 396 return OMX_ErrorInvalidState; 397 } 398 399 FLAC__bool ok = true; 400 FLAC__StreamEncoderInitStatus initStatus = FLAC__STREAM_ENCODER_INIT_STATUS_OK; 401 ok = ok && FLAC__stream_encoder_set_channels(mFlacStreamEncoder, mNumChannels); 402 ok = ok && FLAC__stream_encoder_set_sample_rate(mFlacStreamEncoder, mSampleRate); 403 ok = ok && FLAC__stream_encoder_set_bits_per_sample(mFlacStreamEncoder, 16); 404 ok = ok && FLAC__stream_encoder_set_compression_level(mFlacStreamEncoder, 405 (unsigned)mCompressionLevel); 406 ok = ok && FLAC__stream_encoder_set_verify(mFlacStreamEncoder, false); 407 if (!ok) { goto return_result; } 408 409 ok &= FLAC__STREAM_ENCODER_INIT_STATUS_OK == 410 FLAC__stream_encoder_init_stream(mFlacStreamEncoder, 411 flacEncoderWriteCallback /*write_callback*/, 412 NULL /*seek_callback*/, 413 NULL /*tell_callback*/, 414 NULL /*metadata_callback*/, 415 (void *) this /*client_data*/); 416 417return_result: 418 if (ok) { 419 ALOGV("encoder successfully configured"); 420 return OMX_ErrorNone; 421 } else { 422 ALOGE("unknown error when configuring encoder"); 423 return OMX_ErrorUndefined; 424 } 425} 426 427 428// static 429FLAC__StreamEncoderWriteStatus SoftFlacEncoder::flacEncoderWriteCallback( 430 const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], 431 size_t bytes, unsigned samples, unsigned current_frame, void *client_data) { 432 return ((SoftFlacEncoder*) client_data)->onEncodedFlacAvailable( 433 buffer, bytes, samples, current_frame); 434} 435 436} // namespace android 437 438 439android::SoftOMXComponent *createSoftOMXComponent( 440 const char *name, const OMX_CALLBACKTYPE *callbacks, 441 OMX_PTR appData, OMX_COMPONENTTYPE **component) { 442 return new android::SoftFlacEncoder(name, callbacks, appData, component); 443} 444 445