mediarecorder.cpp revision 7a2146d5807030b2629f347736be5301b61e8811
1/* 2 ** 3 ** Copyright (c) 2008 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 0 19#define LOG_TAG "MediaRecorder" 20#include <utils/Log.h> 21#include <ui/Surface.h> 22#include <media/mediarecorder.h> 23#include <utils/IServiceManager.h> 24#include <media/IMediaPlayerService.h> 25#include <media/IMediaRecorder.h> 26 27namespace android { 28 29status_t MediaRecorder::setCamera(const sp<ICamera>& camera) 30{ 31 LOGV("setCamera(%p)", camera.get()); 32 if(mMediaRecorder == NULL) { 33 LOGE("media recorder is not initialized yet"); 34 return INVALID_OPERATION; 35 } 36 if (!(mCurrentState & MEDIA_RECORDER_IDLE)) { 37 LOGE("setCamera called in an invalid state(%d)", mCurrentState); 38 return INVALID_OPERATION; 39 } 40 41 status_t ret = mMediaRecorder->setCamera(camera); 42 if (OK != ret) { 43 LOGV("setCamera failed: %d", ret); 44 mCurrentState = MEDIA_RECORDER_ERROR; 45 return UNKNOWN_ERROR; 46 } 47 return ret; 48} 49 50status_t MediaRecorder::setPreviewSurface(const sp<Surface>& surface) 51{ 52 LOGV("setPreviewSurface(%p)", surface.get()); 53 if(mMediaRecorder == NULL) { 54 LOGE("media recorder is not initialized yet"); 55 return INVALID_OPERATION; 56 } 57 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 58 LOGE("setPreviewSurface called in an invalid state(%d)", mCurrentState); 59 return INVALID_OPERATION; 60 } 61 62 status_t ret = mMediaRecorder->setPreviewSurface(surface->getISurface()); 63 if (OK != ret) { 64 LOGV("setPreviewSurface failed: %d", ret); 65 mCurrentState = MEDIA_RECORDER_ERROR; 66 return UNKNOWN_ERROR; 67 } 68 return ret; 69} 70 71status_t MediaRecorder::init() 72{ 73 LOGV("init"); 74 if(mMediaRecorder == NULL) { 75 LOGE("media recorder is not initialized yet"); 76 return INVALID_OPERATION; 77 } 78 if (!(mCurrentState & MEDIA_RECORDER_IDLE)) { 79 LOGE("init called in an invalid state(%d)", mCurrentState); 80 return INVALID_OPERATION; 81 } 82 83 status_t ret = mMediaRecorder->init(); 84 if (OK != ret) { 85 LOGV("init failed: %d", ret); 86 mCurrentState = MEDIA_RECORDER_ERROR; 87 return UNKNOWN_ERROR; 88 } 89 mCurrentState = MEDIA_RECORDER_INITIALIZED; 90 return ret; 91} 92 93status_t MediaRecorder::setVideoSource(int vs) 94{ 95 LOGV("setVideoSource(%d)", vs); 96 if(mMediaRecorder == NULL) { 97 LOGE("media recorder is not initialized yet"); 98 return INVALID_OPERATION; 99 } 100 if (mIsVideoSourceSet) { 101 LOGE("video source has already been set"); 102 return INVALID_OPERATION; 103 } 104 if (mCurrentState & MEDIA_RECORDER_IDLE) { 105 LOGV("Call init() since the media recorder is not initialized yet"); 106 status_t ret = init(); 107 if (OK != ret) { 108 return ret; 109 } 110 } 111 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 112 LOGE("setVideoSource called in an invalid state(%d)", mCurrentState); 113 return INVALID_OPERATION; 114 } 115 116 status_t ret = mMediaRecorder->setVideoSource(vs); 117 if (OK != ret) { 118 LOGV("setVideoSource failed: %d", ret); 119 mCurrentState = MEDIA_RECORDER_ERROR; 120 return UNKNOWN_ERROR; 121 } 122 mIsVideoSourceSet = true; 123 return ret; 124} 125 126status_t MediaRecorder::setAudioSource(int as) 127{ 128 LOGV("setAudioSource(%d)", as); 129 if(mMediaRecorder == NULL) { 130 LOGE("media recorder is not initialized yet"); 131 return INVALID_OPERATION; 132 } 133 if (mCurrentState & MEDIA_RECORDER_IDLE) { 134 LOGV("Call init() since the media recorder is not initialized yet"); 135 status_t ret = init(); 136 if (OK != ret) { 137 return ret; 138 } 139 } 140 if (mIsAudioSourceSet) { 141 LOGE("audio source has already been set"); 142 return INVALID_OPERATION; 143 } 144 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 145 LOGE("setAudioSource called in an invalid state(%d)", mCurrentState); 146 return INVALID_OPERATION; 147 } 148 149 status_t ret = mMediaRecorder->setAudioSource(as); 150 if (OK != ret) { 151 LOGV("setAudioSource failed: %d", ret); 152 mCurrentState = MEDIA_RECORDER_ERROR; 153 return UNKNOWN_ERROR; 154 } 155 mIsAudioSourceSet = true; 156 return ret; 157} 158 159status_t MediaRecorder::setOutputFormat(int of) 160{ 161 LOGV("setOutputFormat(%d)", of); 162 if(mMediaRecorder == NULL) { 163 LOGE("media recorder is not initialized yet"); 164 return INVALID_OPERATION; 165 } 166 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 167 LOGE("setOutputFormat called in an invalid state: %d", mCurrentState); 168 return INVALID_OPERATION; 169 } 170 171 status_t ret = mMediaRecorder->setOutputFormat(of); 172 if (OK != ret) { 173 LOGE("setOutputFormat failed: %d", ret); 174 mCurrentState = MEDIA_RECORDER_ERROR; 175 return UNKNOWN_ERROR; 176 } 177 mCurrentState = MEDIA_RECORDER_DATASOURCE_CONFIGURED; 178 return ret; 179} 180 181status_t MediaRecorder::setVideoEncoder(int ve) 182{ 183 LOGV("setVideoEncoder(%d)", ve); 184 if(mMediaRecorder == NULL) { 185 LOGE("media recorder is not initialized yet"); 186 return INVALID_OPERATION; 187 } 188 if (mIsVideoEncoderSet) { 189 LOGE("video encoder has already been set"); 190 return INVALID_OPERATION; 191 } 192 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 193 LOGE("setVideoEncoder called in an invalid state(%d)", mCurrentState); 194 return INVALID_OPERATION; 195 } 196 197 status_t ret = mMediaRecorder->setVideoEncoder(ve); 198 if (OK != ret) { 199 LOGV("setVideoEncoder failed: %d", ret); 200 mCurrentState = MEDIA_RECORDER_ERROR; 201 return UNKNOWN_ERROR; 202 } 203 mIsVideoEncoderSet = true; 204 return ret; 205} 206 207status_t MediaRecorder::setAudioEncoder(int ae) 208{ 209 LOGV("setAudioEncoder(%d)", ae); 210 if(mMediaRecorder == NULL) { 211 LOGE("media recorder is not initialized yet"); 212 return INVALID_OPERATION; 213 } 214 if (mIsAudioEncoderSet) { 215 LOGE("audio encoder has already been set"); 216 return INVALID_OPERATION; 217 } 218 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 219 LOGE("setAudioEncoder called in an invalid state(%d)", mCurrentState); 220 return INVALID_OPERATION; 221 } 222 223 status_t ret = mMediaRecorder->setAudioEncoder(ae); 224 if (OK != ret) { 225 LOGV("setAudioEncoder failed: %d", ret); 226 mCurrentState = MEDIA_RECORDER_ERROR; 227 return UNKNOWN_ERROR; 228 } 229 mIsAudioEncoderSet = true; 230 return ret; 231} 232 233status_t MediaRecorder::setOutputFile(const char* path) 234{ 235 LOGV("setOutputFile(%s)", path); 236 if(mMediaRecorder == NULL) { 237 LOGE("media recorder is not initialized yet"); 238 return INVALID_OPERATION; 239 } 240 if (mIsOutputFileSet) { 241 LOGE("output file has already been set"); 242 return INVALID_OPERATION; 243 } 244 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 245 LOGE("setOutputFile called in an invalid state(%d)", mCurrentState); 246 return INVALID_OPERATION; 247 } 248 249 status_t ret = mMediaRecorder->setOutputFile(path); 250 if (OK != ret) { 251 LOGV("setOutputFile failed: %d", ret); 252 mCurrentState = MEDIA_RECORDER_ERROR; 253 return UNKNOWN_ERROR; 254 } 255 mIsOutputFileSet = true; 256 return ret; 257} 258 259status_t MediaRecorder::setOutputFile(int fd, int64_t offset, int64_t length) 260{ 261 LOGV("setOutputFile(%d, %lld, %lld)", fd, offset, length); 262 if(mMediaRecorder == NULL) { 263 LOGE("media recorder is not initialized yet"); 264 return INVALID_OPERATION; 265 } 266 if (mIsOutputFileSet) { 267 LOGE("output file has already been set"); 268 return INVALID_OPERATION; 269 } 270 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 271 LOGE("setOutputFile called in an invalid state(%d)", mCurrentState); 272 return INVALID_OPERATION; 273 } 274 275 status_t ret = mMediaRecorder->setOutputFile(fd, offset, length); 276 if (OK != ret) { 277 LOGV("setOutputFile failed: %d", ret); 278 mCurrentState = MEDIA_RECORDER_ERROR; 279 return UNKNOWN_ERROR; 280 } 281 mIsOutputFileSet = true; 282 return ret; 283} 284 285status_t MediaRecorder::setVideoSize(int width, int height) 286{ 287 LOGV("setVideoSize(%d, %d)", width, height); 288 if(mMediaRecorder == NULL) { 289 LOGE("media recorder is not initialized yet"); 290 return INVALID_OPERATION; 291 } 292 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 293 LOGE("setVideoSize called in an invalid state: %d", mCurrentState); 294 return INVALID_OPERATION; 295 } 296 297 status_t ret = mMediaRecorder->setVideoSize(width, height); 298 if (OK != ret) { 299 LOGE("setVideoSize failed: %d", ret); 300 mCurrentState = MEDIA_RECORDER_ERROR; 301 return UNKNOWN_ERROR; 302 } 303 return ret; 304} 305 306status_t MediaRecorder::setVideoFrameRate(int frames_per_second) 307{ 308 LOGV("setVideoFrameRate(%d)", frames_per_second); 309 if(mMediaRecorder == NULL) { 310 LOGE("media recorder is not initialized yet"); 311 return INVALID_OPERATION; 312 } 313 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 314 LOGE("setVideoFrameRate called in an invalid state: %d", mCurrentState); 315 return INVALID_OPERATION; 316 } 317 318 status_t ret = mMediaRecorder->setVideoFrameRate(frames_per_second); 319 if (OK != ret) { 320 LOGE("setVideoFrameRate failed: %d", ret); 321 mCurrentState = MEDIA_RECORDER_ERROR; 322 return UNKNOWN_ERROR; 323 } 324 return ret; 325} 326 327status_t MediaRecorder::prepare() 328{ 329 LOGV("prepare"); 330 if(mMediaRecorder == NULL) { 331 LOGE("media recorder is not initialized yet"); 332 return INVALID_OPERATION; 333 } 334 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 335 LOGE("prepare called in an invalid state: %d", mCurrentState); 336 return INVALID_OPERATION; 337 } 338 339 status_t ret = mMediaRecorder->prepare(); 340 if (OK != ret) { 341 LOGE("prepare failed: %d", ret); 342 mCurrentState = MEDIA_RECORDER_ERROR; 343 return UNKNOWN_ERROR; 344 } 345 mCurrentState = MEDIA_RECORDER_PREPARED; 346 return ret; 347} 348 349status_t MediaRecorder::getMaxAmplitude(int* max) 350{ 351 LOGV("getMaxAmplitude"); 352 if(mMediaRecorder == NULL) { 353 LOGE("media recorder is not initialized yet"); 354 return INVALID_OPERATION; 355 } 356 if (mCurrentState & MEDIA_RECORDER_ERROR) { 357 LOGE("getMaxAmplitude called in an invalid state: %d", mCurrentState); 358 return INVALID_OPERATION; 359 } 360 361 status_t ret = mMediaRecorder->getMaxAmplitude(max); 362 if (OK != ret) { 363 LOGE("getMaxAmplitude failed: %d", ret); 364 mCurrentState = MEDIA_RECORDER_ERROR; 365 return UNKNOWN_ERROR; 366 } 367 return ret; 368} 369 370status_t MediaRecorder::start() 371{ 372 LOGV("start"); 373 if (mMediaRecorder == NULL) { 374 LOGE("media recorder is not initialized yet"); 375 return INVALID_OPERATION; 376 } 377 if (!(mCurrentState & MEDIA_RECORDER_PREPARED)) { 378 LOGE("start called in an invalid state: %d", mCurrentState); 379 return INVALID_OPERATION; 380 } 381 382 status_t ret = mMediaRecorder->start(); 383 if (OK != ret) { 384 LOGE("start failed: %d", ret); 385 mCurrentState = MEDIA_RECORDER_ERROR; 386 return UNKNOWN_ERROR; 387 } 388 mCurrentState = MEDIA_RECORDER_RECORDING; 389 return ret; 390} 391 392status_t MediaRecorder::stop() 393{ 394 LOGV("stop"); 395 if (mMediaRecorder == NULL) { 396 LOGE("media recorder is not initialized yet"); 397 return INVALID_OPERATION; 398 } 399 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 400 LOGE("stop called in an invalid state: %d", mCurrentState); 401 return INVALID_OPERATION; 402 } 403 404 status_t ret = mMediaRecorder->stop(); 405 if (OK != ret) { 406 LOGE("stop failed: %d", ret); 407 mCurrentState = MEDIA_RECORDER_ERROR; 408 return UNKNOWN_ERROR; 409 } 410 mCurrentState = MEDIA_RECORDER_IDLE; 411 return ret; 412} 413 414// Reset should be OK in any state 415status_t MediaRecorder::reset() 416{ 417 LOGV("reset"); 418 if (mMediaRecorder == NULL) { 419 LOGE("media recorder is not initialized yet"); 420 return INVALID_OPERATION; 421 } 422 423 doCleanUp(); 424 status_t ret = UNKNOWN_ERROR; 425 switch(mCurrentState) { 426 case MEDIA_RECORDER_IDLE: 427 ret = OK; 428 break; 429 430 case MEDIA_RECORDER_RECORDING: 431 case MEDIA_RECORDER_DATASOURCE_CONFIGURED: 432 case MEDIA_RECORDER_PREPARED: 433 case MEDIA_RECORDER_ERROR: { 434 ret = doReset(); 435 if (OK != ret) { 436 return ret; // No need to continue 437 } 438 } // Intentional fall through 439 case MEDIA_RECORDER_INITIALIZED: 440 ret = close(); 441 break; 442 443 default: { 444 LOGE("Unexpected non-existing state: %d", mCurrentState); 445 break; 446 } 447 } 448 return ret; 449} 450 451status_t MediaRecorder::close() 452{ 453 LOGV("close"); 454 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 455 LOGE("close called in an invalid state: %d", mCurrentState); 456 return INVALID_OPERATION; 457 } 458 status_t ret = mMediaRecorder->close(); 459 if (OK != ret) { 460 LOGE("close failed: %d", ret); 461 mCurrentState = MEDIA_RECORDER_ERROR; 462 return UNKNOWN_ERROR; 463 } else { 464 mCurrentState = MEDIA_RECORDER_IDLE; 465 } 466 return ret; 467} 468 469status_t MediaRecorder::doReset() 470{ 471 LOGV("doReset"); 472 status_t ret = mMediaRecorder->reset(); 473 if (OK != ret) { 474 LOGE("doReset failed: %d", ret); 475 mCurrentState = MEDIA_RECORDER_ERROR; 476 return UNKNOWN_ERROR; 477 } else { 478 mCurrentState = MEDIA_RECORDER_INITIALIZED; 479 } 480 return ret; 481} 482 483void MediaRecorder::doCleanUp() 484{ 485 LOGV("doCleanUp"); 486 mIsAudioSourceSet = false; 487 mIsVideoSourceSet = false; 488 mIsAudioEncoderSet = false; 489 mIsVideoEncoderSet = false; 490 mIsOutputFileSet = false; 491} 492 493// Release should be OK in any state 494status_t MediaRecorder::release() 495{ 496 LOGV("release"); 497 if (mMediaRecorder != NULL) { 498 return mMediaRecorder->release(); 499 } 500 return INVALID_OPERATION; 501} 502 503MediaRecorder::MediaRecorder() 504{ 505 LOGV("constructor"); 506 sp<IServiceManager> sm = defaultServiceManager(); 507 sp<IBinder> binder; 508 509 do { 510 binder = sm->getService(String16("media.player")); 511 if (binder != NULL) { 512 break; 513 } 514 LOGW("MediaPlayerService not published, waiting..."); 515 usleep(500000); // 0.5 s 516 } while(true); 517 518 sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder); 519 if (service != NULL) { 520 mMediaRecorder = service->createMediaRecorder(getpid()); 521 } 522 if (mMediaRecorder != NULL) { 523 mCurrentState = MEDIA_RECORDER_IDLE; 524 } 525 doCleanUp(); 526} 527 528status_t MediaRecorder::initCheck() 529{ 530 return mMediaRecorder != 0 ? NO_ERROR : NO_INIT; 531} 532 533MediaRecorder::~MediaRecorder() 534{ 535 LOGV("destructor"); 536 if (mMediaRecorder != NULL) { 537 mMediaRecorder.clear(); 538 } 539} 540 541}; // namespace android 542 543