VideoEditorAudioPlayer.cpp revision 1c97d9ab52a288d24ea54499de435277cc1a3d68 
1/*
2 * Copyright (C) 2011 NXP Software
3 * Copyright (C) 2011 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#define LOG_NDEBUG 1
19#define LOG_TAG "VideoEditorAudioPlayer"
20#include <utils/Log.h>
21
22#include <binder/IPCThreadState.h>
23#include <media/AudioTrack.h>
24#include <VideoEditorAudioPlayer.h>
25#include <media/stagefright/MediaDebug.h>
26#include <media/stagefright/MediaDefs.h>
27#include <media/stagefright/MediaErrors.h>
28#include <media/stagefright/MediaSource.h>
29#include <media/stagefright/MetaData.h>
30
31#include "PreviewPlayer.h"
32namespace android {
33
34VideoEditorAudioPlayer::VideoEditorAudioPlayer(
35        const sp<MediaPlayerBase::AudioSink> &audioSink,
36        AwesomePlayer *observer)
37    : AudioPlayer(audioSink, observer) {
38
39    LOGV("VideoEditorAudioPlayer");
40    mBGAudioPCMFileHandle = NULL;
41    mAudioProcess = NULL;
42    mBGAudioPCMFileLength = 0;
43    mBGAudioPCMFileTrimmedLength = 0;
44    mBGAudioPCMFileDuration = 0;
45    mBGAudioPCMFileSeekPoint = 0;
46    mBGAudioPCMFileOriginalSeekPoint = 0;
47    mBGAudioStoryBoardSkimTimeStamp = 0;
48    mBGAudioStoryBoardCurrentMediaBeginCutTS = 0;
49    mBGAudioStoryBoardCurrentMediaVolumeVal = 0;
50    mSeekTimeUs = 0;
51    mSource = NULL;
52}
53
54VideoEditorAudioPlayer::~VideoEditorAudioPlayer() {
55
56    LOGV("~VideoEditorAudioPlayer");
57    if (mStarted) {
58        reset();
59    }
60    if (mAudioProcess != NULL) {
61        delete mAudioProcess;
62        mAudioProcess = NULL;
63    }
64}
65void VideoEditorAudioPlayer::setSource(const sp<MediaSource> &source) {
66    Mutex::Autolock autoLock(mLock);
67    mSource = source;
68    mReachedEOS = false;
69}
70
71sp<MediaSource> VideoEditorAudioPlayer::getSource() {
72    Mutex::Autolock autoLock(mLock);
73    return mSource;
74}
75
76void VideoEditorAudioPlayer::setObserver(AwesomePlayer *observer) {
77    LOGV("setObserver");
78    //CHECK(!mStarted);
79    mObserver = observer;
80}
81
82
83bool VideoEditorAudioPlayer::isStarted() {
84    return mStarted;
85}
86
87status_t VideoEditorAudioPlayer::start(bool sourceAlreadyStarted) {
88    Mutex::Autolock autoLock(mLock);
89    CHECK(!mStarted);
90    CHECK(mSource != NULL);
91    LOGV("Start");
92    status_t err;
93    M4OSA_ERR result = M4NO_ERROR;
94    M4OSA_UInt32 startTime = 0;
95    M4OSA_UInt32 seekTimeStamp = 0;
96    M4OSA_Bool bStoryBoardTSBeyondBTEndCutTime = M4OSA_FALSE;
97
98    if (!sourceAlreadyStarted) {
99        err = mSource->start();
100        if (err != OK) {
101            return err;
102        }
103    }
104
105    // Create the BG Audio handler
106    mAudioProcess = new VideoEditorBGAudioProcessing();
107    veAudMixSettings audioMixSettings;
108
109    // Pass on the audio ducking parameters
110    audioMixSettings.lvInDucking_threshold =
111        mAudioMixSettings->uiInDucking_threshold;
112    audioMixSettings.lvInDucking_lowVolume =
113        ((M4OSA_Float)mAudioMixSettings->uiInDucking_lowVolume) / 100.0;
114    audioMixSettings.lvInDucking_enable =
115        mAudioMixSettings->bInDucking_enable;
116    audioMixSettings.lvPTVolLevel =
117        ((M4OSA_Float)mBGAudioStoryBoardCurrentMediaVolumeVal) / 100.0;
118    audioMixSettings.lvBTVolLevel =
119        ((M4OSA_Float)mAudioMixSettings->uiAddVolume) / 100.0;
120    audioMixSettings.lvBTChannelCount = mAudioMixSettings->uiBTChannelCount;
121    audioMixSettings.lvPTChannelCount = mAudioMixSettings->uiNbChannels;
122
123    // Call to Audio mix param setting
124    mAudioProcess->veSetAudioProcessingParams(audioMixSettings);
125
126    // Get the BG Audio PCM file details
127    if ( mBGAudioPCMFileHandle ) {
128
129        // TODO : 32bits required for OSAL, to be updated once OSAL is updated
130        M4OSA_UInt32 tmp32 = 0;
131        result = M4OSA_fileReadGetOption(mBGAudioPCMFileHandle,
132                                        M4OSA_kFileReadGetFileSize,
133                                        (M4OSA_Void**)&tmp32);
134        mBGAudioPCMFileLength = tmp32;
135        mBGAudioPCMFileTrimmedLength = mBGAudioPCMFileLength;
136
137
138        LOGV("VideoEditorAudioPlayer::start M4OSA_kFileReadGetFileSize = %lld",
139                            mBGAudioPCMFileLength);
140
141        // Get the duration in time of the audio BT
142        if ( result == M4NO_ERROR ) {
143         LOGV("VEAP: channels = %d freq = %d",
144         mAudioMixSettings->uiNbChannels,  mAudioMixSettings->uiSamplingFrequency);
145
146            // No trim
147            mBGAudioPCMFileDuration = ((
148                    (int64_t)(mBGAudioPCMFileLength/sizeof(M4OSA_UInt16)/
149                    mAudioMixSettings->uiNbChannels))*1000 ) /
150                    mAudioMixSettings->uiSamplingFrequency;
151
152            LOGV("VideoEditorAudioPlayer:: beginCutMs %d , endCutMs %d",
153                    (unsigned int) mAudioMixSettings->beginCutMs,
154                    (unsigned int) mAudioMixSettings->endCutMs);
155
156            // Remove the trim part
157            if ((mAudioMixSettings->beginCutMs == 0) &&
158                (mAudioMixSettings->endCutMs != 0)) {
159                // End time itself the file duration
160                mBGAudioPCMFileDuration = mAudioMixSettings->endCutMs;
161                // Limit the file length also
162                mBGAudioPCMFileTrimmedLength = ((
163                     (int64_t)(mBGAudioPCMFileDuration *
164                     mAudioMixSettings->uiSamplingFrequency) *
165                     mAudioMixSettings->uiNbChannels) *
166                     sizeof(M4OSA_UInt16)) / 1000;
167            }
168            else if ((mAudioMixSettings->beginCutMs != 0) &&
169                     (mAudioMixSettings->endCutMs == mBGAudioPCMFileDuration)) {
170                // End time itself the file duration
171                mBGAudioPCMFileDuration = mBGAudioPCMFileDuration -
172                      mAudioMixSettings->beginCutMs;
173                // Limit the file length also
174                mBGAudioPCMFileTrimmedLength = ((
175                     (int64_t)(mBGAudioPCMFileDuration *
176                     mAudioMixSettings->uiSamplingFrequency) *
177                     mAudioMixSettings->uiNbChannels) *
178                     sizeof(M4OSA_UInt16)) / 1000;
179            }
180            else if ((mAudioMixSettings->beginCutMs != 0) &&
181                    (mAudioMixSettings->endCutMs != 0)) {
182                // End time itself the file duration
183                mBGAudioPCMFileDuration = mAudioMixSettings->endCutMs -
184                    mAudioMixSettings->beginCutMs;
185                // Limit the file length also
186                mBGAudioPCMFileTrimmedLength = ((
187                    (int64_t)(mBGAudioPCMFileDuration *
188                    mAudioMixSettings->uiSamplingFrequency) *
189                    mAudioMixSettings->uiNbChannels) *
190                    sizeof(M4OSA_UInt16)) / 1000; /*make to sec from ms*/
191            }
192
193            LOGV("VideoEditorAudioPlayer: file duration recorded : %lld",
194                    mBGAudioPCMFileDuration);
195        }
196
197        // Last played location to be seeked at for next media item
198        if ( result == M4NO_ERROR ) {
199            LOGV("VideoEditorAudioPlayer::mBGAudioStoryBoardSkimTimeStamp %lld",
200                    mBGAudioStoryBoardSkimTimeStamp);
201            LOGV("VideoEditorAudioPlayer::uiAddCts %d",
202                    mAudioMixSettings->uiAddCts);
203            if (mBGAudioStoryBoardSkimTimeStamp >= mAudioMixSettings->uiAddCts) {
204                startTime = (mBGAudioStoryBoardSkimTimeStamp -
205                 mAudioMixSettings->uiAddCts);
206            }
207            else {
208                // do nothing
209            }
210
211            LOGV("VideoEditorAudioPlayer::startTime %d", startTime);
212            seekTimeStamp = 0;
213            if (startTime) {
214                if (startTime >= mBGAudioPCMFileDuration) {
215                    // The BG track should be looped and started again
216                    if (mAudioMixSettings->bLoop) {
217                        // Add begin cut time to the mod value
218                        seekTimeStamp = ((startTime%mBGAudioPCMFileDuration) +
219                        mAudioMixSettings->beginCutMs);
220                    }else {
221                        // Looping disabled, donot do BT Mix , set to file end
222                        seekTimeStamp = (mBGAudioPCMFileDuration +
223                        mAudioMixSettings->beginCutMs);
224                    }
225                }else {
226                    // BT still present , just seek to story board time
227                    seekTimeStamp = startTime + mAudioMixSettings->beginCutMs;
228                }
229            }
230            else {
231                seekTimeStamp = mAudioMixSettings->beginCutMs;
232            }
233
234            // Convert the seekTimeStamp to file location
235            mBGAudioPCMFileOriginalSeekPoint = (
236                                        (int64_t)(mAudioMixSettings->beginCutMs)
237                                        * mAudioMixSettings->uiSamplingFrequency
238                                        * mAudioMixSettings->uiNbChannels
239                                        * sizeof(M4OSA_UInt16))/ 1000 ; /*make to sec from ms*/
240
241            mBGAudioPCMFileSeekPoint = ((int64_t)(seekTimeStamp)
242                                        * mAudioMixSettings->uiSamplingFrequency
243                                        * mAudioMixSettings->uiNbChannels
244                                        * sizeof(M4OSA_UInt16))/ 1000 ;
245        }
246    }
247
248    // We allow an optional INFO_FORMAT_CHANGED at the very beginning
249    // of playback, if there is one, getFormat below will retrieve the
250    // updated format, if there isn't, we'll stash away the valid buffer
251    // of data to be used on the first audio callback.
252
253    CHECK(mFirstBuffer == NULL);
254
255    mFirstBufferResult = mSource->read(&mFirstBuffer);
256    if (mFirstBufferResult == INFO_FORMAT_CHANGED) {
257        LOGV("INFO_FORMAT_CHANGED!!!");
258
259        CHECK(mFirstBuffer == NULL);
260        mFirstBufferResult = OK;
261        mIsFirstBuffer = false;
262    } else {
263        mIsFirstBuffer = true;
264    }
265
266    sp<MetaData> format = mSource->getFormat();
267    const char *mime;
268    bool success = format->findCString(kKeyMIMEType, &mime);
269    CHECK(success);
270    CHECK(!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW));
271
272    success = format->findInt32(kKeySampleRate, &mSampleRate);
273    CHECK(success);
274
275    int32_t numChannels;
276    success = format->findInt32(kKeyChannelCount, &numChannels);
277    CHECK(success);
278
279    if (mAudioSink.get() != NULL) {
280        status_t err = mAudioSink->open(
281                mSampleRate, numChannels, AudioSystem::PCM_16_BIT,
282                DEFAULT_AUDIOSINK_BUFFERCOUNT,
283                &VideoEditorAudioPlayer::AudioSinkCallback, this);
284        if (err != OK) {
285            if (mFirstBuffer != NULL) {
286                mFirstBuffer->release();
287                mFirstBuffer = NULL;
288            }
289
290            if (!sourceAlreadyStarted) {
291                mSource->stop();
292            }
293
294            return err;
295        }
296
297        mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
298        mFrameSize = mAudioSink->frameSize();
299
300        mAudioSink->start();
301    } else {
302        mAudioTrack = new AudioTrack(
303                AudioSystem::MUSIC, mSampleRate, AudioSystem::PCM_16_BIT,
304                (numChannels == 2)
305                    ? AudioSystem::CHANNEL_OUT_STEREO
306                    : AudioSystem::CHANNEL_OUT_MONO,
307                0, 0, &AudioCallback, this, 0);
308
309        if ((err = mAudioTrack->initCheck()) != OK) {
310            delete mAudioTrack;
311            mAudioTrack = NULL;
312
313            if (mFirstBuffer != NULL) {
314                mFirstBuffer->release();
315                mFirstBuffer = NULL;
316            }
317
318            if (!sourceAlreadyStarted) {
319                mSource->stop();
320            }
321
322            return err;
323        }
324
325        mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
326        mFrameSize = mAudioTrack->frameSize();
327
328        mAudioTrack->start();
329    }
330
331    mStarted = true;
332
333    return OK;
334}
335
336void VideoEditorAudioPlayer::resume() {
337
338    veAudMixSettings audioMixSettings;
339
340    // Single audio player is used;
341    // Pass on the audio ducking parameters
342    // which might have changed with new audio source
343    audioMixSettings.lvInDucking_threshold =
344        mAudioMixSettings->uiInDucking_threshold;
345    audioMixSettings.lvInDucking_lowVolume =
346        ((M4OSA_Float)mAudioMixSettings->uiInDucking_lowVolume) / 100.0;
347    audioMixSettings.lvInDucking_enable =
348        mAudioMixSettings->bInDucking_enable;
349    audioMixSettings.lvPTVolLevel =
350        ((M4OSA_Float)mBGAudioStoryBoardCurrentMediaVolumeVal) / 100.0;
351    audioMixSettings.lvBTVolLevel =
352        ((M4OSA_Float)mAudioMixSettings->uiAddVolume) / 100.0;
353    audioMixSettings.lvBTChannelCount = mAudioMixSettings->uiBTChannelCount;
354    audioMixSettings.lvPTChannelCount = mAudioMixSettings->uiNbChannels;
355
356    // Call to Audio mix param setting
357    mAudioProcess->veSetAudioProcessingParams(audioMixSettings);
358
359    //Call the base class
360    AudioPlayer::resume();
361}
362
363void VideoEditorAudioPlayer::reset() {
364
365    LOGV("reset");
366    AudioPlayer::reset();
367
368    // Capture the current seek point
369    mBGAudioPCMFileSeekPoint = 0;
370    mBGAudioStoryBoardSkimTimeStamp =0;
371    mBGAudioStoryBoardCurrentMediaBeginCutTS=0;
372}
373
374size_t VideoEditorAudioPlayer::AudioSinkCallback(
375        MediaPlayerBase::AudioSink *audioSink,
376        void *buffer, size_t size, void *cookie) {
377    VideoEditorAudioPlayer *me = (VideoEditorAudioPlayer *)cookie;
378
379    return me->fillBuffer(buffer, size);
380}
381
382
383size_t VideoEditorAudioPlayer::fillBuffer(void *data, size_t size) {
384
385    if (mReachedEOS) {
386        return 0;
387    }
388
389    size_t size_done = 0;
390    size_t size_remaining = size;
391
392    M4OSA_ERR err = M4NO_ERROR;
393    M4AM_Buffer16 bgFrame = {NULL, 0};
394    M4AM_Buffer16 mixFrame = {NULL, 0};
395    M4AM_Buffer16 ptFrame = {NULL, 0};
396    int64_t currentSteamTS = 0;
397    int64_t startTimeForBT = 0;
398    M4OSA_Float fPTVolLevel =
399     ((M4OSA_Float)mBGAudioStoryBoardCurrentMediaVolumeVal)/100;
400    M4OSA_Int16     *pPTMdata;
401    M4OSA_UInt32     uiPCMsize = 0;
402
403    while ((size_remaining > 0)&&(err==M4NO_ERROR)) {
404        MediaSource::ReadOptions options;
405
406        {
407            Mutex::Autolock autoLock(mLock);
408            if (mSeeking) {
409                if (mIsFirstBuffer) {
410                    if (mFirstBuffer != NULL) {
411                        mFirstBuffer->release();
412                        mFirstBuffer = NULL;
413                    }
414                    mIsFirstBuffer = false;
415                }
416
417                options.setSeekTo(mSeekTimeUs);
418
419                if (mInputBuffer != NULL) {
420                    mInputBuffer->release();
421                    mInputBuffer = NULL;
422                }
423
424                mSeeking = false;
425                if (mObserver) {
426                    mObserver->postAudioSeekComplete();
427                }
428            }
429        }
430
431        if (mInputBuffer == NULL) {
432            status_t status = OK;
433
434            if (mIsFirstBuffer) {
435                mInputBuffer = mFirstBuffer;
436                mFirstBuffer = NULL;
437                status = mFirstBufferResult;
438
439                mIsFirstBuffer = false;
440            } else {
441
442                {
443                    Mutex::Autolock autoLock(mLock);
444                    status = mSource->read(&mInputBuffer, &options);
445                }
446                // Data is Primary Track, mix with background track
447                // after reading same size from Background track PCM file
448                if (status == OK)
449                {
450                    // Mix only when skim point is after startTime of BT
451                    if (((mBGAudioStoryBoardSkimTimeStamp* 1000) +
452                          (mPositionTimeMediaUs - mSeekTimeUs)) >=
453                          (int64_t)(mAudioMixSettings->uiAddCts * 1000)) {
454
455                        LOGV("VideoEditorAudioPlayer::INSIDE MIXING");
456                        LOGV("Checking %lld <= %lld",
457                            mBGAudioPCMFileSeekPoint-mBGAudioPCMFileOriginalSeekPoint,
458                            mBGAudioPCMFileTrimmedLength);
459
460
461                        M4OSA_Void* ptr;
462                        ptr = (M4OSA_Void*)((unsigned int)mInputBuffer->data() +
463                        mInputBuffer->range_offset());
464
465                        M4OSA_UInt32 len = mInputBuffer->range_length();
466                        M4OSA_Context fp = M4OSA_NULL;
467
468                        uiPCMsize = (mInputBuffer->range_length())/2;
469                        pPTMdata = (M4OSA_Int16*) ((uint8_t*) mInputBuffer->data()
470                                + mInputBuffer->range_offset());
471
472                        LOGV("mix with background malloc to do len %d", len);
473
474                        bgFrame.m_dataAddress = (M4OSA_UInt16*)M4OSA_malloc( len, 1,
475                                                       (M4OSA_Char*)"bgFrame");
476                        if (NULL == bgFrame.m_dataAddress) {
477                            LOGE("mBackgroundAudioSetting Malloc failed");
478                        }
479
480                        bgFrame.m_bufferSize = len;
481
482                        mixFrame.m_dataAddress = (M4OSA_UInt16*)M4OSA_malloc(len, 1,
483                                                    (M4OSA_Char*)"mixFrame");
484                        if (NULL == mixFrame.m_dataAddress) {
485                            LOGE("mBackgroundAudioSetting Malloc failed");
486                        }
487
488                        mixFrame.m_bufferSize = len;
489
490                        LOGV("mix with bgm with size %lld", mBGAudioPCMFileLength);
491
492                        CHECK(mInputBuffer->meta_data()->findInt64(kKeyTime,
493                                         &mPositionTimeMediaUs));
494
495                        if (mBGAudioPCMFileSeekPoint -
496                             mBGAudioPCMFileOriginalSeekPoint <=
497                              (mBGAudioPCMFileTrimmedLength - len)) {
498
499                            LOGV("Checking mBGAudioPCMFileHandle %d",
500                                (unsigned int)mBGAudioPCMFileHandle);
501
502                            if (mBGAudioPCMFileHandle != M4OSA_NULL) {
503                                LOGV("fillBuffer seeking file to %lld",
504                                    mBGAudioPCMFileSeekPoint);
505
506                            // TODO : 32bits required for OSAL
507                                M4OSA_UInt32 tmp32 =
508                                    (M4OSA_UInt32)mBGAudioPCMFileSeekPoint;
509                                err = M4OSA_fileReadSeek(mBGAudioPCMFileHandle,
510                                                M4OSA_kFileSeekBeginning,
511                                                (M4OSA_FilePosition*)&tmp32);
512
513                                mBGAudioPCMFileSeekPoint = tmp32;
514
515                                if (err != M4NO_ERROR){
516                                    LOGE("M4OSA_fileReadSeek err %d", err);
517                                }
518
519                                err = M4OSA_fileReadData(mBGAudioPCMFileHandle,
520                                       (M4OSA_Int8*)bgFrame.m_dataAddress,
521                                       (M4OSA_UInt32*)&len);
522                                if (err == M4WAR_NO_DATA_YET ) {
523
524                                    LOGV("fillBuffer End of file reached");
525                                    err = M4NO_ERROR;
526
527                                    // We reached the end of file
528                                    // move to begin cut time equal value
529                                    if (mAudioMixSettings->bLoop) {
530                                        mBGAudioPCMFileSeekPoint =
531                                         (((int64_t)(mAudioMixSettings->beginCutMs) *
532                                          mAudioMixSettings->uiSamplingFrequency) *
533                                          mAudioMixSettings->uiNbChannels *
534                                           sizeof(M4OSA_UInt16)) / 1000;
535                                        LOGV("fillBuffer Looping \
536                                            to mBGAudioPCMFileSeekPoint %lld",
537                                            mBGAudioPCMFileSeekPoint);
538                                    }
539                                    else {
540                                            // No mixing;
541                                            // take care of volume of primary track
542                                        if (fPTVolLevel < 1.0) {
543                                            setPrimaryTrackVolume(pPTMdata,
544                                             uiPCMsize, fPTVolLevel);
545                                        }
546                                    }
547                                } else if (err != M4NO_ERROR ) {
548                                     LOGV("fileReadData for audio err %d", err);
549                                } else {
550                                    mBGAudioPCMFileSeekPoint += len;
551                                    LOGV("fillBuffer mBGAudioPCMFileSeekPoint \
552                                         %lld", mBGAudioPCMFileSeekPoint);
553
554                                    // Assign the ptr data to primary track
555                                    ptFrame.m_dataAddress = (M4OSA_UInt16*)ptr;
556                                    ptFrame.m_bufferSize = len;
557
558                                    // Call to mix and duck
559                                    mAudioProcess->veProcessAudioMixNDuck(
560                                         &ptFrame, &bgFrame, &mixFrame);
561
562                                        // Overwrite the decoded buffer
563                                    M4OSA_memcpy((M4OSA_MemAddr8)ptr,
564                                         (M4OSA_MemAddr8)mixFrame.m_dataAddress, len);
565                                }
566                            }
567                        } else if (mAudioMixSettings->bLoop){
568                            // Move to begin cut time equal value
569                            mBGAudioPCMFileSeekPoint =
570                                mBGAudioPCMFileOriginalSeekPoint;
571                        } else {
572                            // No mixing;
573                            // take care of volume level of primary track
574                            if(fPTVolLevel < 1.0) {
575                                setPrimaryTrackVolume(
576                                      pPTMdata, uiPCMsize, fPTVolLevel);
577                            }
578                        }
579                        if (bgFrame.m_dataAddress) {
580                            M4OSA_free((M4OSA_MemAddr32)bgFrame.m_dataAddress);
581                        }
582                        if (mixFrame.m_dataAddress) {
583                            M4OSA_free((M4OSA_MemAddr32)mixFrame.m_dataAddress);
584                        }
585                    } else {
586                        // No mixing;
587                        // take care of volume level of primary track
588                        if(fPTVolLevel < 1.0) {
589                            setPrimaryTrackVolume(pPTMdata, uiPCMsize,
590                                                 fPTVolLevel);
591                        }
592                    }
593                }
594            }
595
596            CHECK((status == OK && mInputBuffer != NULL)
597                   || (status != OK && mInputBuffer == NULL));
598
599            Mutex::Autolock autoLock(mLock);
600
601            if (status != OK) {
602                LOGV("fillBuffer: mSource->read returned err %d", status);
603                if (mObserver && !mReachedEOS) {
604                    mObserver->postAudioEOS();
605                }
606
607                mReachedEOS = true;
608                mFinalStatus = status;
609                break;
610            }
611
612            CHECK(mInputBuffer->meta_data()->findInt64(
613                        kKeyTime, &mPositionTimeMediaUs));
614
615            mPositionTimeRealUs =
616                ((mNumFramesPlayed + size_done / mFrameSize) * 1000000)
617                    / mSampleRate;
618
619            LOGV("buffer->size() = %d, "
620                     "mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
621                 mInputBuffer->range_length(),
622                 mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
623        }
624
625        if (mInputBuffer->range_length() == 0) {
626            mInputBuffer->release();
627            mInputBuffer = NULL;
628
629            continue;
630        }
631
632        size_t copy = size_remaining;
633        if (copy > mInputBuffer->range_length()) {
634            copy = mInputBuffer->range_length();
635        }
636
637        memcpy((char *)data + size_done,
638           (const char *)mInputBuffer->data() + mInputBuffer->range_offset(),
639               copy);
640
641        mInputBuffer->set_range(mInputBuffer->range_offset() + copy,
642                            mInputBuffer->range_length() - copy);
643
644        size_done += copy;
645        size_remaining -= copy;
646    }
647
648    Mutex::Autolock autoLock(mLock);
649    mNumFramesPlayed += size_done / mFrameSize;
650
651    return size_done;
652}
653
654void VideoEditorAudioPlayer::setAudioMixSettings(
655                            M4xVSS_AudioMixingSettings* pAudioMixSettings) {
656    mAudioMixSettings = pAudioMixSettings;
657}
658
659void VideoEditorAudioPlayer::setAudioMixPCMFileHandle(
660                            M4OSA_Context pBGAudioPCMFileHandle){
661    mBGAudioPCMFileHandle = pBGAudioPCMFileHandle;
662}
663
664void VideoEditorAudioPlayer::setAudioMixStoryBoardSkimTimeStamp(
665                            M4OSA_UInt32 pBGAudioStoryBoardSkimTimeStamp,
666                            M4OSA_UInt32 pBGAudioCurrentMediaBeginCutTS,
667                            M4OSA_UInt32 pBGAudioCurrentMediaVolumeVal) {
668
669    mBGAudioStoryBoardSkimTimeStamp = pBGAudioStoryBoardSkimTimeStamp;
670    mBGAudioStoryBoardCurrentMediaBeginCutTS = pBGAudioCurrentMediaBeginCutTS;
671    mBGAudioStoryBoardCurrentMediaVolumeVal = pBGAudioCurrentMediaVolumeVal;
672}
673
674void VideoEditorAudioPlayer::setPrimaryTrackVolume(
675    M4OSA_Int16 *data, M4OSA_UInt32 size, M4OSA_Float volLevel) {
676
677    while(size-- > 0) {
678        *data = (M4OSA_Int16)((*data)*volLevel);
679        data++;
680    }
681}
682
683}
684