mediarecorder.cpp revision dd172fce75b2a1c3cb3a5d3b3bbb5020b1ae8675 
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 <binder/IServiceManager.h>
24#include <utils/String8.h>
25#include <media/IMediaPlayerService.h>
26#include <media/IMediaRecorder.h>
27#include <media/mediaplayer.h>  // for MEDIA_ERROR_SERVER_DIED
28
29namespace android {
30
31status_t MediaRecorder::setCamera(const sp<ICamera>& camera)
32{
33    LOGV("setCamera(%p)", camera.get());
34    if(mMediaRecorder == NULL) {
35        LOGE("media recorder is not initialized yet");
36        return INVALID_OPERATION;
37    }
38    if (!(mCurrentState & MEDIA_RECORDER_IDLE)) {
39        LOGE("setCamera called in an invalid state(%d)", mCurrentState);
40        return INVALID_OPERATION;
41    }
42
43    status_t ret = mMediaRecorder->setCamera(camera);
44    if (OK != ret) {
45        LOGV("setCamera failed: %d", ret);
46        mCurrentState = MEDIA_RECORDER_ERROR;
47        return ret;
48    }
49    return ret;
50}
51
52status_t MediaRecorder::setPreviewSurface(const sp<Surface>& surface)
53{
54    LOGV("setPreviewSurface(%p)", surface.get());
55    if(mMediaRecorder == NULL) {
56        LOGE("media recorder is not initialized yet");
57        return INVALID_OPERATION;
58    }
59    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
60        LOGE("setPreviewSurface called in an invalid state(%d)", mCurrentState);
61        return INVALID_OPERATION;
62    }
63    if (!mIsVideoSourceSet) {
64        LOGE("try to set preview surface without setting the video source first");
65        return INVALID_OPERATION;
66    }
67
68    status_t ret = mMediaRecorder->setPreviewSurface(surface->getISurface());
69    if (OK != ret) {
70        LOGV("setPreviewSurface failed: %d", ret);
71        mCurrentState = MEDIA_RECORDER_ERROR;
72        return ret;
73    }
74    return ret;
75}
76
77status_t MediaRecorder::init()
78{
79    LOGV("init");
80    if(mMediaRecorder == NULL) {
81        LOGE("media recorder is not initialized yet");
82        return INVALID_OPERATION;
83    }
84    if (!(mCurrentState & MEDIA_RECORDER_IDLE)) {
85        LOGE("init called in an invalid state(%d)", mCurrentState);
86        return INVALID_OPERATION;
87    }
88
89    status_t ret = mMediaRecorder->init();
90    if (OK != ret) {
91        LOGV("init failed: %d", ret);
92        mCurrentState = MEDIA_RECORDER_ERROR;
93        return ret;
94    }
95
96    ret = mMediaRecorder->setListener(this);
97    if (OK != ret) {
98        LOGV("setListener failed: %d", ret);
99        mCurrentState = MEDIA_RECORDER_ERROR;
100        return ret;
101    }
102
103    mCurrentState = MEDIA_RECORDER_INITIALIZED;
104    return ret;
105}
106
107status_t MediaRecorder::setVideoSource(int vs)
108{
109    LOGV("setVideoSource(%d)", vs);
110    if(mMediaRecorder == NULL) {
111        LOGE("media recorder is not initialized yet");
112        return INVALID_OPERATION;
113    }
114    if (mIsVideoSourceSet) {
115        LOGE("video source has already been set");
116        return INVALID_OPERATION;
117    }
118    if (mCurrentState & MEDIA_RECORDER_IDLE) {
119        LOGV("Call init() since the media recorder is not initialized yet");
120        status_t ret = init();
121        if (OK != ret) {
122            return ret;
123        }
124    }
125    if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) {
126        LOGE("setVideoSource called in an invalid state(%d)", mCurrentState);
127        return INVALID_OPERATION;
128    }
129
130    status_t ret = mMediaRecorder->setVideoSource(vs);
131    if (OK != ret) {
132        LOGV("setVideoSource failed: %d", ret);
133        mCurrentState = MEDIA_RECORDER_ERROR;
134        return ret;
135    }
136    mIsVideoSourceSet = true;
137    return ret;
138}
139
140status_t MediaRecorder::setAudioSource(int as)
141{
142    LOGV("setAudioSource(%d)", as);
143    if(mMediaRecorder == NULL) {
144        LOGE("media recorder is not initialized yet");
145        return INVALID_OPERATION;
146    }
147    if (mCurrentState & MEDIA_RECORDER_IDLE) {
148        LOGV("Call init() since the media recorder is not initialized yet");
149        status_t ret = init();
150        if (OK != ret) {
151            return ret;
152        }
153    }
154    if (mIsAudioSourceSet) {
155        LOGE("audio source has already been set");
156        return INVALID_OPERATION;
157    }
158    if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) {
159        LOGE("setAudioSource called in an invalid state(%d)", mCurrentState);
160        return INVALID_OPERATION;
161    }
162
163    status_t ret = mMediaRecorder->setAudioSource(as);
164    if (OK != ret) {
165        LOGV("setAudioSource failed: %d", ret);
166        mCurrentState = MEDIA_RECORDER_ERROR;
167        return ret;
168    }
169    mIsAudioSourceSet = true;
170    return ret;
171}
172
173status_t MediaRecorder::setOutputFormat(int of)
174{
175    LOGV("setOutputFormat(%d)", of);
176    if(mMediaRecorder == NULL) {
177        LOGE("media recorder is not initialized yet");
178        return INVALID_OPERATION;
179    }
180    if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) {
181        LOGE("setOutputFormat called in an invalid state: %d", mCurrentState);
182        return INVALID_OPERATION;
183    }
184    if (mIsVideoSourceSet && of >= OUTPUT_FORMAT_AUDIO_ONLY_START) { //first non-video output format
185        LOGE("output format (%d) is meant for audio recording only and incompatible with video recording", of);
186        return INVALID_OPERATION;
187    }
188
189    status_t ret = mMediaRecorder->setOutputFormat(of);
190    if (OK != ret) {
191        LOGE("setOutputFormat failed: %d", ret);
192        mCurrentState = MEDIA_RECORDER_ERROR;
193        return ret;
194    }
195    mCurrentState = MEDIA_RECORDER_DATASOURCE_CONFIGURED;
196    return ret;
197}
198
199status_t MediaRecorder::setVideoEncoder(int ve)
200{
201    LOGV("setVideoEncoder(%d)", ve);
202    if(mMediaRecorder == NULL) {
203        LOGE("media recorder is not initialized yet");
204        return INVALID_OPERATION;
205    }
206    if (!mIsVideoSourceSet) {
207        LOGE("try to set the video encoder without setting the video source first");
208        return INVALID_OPERATION;
209    }
210    if (mIsVideoEncoderSet) {
211        LOGE("video encoder has already been set");
212        return INVALID_OPERATION;
213    }
214    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
215        LOGE("setVideoEncoder called in an invalid state(%d)", mCurrentState);
216        return INVALID_OPERATION;
217    }
218
219    status_t ret = mMediaRecorder->setVideoEncoder(ve);
220    if (OK != ret) {
221        LOGV("setVideoEncoder failed: %d", ret);
222        mCurrentState = MEDIA_RECORDER_ERROR;
223        return ret;
224    }
225    mIsVideoEncoderSet = true;
226    return ret;
227}
228
229status_t MediaRecorder::setAudioEncoder(int ae)
230{
231    LOGV("setAudioEncoder(%d)", ae);
232    if(mMediaRecorder == NULL) {
233        LOGE("media recorder is not initialized yet");
234        return INVALID_OPERATION;
235    }
236    if (!mIsAudioSourceSet) {
237        LOGE("try to set the audio encoder without setting the audio source first");
238        return INVALID_OPERATION;
239    }
240    if (mIsAudioEncoderSet) {
241        LOGE("audio encoder has already been set");
242        return INVALID_OPERATION;
243    }
244    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
245        LOGE("setAudioEncoder called in an invalid state(%d)", mCurrentState);
246        return INVALID_OPERATION;
247    }
248
249    status_t ret = mMediaRecorder->setAudioEncoder(ae);
250    if (OK != ret) {
251        LOGV("setAudioEncoder failed: %d", ret);
252        mCurrentState = MEDIA_RECORDER_ERROR;
253        return ret;
254    }
255    mIsAudioEncoderSet = true;
256    return ret;
257}
258
259status_t MediaRecorder::setOutputFile(const char* path)
260{
261    LOGV("setOutputFile(%s)", path);
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(path);
276    if (OK != ret) {
277        LOGV("setOutputFile failed: %d", ret);
278        mCurrentState = MEDIA_RECORDER_ERROR;
279        return ret;
280    }
281    mIsOutputFileSet = true;
282    return ret;
283}
284
285status_t MediaRecorder::setOutputFile(int fd, int64_t offset, int64_t length)
286{
287    LOGV("setOutputFile(%d, %lld, %lld)", fd, offset, length);
288    if(mMediaRecorder == NULL) {
289        LOGE("media recorder is not initialized yet");
290        return INVALID_OPERATION;
291    }
292    if (mIsOutputFileSet) {
293        LOGE("output file has already been set");
294        return INVALID_OPERATION;
295    }
296    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
297        LOGE("setOutputFile called in an invalid state(%d)", mCurrentState);
298        return INVALID_OPERATION;
299    }
300
301    status_t ret = mMediaRecorder->setOutputFile(fd, offset, length);
302    if (OK != ret) {
303        LOGV("setOutputFile failed: %d", ret);
304        mCurrentState = MEDIA_RECORDER_ERROR;
305        return ret;
306    }
307    mIsOutputFileSet = true;
308    return ret;
309}
310
311status_t MediaRecorder::setVideoSize(int width, int height)
312{
313    LOGV("setVideoSize(%d, %d)", width, height);
314    if(mMediaRecorder == NULL) {
315        LOGE("media recorder is not initialized yet");
316        return INVALID_OPERATION;
317    }
318    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
319        LOGE("setVideoSize called in an invalid state: %d", mCurrentState);
320        return INVALID_OPERATION;
321    }
322    if (!mIsVideoSourceSet) {
323        LOGE("try to set video size without setting video source first");
324        return INVALID_OPERATION;
325    }
326
327    status_t ret = mMediaRecorder->setVideoSize(width, height);
328    if (OK != ret) {
329        LOGE("setVideoSize failed: %d", ret);
330        mCurrentState = MEDIA_RECORDER_ERROR;
331        return ret;
332    }
333    return ret;
334}
335
336status_t MediaRecorder::setVideoFrameRate(int frames_per_second)
337{
338    LOGV("setVideoFrameRate(%d)", frames_per_second);
339    if(mMediaRecorder == NULL) {
340        LOGE("media recorder is not initialized yet");
341        return INVALID_OPERATION;
342    }
343    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
344        LOGE("setVideoFrameRate called in an invalid state: %d", mCurrentState);
345        return INVALID_OPERATION;
346    }
347    if (!mIsVideoSourceSet) {
348        LOGE("try to set video frame rate without setting video source first");
349        return INVALID_OPERATION;
350    }
351
352    status_t ret = mMediaRecorder->setVideoFrameRate(frames_per_second);
353    if (OK != ret) {
354        LOGE("setVideoFrameRate failed: %d", ret);
355        mCurrentState = MEDIA_RECORDER_ERROR;
356        return ret;
357    }
358    return ret;
359}
360
361status_t MediaRecorder::setParameters(const String8& params) {
362    LOGV("setParameters(%s)", params.string());
363    if(mMediaRecorder == NULL) {
364        LOGE("media recorder is not initialized yet");
365        return INVALID_OPERATION;
366    }
367
368    status_t ret = mMediaRecorder->setParameters(params);
369    if (OK != ret) {
370        LOGE("setParameters(%s) failed: %d", params.string(), ret);
371        // Do not change our current state to MEDIA_RECORDER_ERROR, failures
372        // of the only currently supported parameters, "max-duration" and
373        // "max-filesize" are _not_ fatal.
374    }
375
376    return ret;
377}
378
379status_t MediaRecorder::prepare()
380{
381    LOGV("prepare");
382    if(mMediaRecorder == NULL) {
383        LOGE("media recorder is not initialized yet");
384        return INVALID_OPERATION;
385    }
386    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {
387        LOGE("prepare called in an invalid state: %d", mCurrentState);
388        return INVALID_OPERATION;
389    }
390    if (mIsAudioSourceSet != mIsAudioEncoderSet) {
391        if (mIsAudioSourceSet) {
392            LOGE("audio source is set, but audio encoder is not set");
393        } else {  // must not happen, since setAudioEncoder checks this already
394            LOGE("audio encoder is set, but audio source is not set");
395        }
396        return INVALID_OPERATION;
397    }
398
399    if (mIsVideoSourceSet != mIsVideoEncoderSet) {
400        if (mIsVideoSourceSet) {
401            LOGE("video source is set, but video encoder is not set");
402        } else {  // must not happen, since setVideoEncoder checks this already
403            LOGE("video encoder is set, but video source is not set");
404        }
405        return INVALID_OPERATION;
406    }
407
408    status_t ret = mMediaRecorder->prepare();
409    if (OK != ret) {
410        LOGE("prepare failed: %d", ret);
411        mCurrentState = MEDIA_RECORDER_ERROR;
412        return ret;
413    }
414    mCurrentState = MEDIA_RECORDER_PREPARED;
415    return ret;
416}
417
418status_t MediaRecorder::getMaxAmplitude(int* max)
419{
420    LOGV("getMaxAmplitude");
421    if(mMediaRecorder == NULL) {
422        LOGE("media recorder is not initialized yet");
423        return INVALID_OPERATION;
424    }
425    if (mCurrentState & MEDIA_RECORDER_ERROR) {
426        LOGE("getMaxAmplitude called in an invalid state: %d", mCurrentState);
427        return INVALID_OPERATION;
428    }
429
430    status_t ret = mMediaRecorder->getMaxAmplitude(max);
431    if (OK != ret) {
432        LOGE("getMaxAmplitude failed: %d", ret);
433        mCurrentState = MEDIA_RECORDER_ERROR;
434        return ret;
435    }
436    return ret;
437}
438
439status_t MediaRecorder::start()
440{
441    LOGV("start");
442    if (mMediaRecorder == NULL) {
443        LOGE("media recorder is not initialized yet");
444        return INVALID_OPERATION;
445    }
446    if (!(mCurrentState & MEDIA_RECORDER_PREPARED)) {
447        LOGE("start called in an invalid state: %d", mCurrentState);
448        return INVALID_OPERATION;
449    }
450
451    status_t ret = mMediaRecorder->start();
452    if (OK != ret) {
453        LOGE("start failed: %d", ret);
454        mCurrentState = MEDIA_RECORDER_ERROR;
455        return ret;
456    }
457    mCurrentState = MEDIA_RECORDER_RECORDING;
458    return ret;
459}
460
461status_t MediaRecorder::stop()
462{
463    LOGV("stop");
464    if (mMediaRecorder == NULL) {
465        LOGE("media recorder is not initialized yet");
466        return INVALID_OPERATION;
467    }
468    if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) {
469        LOGE("stop called in an invalid state: %d", mCurrentState);
470        return INVALID_OPERATION;
471    }
472
473    status_t ret = mMediaRecorder->stop();
474    if (OK != ret) {
475        LOGE("stop failed: %d", ret);
476        mCurrentState = MEDIA_RECORDER_ERROR;
477        return ret;
478    }
479
480    // FIXME:
481    // stop and reset are semantically different.
482    // We treat them the same for now, and will change this in the future.
483    doCleanUp();
484    mCurrentState = MEDIA_RECORDER_IDLE;
485    return ret;
486}
487
488// Reset should be OK in any state
489status_t MediaRecorder::reset()
490{
491    LOGV("reset");
492    if (mMediaRecorder == NULL) {
493        LOGE("media recorder is not initialized yet");
494        return INVALID_OPERATION;
495    }
496
497    doCleanUp();
498    status_t ret = UNKNOWN_ERROR;
499    switch(mCurrentState) {
500        case MEDIA_RECORDER_IDLE:
501            ret = OK;
502            break;
503
504        case MEDIA_RECORDER_RECORDING:
505        case MEDIA_RECORDER_DATASOURCE_CONFIGURED:
506        case MEDIA_RECORDER_PREPARED:
507        case MEDIA_RECORDER_ERROR: {
508            ret = doReset();
509            if (OK != ret) {
510               return ret;  // No need to continue
511            }
512        }  // Intentional fall through
513        case MEDIA_RECORDER_INITIALIZED:
514            ret = close();
515            break;
516
517        default: {
518            LOGE("Unexpected non-existing state: %d", mCurrentState);
519            break;
520        }
521    }
522    return ret;
523}
524
525status_t MediaRecorder::close()
526{
527    LOGV("close");
528    if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) {
529        LOGE("close called in an invalid state: %d", mCurrentState);
530        return INVALID_OPERATION;
531    }
532    status_t ret = mMediaRecorder->close();
533    if (OK != ret) {
534        LOGE("close failed: %d", ret);
535        mCurrentState = MEDIA_RECORDER_ERROR;
536        return UNKNOWN_ERROR;
537    } else {
538        mCurrentState = MEDIA_RECORDER_IDLE;
539    }
540    return ret;
541}
542
543status_t MediaRecorder::doReset()
544{
545    LOGV("doReset");
546    status_t ret = mMediaRecorder->reset();
547    if (OK != ret) {
548        LOGE("doReset failed: %d", ret);
549        mCurrentState = MEDIA_RECORDER_ERROR;
550        return ret;
551    } else {
552        mCurrentState = MEDIA_RECORDER_INITIALIZED;
553    }
554    return ret;
555}
556
557void MediaRecorder::doCleanUp()
558{
559    LOGV("doCleanUp");
560    mIsAudioSourceSet  = false;
561    mIsVideoSourceSet  = false;
562    mIsAudioEncoderSet = false;
563    mIsVideoEncoderSet = false;
564    mIsOutputFileSet   = false;
565}
566
567// Release should be OK in any state
568status_t MediaRecorder::release()
569{
570    LOGV("release");
571    if (mMediaRecorder != NULL) {
572        return mMediaRecorder->release();
573    }
574    return INVALID_OPERATION;
575}
576
577MediaRecorder::MediaRecorder()
578{
579    LOGV("constructor");
580
581    const sp<IMediaPlayerService>& service(getMediaPlayerService());
582    if (service != NULL) {
583        mMediaRecorder = service->createMediaRecorder(getpid());
584    }
585    if (mMediaRecorder != NULL) {
586        mCurrentState = MEDIA_RECORDER_IDLE;
587    }
588    doCleanUp();
589}
590
591status_t MediaRecorder::initCheck()
592{
593    return mMediaRecorder != 0 ? NO_ERROR : NO_INIT;
594}
595
596MediaRecorder::~MediaRecorder()
597{
598    LOGV("destructor");
599    if (mMediaRecorder != NULL) {
600        mMediaRecorder.clear();
601    }
602}
603
604status_t MediaRecorder::setListener(const sp<MediaRecorderListener>& listener)
605{
606    LOGV("setListener");
607    Mutex::Autolock _l(mLock);
608    mListener = listener;
609
610    return NO_ERROR;
611}
612
613void MediaRecorder::notify(int msg, int ext1, int ext2)
614{
615    LOGV("message received msg=%d, ext1=%d, ext2=%d", msg, ext1, ext2);
616
617    sp<MediaRecorderListener> listener;
618    mLock.lock();
619    listener = mListener;
620    mLock.unlock();
621
622    if (listener != NULL) {
623        Mutex::Autolock _l(mNotifyLock);
624        LOGV("callback application");
625        listener->notify(msg, ext1, ext2);
626        LOGV("back from callback");
627    }
628}
629
630void MediaRecorder::died()
631{
632    LOGV("died");
633    notify(MEDIA_RECORDER_EVENT_ERROR, MEDIA_ERROR_SERVER_DIED, 0);
634}
635
636}; // namespace android
637
638