blob: cea1576c688233e61dec701da92611ce7bacd553 [file] [log] [blame]
Dharmaray Kundargi643290d2011-01-16 16:02:42 -08001/*
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 "VideoEditorPlayer"
20#include <utils/Log.h>
21
22#include "VideoEditorPlayer.h"
23#include "PreviewPlayer.h"
24
25#include <media/Metadata.h>
26#include <media/stagefright/MediaExtractor.h>
27
28namespace android {
29
30VideoEditorPlayer::VideoEditorPlayer()
31 : mPlayer(new PreviewPlayer) {
32
33 LOGV("VideoEditorPlayer");
34 mPlayer->setListener(this);
35}
36
37VideoEditorPlayer::~VideoEditorPlayer() {
38 LOGV("~VideoEditorPlayer");
39
40 reset();
41 mVeAudioSink.clear();
42
43 delete mPlayer;
44 mPlayer = NULL;
45}
46
47status_t VideoEditorPlayer::initCheck() {
48 LOGV("initCheck");
49 return OK;
50}
51
Rajneesh Chowdury1c97d9a2011-02-21 15:43:33 -080052
53status_t VideoEditorPlayer::setAudioPlayer(VideoEditorAudioPlayer *audioPlayer) {
54 return mPlayer->setAudioPlayer(audioPlayer);
55}
56
57
Dharmaray Kundargi643290d2011-01-16 16:02:42 -080058status_t VideoEditorPlayer::setDataSource(
59 const char *url, const KeyedVector<String8, String8> *headers) {
60 LOGI("setDataSource('%s')", url);
61
Dharmaray Kundargi643290d2011-01-16 16:02:42 -080062 return mPlayer->setDataSource(url, headers);
63}
64
65//We donot use this in preview, dummy implimentation as this is pure virtual
66status_t VideoEditorPlayer::setDataSource(int fd, int64_t offset,
67 int64_t length) {
68 LOGE("setDataSource(%d, %lld, %lld) Not supported", fd, offset, length);
69 return (!OK);
70}
71
Dharmaray Kundargi643290d2011-01-16 16:02:42 -080072status_t VideoEditorPlayer::setVideoSurface(const sp<Surface> &surface) {
73 LOGV("setVideoSurface");
74
75 mPlayer->setSurface(surface);
76 return OK;
77}
78
Glenn Kasten4aeec632011-02-14 11:56:16 -080079status_t VideoEditorPlayer::setVideoSurfaceTexture(const sp<ISurfaceTexture> &surfaceTexture) {
80 LOGV("setVideoSurfaceTexture");
81
82 mPlayer->setSurfaceTexture(surfaceTexture);
83 return OK;
84}
85
Dharmaray Kundargi643290d2011-01-16 16:02:42 -080086status_t VideoEditorPlayer::prepare() {
87 LOGV("prepare");
88 return mPlayer->prepare();
89}
90
91status_t VideoEditorPlayer::prepareAsync() {
92 return mPlayer->prepareAsync();
93}
94
95status_t VideoEditorPlayer::start() {
96 LOGV("start");
97 return mPlayer->play();
98}
99
100status_t VideoEditorPlayer::stop() {
101 LOGV("stop");
102 return pause();
103}
104
105status_t VideoEditorPlayer::pause() {
106 LOGV("pause");
107 return mPlayer->pause();
108}
109
110bool VideoEditorPlayer::isPlaying() {
111 LOGV("isPlaying");
112 return mPlayer->isPlaying();
113}
114
115status_t VideoEditorPlayer::seekTo(int msec) {
116 LOGV("seekTo");
117 status_t err = mPlayer->seekTo((int64_t)msec * 1000);
118 return err;
119}
120
121status_t VideoEditorPlayer::getCurrentPosition(int *msec) {
122 LOGV("getCurrentPosition");
123 int64_t positionUs;
124 status_t err = mPlayer->getPosition(&positionUs);
125
126 if (err != OK) {
127 return err;
128 }
129
130 *msec = (positionUs + 500) / 1000;
131 return OK;
132}
133
134status_t VideoEditorPlayer::getDuration(int *msec) {
135 LOGV("getDuration");
136
137 int64_t durationUs;
138 status_t err = mPlayer->getDuration(&durationUs);
139
140 if (err != OK) {
141 *msec = 0;
142 return OK;
143 }
144
145 *msec = (durationUs + 500) / 1000;
146 return OK;
147}
148
149status_t VideoEditorPlayer::reset() {
150 LOGV("reset");
151 mPlayer->reset();
152 return OK;
153}
154
155status_t VideoEditorPlayer::setLooping(int loop) {
156 LOGV("setLooping");
157 return mPlayer->setLooping(loop);
158}
159
160player_type VideoEditorPlayer::playerType() {
161 LOGV("playerType");
162 return STAGEFRIGHT_PLAYER;
163}
164
165status_t VideoEditorPlayer::suspend() {
166 LOGV("suspend");
167 return mPlayer->suspend();
168}
169
170status_t VideoEditorPlayer::resume() {
171 LOGV("resume");
172 return mPlayer->resume();
Raghavender Pallafa31daf2011-03-18 22:32:51 -0700173}
174
175void VideoEditorPlayer::acquireLock() {
176 LOGV("acquireLock");
177 mPlayer->acquireLock();
178}
179
180void VideoEditorPlayer::releaseLock() {
181 LOGV("releaseLock");
182 mPlayer->releaseLock();
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800183}
184
185status_t VideoEditorPlayer::invoke(const Parcel &request, Parcel *reply) {
186 return INVALID_OPERATION;
187}
188
189void VideoEditorPlayer::setAudioSink(const sp<AudioSink> &audioSink) {
190 MediaPlayerInterface::setAudioSink(audioSink);
191
192 mPlayer->setAudioSink(audioSink);
193}
194
195status_t VideoEditorPlayer::getMetadata(
196 const media::Metadata::Filter& ids, Parcel *records) {
197 using media::Metadata;
198
199 uint32_t flags = mPlayer->flags();
200
201 Metadata metadata(records);
202
203 metadata.appendBool(
204 Metadata::kPauseAvailable,
205 flags & MediaExtractor::CAN_PAUSE);
206
207 metadata.appendBool(
208 Metadata::kSeekBackwardAvailable,
209 flags & MediaExtractor::CAN_SEEK_BACKWARD);
210
211 metadata.appendBool(
212 Metadata::kSeekForwardAvailable,
213 flags & MediaExtractor::CAN_SEEK_FORWARD);
214
215 metadata.appendBool(
216 Metadata::kSeekAvailable,
217 flags & MediaExtractor::CAN_SEEK);
218
219 return OK;
220}
221
222status_t VideoEditorPlayer::loadEffectsSettings(
223 M4VSS3GPP_EffectSettings* pEffectSettings, int nEffects) {
224 LOGV("loadEffectsSettings");
225 return mPlayer->loadEffectsSettings(pEffectSettings, nEffects);
226}
227
228status_t VideoEditorPlayer::loadAudioMixSettings(
229 M4xVSS_AudioMixingSettings* pAudioMixSettings) {
230 LOGV("VideoEditorPlayer: loadAudioMixSettings");
231 return mPlayer->loadAudioMixSettings(pAudioMixSettings);
232}
233
234status_t VideoEditorPlayer::setAudioMixPCMFileHandle(
235 M4OSA_Context pAudioMixPCMFileHandle) {
236
237 LOGV("VideoEditorPlayer: loadAudioMixSettings");
238 return mPlayer->setAudioMixPCMFileHandle(pAudioMixPCMFileHandle);
239}
240
241status_t VideoEditorPlayer::setAudioMixStoryBoardParam(
242 M4OSA_UInt32 audioMixStoryBoardTS,
243 M4OSA_UInt32 currentMediaBeginCutTime,
244 M4OSA_UInt32 primaryTrackVolValue) {
245
246 LOGV("VideoEditorPlayer: loadAudioMixSettings");
247 return mPlayer->setAudioMixStoryBoardParam(audioMixStoryBoardTS,
248 currentMediaBeginCutTime, primaryTrackVolValue);
249}
250
251status_t VideoEditorPlayer::setPlaybackBeginTime(uint32_t msec) {
252 LOGV("setPlaybackBeginTime");
253 return mPlayer->setPlaybackBeginTime(msec);
254}
255
256status_t VideoEditorPlayer::setPlaybackEndTime(uint32_t msec) {
257 LOGV("setPlaybackEndTime");
258 return mPlayer->setPlaybackEndTime(msec);
259}
260
261status_t VideoEditorPlayer::setStoryboardStartTime(uint32_t msec) {
262 LOGV("setStoryboardStartTime");
263 return mPlayer->setStoryboardStartTime(msec);
264}
265
266status_t VideoEditorPlayer::setProgressCallbackInterval(uint32_t cbInterval) {
267 LOGV("setProgressCallbackInterval");
268 return mPlayer->setProgressCallbackInterval(cbInterval);
269}
270
271status_t VideoEditorPlayer::setMediaRenderingMode(
272 M4xVSS_MediaRendering mode,
273 M4VIDEOEDITING_VideoFrameSize outputVideoSize) {
274
275 LOGV("setMediaRenderingMode");
276 return mPlayer->setMediaRenderingMode(mode, outputVideoSize);
277}
278
279status_t VideoEditorPlayer::resetJniCallbackTimeStamp() {
280 LOGV("resetJniCallbackTimeStamp");
281 return mPlayer->resetJniCallbackTimeStamp();
282}
283
284status_t VideoEditorPlayer::setImageClipProperties(
285 uint32_t width, uint32_t height) {
286 return mPlayer->setImageClipProperties(width, height);
287}
288
289status_t VideoEditorPlayer::readFirstVideoFrame() {
290 return mPlayer->readFirstVideoFrame();
291}
292
Santosh Madhavab2d6e0f2011-02-16 22:24:42 -0800293status_t VideoEditorPlayer::getLastRenderedTimeMs(uint32_t *lastRenderedTimeMs) {
294 mPlayer->getLastRenderedTimeMs(lastRenderedTimeMs);
295 return NO_ERROR;
296}
297
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800298/* Implementation of AudioSink interface */
299#undef LOG_TAG
300#define LOG_TAG "VeAudioSink"
301
302int VideoEditorPlayer::VeAudioOutput::mMinBufferCount = 4;
303bool VideoEditorPlayer::VeAudioOutput::mIsOnEmulator = false;
304
305VideoEditorPlayer::VeAudioOutput::VeAudioOutput()
306 : mCallback(NULL),
307 mCallbackCookie(NULL) {
308 mTrack = 0;
309 mStreamType = AudioSystem::MUSIC;
310 mLeftVolume = 1.0;
311 mRightVolume = 1.0;
312 mLatency = 0;
313 mMsecsPerFrame = 0;
314 mNumFramesWritten = 0;
315 setMinBufferCount();
316}
317
318VideoEditorPlayer::VeAudioOutput::~VeAudioOutput() {
319 close();
320}
321
322void VideoEditorPlayer::VeAudioOutput::setMinBufferCount() {
323
324 mIsOnEmulator = false;
Danny Fernandesd196f1c2011-02-11 18:47:03 -0800325 mMinBufferCount = 4;
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800326}
327
328bool VideoEditorPlayer::VeAudioOutput::isOnEmulator() {
329
330 setMinBufferCount();
331 return mIsOnEmulator;
332}
333
334int VideoEditorPlayer::VeAudioOutput::getMinBufferCount() {
335
336 setMinBufferCount();
337 return mMinBufferCount;
338}
339
340ssize_t VideoEditorPlayer::VeAudioOutput::bufferSize() const {
341
342 if (mTrack == 0) return NO_INIT;
343 return mTrack->frameCount() * frameSize();
344}
345
346ssize_t VideoEditorPlayer::VeAudioOutput::frameCount() const {
347
348 if (mTrack == 0) return NO_INIT;
349 return mTrack->frameCount();
350}
351
352ssize_t VideoEditorPlayer::VeAudioOutput::channelCount() const
353{
354 if (mTrack == 0) return NO_INIT;
355 return mTrack->channelCount();
356}
357
358ssize_t VideoEditorPlayer::VeAudioOutput::frameSize() const
359{
360 if (mTrack == 0) return NO_INIT;
361 return mTrack->frameSize();
362}
363
364uint32_t VideoEditorPlayer::VeAudioOutput::latency () const
365{
366 return mLatency;
367}
368
369float VideoEditorPlayer::VeAudioOutput::msecsPerFrame() const
370{
371 return mMsecsPerFrame;
372}
373
374status_t VideoEditorPlayer::VeAudioOutput::getPosition(uint32_t *position) {
375
376 if (mTrack == 0) return NO_INIT;
377 return mTrack->getPosition(position);
378}
379
380status_t VideoEditorPlayer::VeAudioOutput::open(
381 uint32_t sampleRate, int channelCount, int format, int bufferCount,
382 AudioCallback cb, void *cookie) {
383
384 mCallback = cb;
385 mCallbackCookie = cookie;
386
387 // Check argument "bufferCount" against the mininum buffer count
388 if (bufferCount < mMinBufferCount) {
Danny Fernandesd196f1c2011-02-11 18:47:03 -0800389 LOGV("bufferCount (%d) is too small and increased to %d",
390 bufferCount, mMinBufferCount);
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800391 bufferCount = mMinBufferCount;
392
393 }
394 LOGV("open(%u, %d, %d, %d)", sampleRate, channelCount, format, bufferCount);
395 if (mTrack) close();
396 int afSampleRate;
397 int afFrameCount;
398 int frameCount;
399
400 if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) !=
401 NO_ERROR) {
402 return NO_INIT;
403 }
404 if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) !=
405 NO_ERROR) {
406 return NO_INIT;
407 }
408
409 frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
410
411 AudioTrack *t;
412 if (mCallback != NULL) {
413 t = new AudioTrack(
414 mStreamType,
415 sampleRate,
416 format,
417 (channelCount == 2) ?
418 AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO,
419 frameCount,
420 0 /* flags */,
421 CallbackWrapper,
422 this);
423 } else {
424 t = new AudioTrack(
425 mStreamType,
426 sampleRate,
427 format,
428 (channelCount == 2) ?
429 AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO,
430 frameCount);
431 }
432
433 if ((t == 0) || (t->initCheck() != NO_ERROR)) {
434 LOGE("Unable to create audio track");
435 delete t;
436 return NO_INIT;
437 }
438
439 LOGV("setVolume");
440 t->setVolume(mLeftVolume, mRightVolume);
441 mMsecsPerFrame = 1.e3 / (float) sampleRate;
442 mLatency = t->latency();
443 mTrack = t;
444 return NO_ERROR;
445}
446
447void VideoEditorPlayer::VeAudioOutput::start() {
448
449 LOGV("start");
450 if (mTrack) {
451 mTrack->setVolume(mLeftVolume, mRightVolume);
452 mTrack->start();
453 mTrack->getPosition(&mNumFramesWritten);
454 }
455}
456
457void VideoEditorPlayer::VeAudioOutput::snoopWrite(
458 const void* buffer, size_t size) {
459 // Visualization buffers not supported
460 return;
461
462}
463
464ssize_t VideoEditorPlayer::VeAudioOutput::write(
465 const void* buffer, size_t size) {
466
467 LOG_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
468
469 //LOGV("write(%p, %u)", buffer, size);
470 if (mTrack) {
471 snoopWrite(buffer, size);
472 ssize_t ret = mTrack->write(buffer, size);
473 mNumFramesWritten += ret / 4; // assume 16 bit stereo
474 return ret;
475 }
476 return NO_INIT;
477}
478
479void VideoEditorPlayer::VeAudioOutput::stop() {
480
481 LOGV("stop");
482 if (mTrack) mTrack->stop();
483}
484
485void VideoEditorPlayer::VeAudioOutput::flush() {
486
487 LOGV("flush");
488 if (mTrack) mTrack->flush();
489}
490
491void VideoEditorPlayer::VeAudioOutput::pause() {
492
493 LOGV("VeAudioOutput::pause");
494 if (mTrack) mTrack->pause();
495}
496
497void VideoEditorPlayer::VeAudioOutput::close() {
498
499 LOGV("close");
500 delete mTrack;
501 mTrack = 0;
502}
503
504void VideoEditorPlayer::VeAudioOutput::setVolume(float left, float right) {
505
506 LOGV("setVolume(%f, %f)", left, right);
507 mLeftVolume = left;
508 mRightVolume = right;
509 if (mTrack) {
510 mTrack->setVolume(left, right);
511 }
512}
513
514// static
515void VideoEditorPlayer::VeAudioOutput::CallbackWrapper(
516 int event, void *cookie, void *info) {
517 //LOGV("VeAudioOutput::callbackwrapper");
518 if (event != AudioTrack::EVENT_MORE_DATA) {
519 return;
520 }
521
522 VeAudioOutput *me = (VeAudioOutput *)cookie;
523 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
524
525 size_t actualSize = (*me->mCallback)(
526 me, buffer->raw, buffer->size, me->mCallbackCookie);
527
528 buffer->size = actualSize;
529
530 if (actualSize > 0) {
531 me->snoopWrite(buffer->raw, actualSize);
532 }
533}
534
535status_t VideoEditorPlayer::VeAudioOutput::dump(int fd, const Vector<String16>& args) const
536{
537 const size_t SIZE = 256;
538 char buffer[SIZE];
539 String8 result;
540
541 result.append(" VeAudioOutput\n");
542 snprintf(buffer, SIZE-1, " stream type(%d), left - right volume(%f, %f)\n",
543 mStreamType, mLeftVolume, mRightVolume);
544 result.append(buffer);
545 snprintf(buffer, SIZE-1, " msec per frame(%f), latency (%d)\n",
546 mMsecsPerFrame, mLatency);
547 result.append(buffer);
548 ::write(fd, result.string(), result.size());
549 if (mTrack != 0) {
550 mTrack->dump(fd, args);
551 }
552 return NO_ERROR;
553}
554
555int VideoEditorPlayer::VeAudioOutput::getSessionId() {
556
557 return mSessionId;
558}
559
560} // namespace android