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