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