Home | History | Annotate | Download | only in libmediaplayerservice 
      1 /*
      2  * Copyright (C) 2009 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 0
     18 #define LOG_TAG "StagefrightRecorder"
     19 #include <inttypes.h>
     20 #include <utils/Log.h>
     21 
     22 #include "WebmWriter.h"
     23 #include "StagefrightRecorder.h"
     24 
     25 #include <algorithm>
     26 
     27 #include <android/hardware/ICamera.h>
     28 
     29 #include <binder/IPCThreadState.h>
     30 #include <binder/IServiceManager.h>
     31 
     32 #include <media/IMediaPlayerService.h>
     33 #include <media/MediaAnalyticsItem.h>
     34 #include <media/stagefright/foundation/ABuffer.h>
     35 #include <media/stagefright/foundation/ADebug.h>
     36 #include <media/stagefright/foundation/AMessage.h>
     37 #include <media/stagefright/foundation/ALooper.h>
     38 #include <media/stagefright/ACodec.h>
     39 #include <media/stagefright/AudioSource.h>
     40 #include <media/stagefright/AMRWriter.h>
     41 #include <media/stagefright/AACWriter.h>
     42 #include <media/stagefright/CameraSource.h>
     43 #include <media/stagefright/CameraSourceTimeLapse.h>
     44 #include <media/stagefright/MPEG2TSWriter.h>
     45 #include <media/stagefright/MPEG4Writer.h>
     46 #include <media/stagefright/MediaDefs.h>
     47 #include <media/stagefright/MetaData.h>
     48 #include <media/stagefright/MediaCodecSource.h>
     49 #include <media/stagefright/PersistentSurface.h>
     50 #include <media/MediaProfiles.h>
     51 #include <camera/CameraParameters.h>
     52 
     53 #include <utils/Errors.h>
     54 #include <sys/types.h>
     55 #include <ctype.h>
     56 #include <unistd.h>
     57 
     58 #include <system/audio.h>
     59 
     60 #include "ARTPWriter.h"
     61 
     62 namespace android {
     63 
     64 static const float kTypicalDisplayRefreshingRate = 60.f;
     65 // display refresh rate drops on battery saver
     66 static const float kMinTypicalDisplayRefreshingRate = kTypicalDisplayRefreshingRate / 2;
     67 static const int kMaxNumVideoTemporalLayers = 8;
     68 
     69 // key for media statistics
     70 static const char *kKeyRecorder = "recorder";
     71 // attrs for media statistics
     72 static const char *kRecorderHeight = "android.media.mediarecorder.height";
     73 static const char *kRecorderWidth = "android.media.mediarecorder.width";
     74 static const char *kRecorderFrameRate = "android.media.mediarecorder.frame-rate";
     75 static const char *kRecorderVideoBitrate = "android.media.mediarecorder.video-bitrate";
     76 static const char *kRecorderAudioSampleRate = "android.media.mediarecorder.audio-samplerate";
     77 static const char *kRecorderAudioChannels = "android.media.mediarecorder.audio-channels";
     78 static const char *kRecorderAudioBitrate = "android.media.mediarecorder.audio-bitrate";
     79 static const char *kRecorderVideoIframeInterval = "android.media.mediarecorder.video-iframe-interval";
     80 static const char *kRecorderMovieTimescale = "android.media.mediarecorder.movie-timescale";
     81 static const char *kRecorderAudioTimescale = "android.media.mediarecorder.audio-timescale";
     82 static const char *kRecorderVideoTimescale = "android.media.mediarecorder.video-timescale";
     83 static const char *kRecorderVideoProfile = "android.media.mediarecorder.video-encoder-profile";
     84 static const char *kRecorderVideoLevel = "android.media.mediarecorder.video-encoder-level";
     85 static const char *kRecorderCaptureFpsEnable = "android.media.mediarecorder.capture-fpsenable";
     86 static const char *kRecorderCaptureFps = "android.media.mediarecorder.capture-fps";
     87 static const char *kRecorderRotation = "android.media.mediarecorder.rotation";
     88 
     89 // To collect the encoder usage for the battery app
     90 static void addBatteryData(uint32_t params) {
     91     sp<IBinder> binder =
     92         defaultServiceManager()->getService(String16("media.player"));
     93     sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);
     94     CHECK(service.get() != NULL);
     95 
     96     service->addBatteryData(params);
     97 }
     98 
     99 
    100 StagefrightRecorder::StagefrightRecorder(const String16 &opPackageName)
    101     : MediaRecorderBase(opPackageName),
    102       mWriter(NULL),
    103       mOutputFd(-1),
    104       mAudioSource(AUDIO_SOURCE_CNT),
    105       mVideoSource(VIDEO_SOURCE_LIST_END),
    106       mStarted(false) {
    107 
    108     ALOGV("Constructor");
    109 
    110     mAnalyticsDirty = false;
    111     reset();
    112 }
    113 
    114 StagefrightRecorder::~StagefrightRecorder() {
    115     ALOGV("Destructor");
    116     stop();
    117 
    118     if (mLooper != NULL) {
    119         mLooper->stop();
    120     }
    121 
    122     // log the current record, provided it has some information worth recording
    123     if (mAnalyticsDirty && mAnalyticsItem != NULL) {
    124         updateMetrics();
    125         if (mAnalyticsItem->count() > 0) {
    126             mAnalyticsItem->setFinalized(true);
    127             mAnalyticsItem->selfrecord();
    128         }
    129         delete mAnalyticsItem;
    130         mAnalyticsItem = NULL;
    131     }
    132 }
    133 
    134 void StagefrightRecorder::updateMetrics() {
    135     ALOGV("updateMetrics");
    136 
    137     // we'll populate the values from the raw fields.
    138     // (NOT going to populate as we go through the various set* ops)
    139 
    140     // TBD mOutputFormat  = OUTPUT_FORMAT_THREE_GPP;
    141     // TBD mAudioEncoder  = AUDIO_ENCODER_AMR_NB;
    142     // TBD mVideoEncoder  = VIDEO_ENCODER_DEFAULT;
    143     mAnalyticsItem->setInt32(kRecorderHeight, mVideoHeight);
    144     mAnalyticsItem->setInt32(kRecorderWidth, mVideoWidth);
    145     mAnalyticsItem->setInt32(kRecorderFrameRate, mFrameRate);
    146     mAnalyticsItem->setInt32(kRecorderVideoBitrate, mVideoBitRate);
    147     mAnalyticsItem->setInt32(kRecorderAudioSampleRate, mSampleRate);
    148     mAnalyticsItem->setInt32(kRecorderAudioChannels, mAudioChannels);
    149     mAnalyticsItem->setInt32(kRecorderAudioBitrate, mAudioBitRate);
    150     // TBD mInterleaveDurationUs = 0;
    151     mAnalyticsItem->setInt32(kRecorderVideoIframeInterval, mIFramesIntervalSec);
    152     // TBD mAudioSourceNode = 0;
    153     // TBD mUse64BitFileOffset = false;
    154     mAnalyticsItem->setInt32(kRecorderMovieTimescale, mMovieTimeScale);
    155     mAnalyticsItem->setInt32(kRecorderAudioTimescale, mAudioTimeScale);
    156     mAnalyticsItem->setInt32(kRecorderVideoTimescale, mVideoTimeScale);
    157     // TBD mCameraId        = 0;
    158     // TBD mStartTimeOffsetMs = -1;
    159     mAnalyticsItem->setInt32(kRecorderVideoProfile, mVideoEncoderProfile);
    160     mAnalyticsItem->setInt32(kRecorderVideoLevel, mVideoEncoderLevel);
    161     // TBD mMaxFileDurationUs = 0;
    162     // TBD mMaxFileSizeBytes = 0;
    163     // TBD mTrackEveryTimeDurationUs = 0;
    164     mAnalyticsItem->setInt32(kRecorderCaptureFpsEnable, mCaptureFpsEnable);
    165     mAnalyticsItem->setDouble(kRecorderCaptureFps, mCaptureFps);
    166     // TBD mCaptureFps = -1.0;
    167     // TBD mCameraSourceTimeLapse = NULL;
    168     // TBD mMetaDataStoredInVideoBuffers = kMetadataBufferTypeInvalid;
    169     // TBD mEncoderProfiles = MediaProfiles::getInstance();
    170     mAnalyticsItem->setInt32(kRecorderRotation, mRotationDegrees);
    171     // PII mLatitudex10000 = -3600000;
    172     // PII mLongitudex10000 = -3600000;
    173     // TBD mTotalBitRate = 0;
    174 
    175     // TBD: some duration information (capture, paused)
    176     //
    177 
    178 }
    179 
    180 void StagefrightRecorder::resetMetrics() {
    181     ALOGV("resetMetrics");
    182     // flush anything we have, restart the record
    183     if (mAnalyticsDirty && mAnalyticsItem != NULL) {
    184         updateMetrics();
    185         if (mAnalyticsItem->count() > 0) {
    186             mAnalyticsItem->setFinalized(true);
    187             mAnalyticsItem->selfrecord();
    188         }
    189         delete mAnalyticsItem;
    190         mAnalyticsItem = NULL;
    191     }
    192     mAnalyticsItem = new MediaAnalyticsItem(kKeyRecorder);
    193     (void) mAnalyticsItem->generateSessionID();
    194     mAnalyticsDirty = false;
    195 }
    196 
    197 status_t StagefrightRecorder::init() {
    198     ALOGV("init");
    199 
    200     mLooper = new ALooper;
    201     mLooper->setName("recorder_looper");
    202     mLooper->start();
    203 
    204     return OK;
    205 }
    206 
    207 // The client side of mediaserver asks it to creat a SurfaceMediaSource
    208 // and return a interface reference. The client side will use that
    209 // while encoding GL Frames
    210 sp<IGraphicBufferProducer> StagefrightRecorder::querySurfaceMediaSource() const {
    211     ALOGV("Get SurfaceMediaSource");
    212     return mGraphicBufferProducer;
    213 }
    214 
    215 status_t StagefrightRecorder::setAudioSource(audio_source_t as) {
    216     ALOGV("setAudioSource: %d", as);
    217     if (as < AUDIO_SOURCE_DEFAULT ||
    218         (as >= AUDIO_SOURCE_CNT && as != AUDIO_SOURCE_FM_TUNER)) {
    219         ALOGE("Invalid audio source: %d", as);
    220         return BAD_VALUE;
    221     }
    222 
    223     if (as == AUDIO_SOURCE_DEFAULT) {
    224         mAudioSource = AUDIO_SOURCE_MIC;
    225     } else {
    226         mAudioSource = as;
    227     }
    228 
    229     return OK;
    230 }
    231 
    232 status_t StagefrightRecorder::setVideoSource(video_source vs) {
    233     ALOGV("setVideoSource: %d", vs);
    234     if (vs < VIDEO_SOURCE_DEFAULT ||
    235         vs >= VIDEO_SOURCE_LIST_END) {
    236         ALOGE("Invalid video source: %d", vs);
    237         return BAD_VALUE;
    238     }
    239 
    240     if (vs == VIDEO_SOURCE_DEFAULT) {
    241         mVideoSource = VIDEO_SOURCE_CAMERA;
    242     } else {
    243         mVideoSource = vs;
    244     }
    245 
    246     return OK;
    247 }
    248 
    249 status_t StagefrightRecorder::setOutputFormat(output_format of) {
    250     ALOGV("setOutputFormat: %d", of);
    251     if (of < OUTPUT_FORMAT_DEFAULT ||
    252         of >= OUTPUT_FORMAT_LIST_END) {
    253         ALOGE("Invalid output format: %d", of);
    254         return BAD_VALUE;
    255     }
    256 
    257     if (of == OUTPUT_FORMAT_DEFAULT) {
    258         mOutputFormat = OUTPUT_FORMAT_THREE_GPP;
    259     } else {
    260         mOutputFormat = of;
    261     }
    262 
    263     return OK;
    264 }
    265 
    266 status_t StagefrightRecorder::setAudioEncoder(audio_encoder ae) {
    267     ALOGV("setAudioEncoder: %d", ae);
    268     if (ae < AUDIO_ENCODER_DEFAULT ||
    269         ae >= AUDIO_ENCODER_LIST_END) {
    270         ALOGE("Invalid audio encoder: %d", ae);
    271         return BAD_VALUE;
    272     }
    273 
    274     if (ae == AUDIO_ENCODER_DEFAULT) {
    275         mAudioEncoder = AUDIO_ENCODER_AMR_NB;
    276     } else {
    277         mAudioEncoder = ae;
    278     }
    279 
    280     return OK;
    281 }
    282 
    283 status_t StagefrightRecorder::setVideoEncoder(video_encoder ve) {
    284     ALOGV("setVideoEncoder: %d", ve);
    285     if (ve < VIDEO_ENCODER_DEFAULT ||
    286         ve >= VIDEO_ENCODER_LIST_END) {
    287         ALOGE("Invalid video encoder: %d", ve);
    288         return BAD_VALUE;
    289     }
    290 
    291     mVideoEncoder = ve;
    292 
    293     return OK;
    294 }
    295 
    296 status_t StagefrightRecorder::setVideoSize(int width, int height) {
    297     ALOGV("setVideoSize: %dx%d", width, height);
    298     if (width <= 0 || height <= 0) {
    299         ALOGE("Invalid video size: %dx%d", width, height);
    300         return BAD_VALUE;
    301     }
    302 
    303     // Additional check on the dimension will be performed later
    304     mVideoWidth = width;
    305     mVideoHeight = height;
    306 
    307     return OK;
    308 }
    309 
    310 status_t StagefrightRecorder::setVideoFrameRate(int frames_per_second) {
    311     ALOGV("setVideoFrameRate: %d", frames_per_second);
    312     if ((frames_per_second <= 0 && frames_per_second != -1) ||
    313         frames_per_second > kMaxHighSpeedFps) {
    314         ALOGE("Invalid video frame rate: %d", frames_per_second);
    315         return BAD_VALUE;
    316     }
    317 
    318     // Additional check on the frame rate will be performed later
    319     mFrameRate = frames_per_second;
    320 
    321     return OK;
    322 }
    323 
    324 status_t StagefrightRecorder::setCamera(const sp<hardware::ICamera> &camera,
    325                                         const sp<ICameraRecordingProxy> &proxy) {
    326     ALOGV("setCamera");
    327     if (camera == 0) {
    328         ALOGE("camera is NULL");
    329         return BAD_VALUE;
    330     }
    331     if (proxy == 0) {
    332         ALOGE("camera proxy is NULL");
    333         return BAD_VALUE;
    334     }
    335 
    336     mCamera = camera;
    337     mCameraProxy = proxy;
    338     return OK;
    339 }
    340 
    341 status_t StagefrightRecorder::setPreviewSurface(const sp<IGraphicBufferProducer> &surface) {
    342     ALOGV("setPreviewSurface: %p", surface.get());
    343     mPreviewSurface = surface;
    344 
    345     return OK;
    346 }
    347 
    348 status_t StagefrightRecorder::setInputSurface(
    349         const sp<PersistentSurface>& surface) {
    350     mPersistentSurface = surface;
    351 
    352     return OK;
    353 }
    354 
    355 status_t StagefrightRecorder::setOutputFile(int fd) {
    356     ALOGV("setOutputFile: %d", fd);
    357 
    358     if (fd < 0) {
    359         ALOGE("Invalid file descriptor: %d", fd);
    360         return -EBADF;
    361     }
    362 
    363     // start with a clean, empty file
    364     ftruncate(fd, 0);
    365 
    366     if (mOutputFd >= 0) {
    367         ::close(mOutputFd);
    368     }
    369     mOutputFd = dup(fd);
    370 
    371     return OK;
    372 }
    373 
    374 status_t StagefrightRecorder::setNextOutputFile(int fd) {
    375     Mutex::Autolock autolock(mLock);
    376     // Only support MPEG4
    377     if (mOutputFormat != OUTPUT_FORMAT_MPEG_4) {
    378         ALOGE("Only MP4 file format supports setting next output file");
    379         return INVALID_OPERATION;
    380     }
    381     ALOGV("setNextOutputFile: %d", fd);
    382 
    383     if (fd < 0) {
    384         ALOGE("Invalid file descriptor: %d", fd);
    385         return -EBADF;
    386     }
    387 
    388     // start with a clean, empty file
    389     ftruncate(fd, 0);
    390     int nextFd = dup(fd);
    391     if (mWriter == NULL) {
    392         ALOGE("setNextOutputFile failed. Writer has been freed");
    393         return INVALID_OPERATION;
    394     }
    395     return mWriter->setNextFd(nextFd);
    396 }
    397 
    398 // Attempt to parse an float literal optionally surrounded by whitespace,
    399 // returns true on success, false otherwise.
    400 static bool safe_strtod(const char *s, double *val) {
    401     char *end;
    402 
    403     // It is lame, but according to man page, we have to set errno to 0
    404     // before calling strtod().
    405     errno = 0;
    406     *val = strtod(s, &end);
    407 
    408     if (end == s || errno == ERANGE) {
    409         return false;
    410     }
    411 
    412     // Skip trailing whitespace
    413     while (isspace(*end)) {
    414         ++end;
    415     }
    416 
    417     // For a successful return, the string must contain nothing but a valid
    418     // float literal optionally surrounded by whitespace.
    419 
    420     return *end == '\0';
    421 }
    422 
    423 // Attempt to parse an int64 literal optionally surrounded by whitespace,
    424 // returns true on success, false otherwise.
    425 static bool safe_strtoi64(const char *s, int64_t *val) {
    426     char *end;
    427 
    428     // It is lame, but according to man page, we have to set errno to 0
    429     // before calling strtoll().
    430     errno = 0;
    431     *val = strtoll(s, &end, 10);
    432 
    433     if (end == s || errno == ERANGE) {
    434         return false;
    435     }
    436 
    437     // Skip trailing whitespace
    438     while (isspace(*end)) {
    439         ++end;
    440     }
    441 
    442     // For a successful return, the string must contain nothing but a valid
    443     // int64 literal optionally surrounded by whitespace.
    444 
    445     return *end == '\0';
    446 }
    447 
    448 // Return true if the value is in [0, 0x007FFFFFFF]
    449 static bool safe_strtoi32(const char *s, int32_t *val) {
    450     int64_t temp;
    451     if (safe_strtoi64(s, &temp)) {
    452         if (temp >= 0 && temp <= 0x007FFFFFFF) {
    453             *val = static_cast<int32_t>(temp);
    454             return true;
    455         }
    456     }
    457     return false;
    458 }
    459 
    460 // Trim both leading and trailing whitespace from the given string.
    461 static void TrimString(String8 *s) {
    462     size_t num_bytes = s->bytes();
    463     const char *data = s->string();
    464 
    465     size_t leading_space = 0;
    466     while (leading_space < num_bytes && isspace(data[leading_space])) {
    467         ++leading_space;
    468     }
    469 
    470     size_t i = num_bytes;
    471     while (i > leading_space && isspace(data[i - 1])) {
    472         --i;
    473     }
    474 
    475     s->setTo(String8(&data[leading_space], i - leading_space));
    476 }
    477 
    478 status_t StagefrightRecorder::setParamAudioSamplingRate(int32_t sampleRate) {
    479     ALOGV("setParamAudioSamplingRate: %d", sampleRate);
    480     if (sampleRate <= 0) {
    481         ALOGE("Invalid audio sampling rate: %d", sampleRate);
    482         return BAD_VALUE;
    483     }
    484 
    485     // Additional check on the sample rate will be performed later.
    486     mSampleRate = sampleRate;
    487 
    488     return OK;
    489 }
    490 
    491 status_t StagefrightRecorder::setParamAudioNumberOfChannels(int32_t channels) {
    492     ALOGV("setParamAudioNumberOfChannels: %d", channels);
    493     if (channels <= 0 || channels >= 3) {
    494         ALOGE("Invalid number of audio channels: %d", channels);
    495         return BAD_VALUE;
    496     }
    497 
    498     // Additional check on the number of channels will be performed later.
    499     mAudioChannels = channels;
    500 
    501     return OK;
    502 }
    503 
    504 status_t StagefrightRecorder::setParamAudioEncodingBitRate(int32_t bitRate) {
    505     ALOGV("setParamAudioEncodingBitRate: %d", bitRate);
    506     if (bitRate <= 0) {
    507         ALOGE("Invalid audio encoding bit rate: %d", bitRate);
    508         return BAD_VALUE;
    509     }
    510 
    511     // The target bit rate may not be exactly the same as the requested.
    512     // It depends on many factors, such as rate control, and the bit rate
    513     // range that a specific encoder supports. The mismatch between the
    514     // the target and requested bit rate will NOT be treated as an error.
    515     mAudioBitRate = bitRate;
    516     return OK;
    517 }
    518 
    519 status_t StagefrightRecorder::setParamVideoEncodingBitRate(int32_t bitRate) {
    520     ALOGV("setParamVideoEncodingBitRate: %d", bitRate);
    521     if (bitRate <= 0) {
    522         ALOGE("Invalid video encoding bit rate: %d", bitRate);
    523         return BAD_VALUE;
    524     }
    525 
    526     // The target bit rate may not be exactly the same as the requested.
    527     // It depends on many factors, such as rate control, and the bit rate
    528     // range that a specific encoder supports. The mismatch between the
    529     // the target and requested bit rate will NOT be treated as an error.
    530     mVideoBitRate = bitRate;
    531     return OK;
    532 }
    533 
    534 // Always rotate clockwise, and only support 0, 90, 180 and 270 for now.
    535 status_t StagefrightRecorder::setParamVideoRotation(int32_t degrees) {
    536     ALOGV("setParamVideoRotation: %d", degrees);
    537     if (degrees < 0 || degrees % 90 != 0) {
    538         ALOGE("Unsupported video rotation angle: %d", degrees);
    539         return BAD_VALUE;
    540     }
    541     mRotationDegrees = degrees % 360;
    542     return OK;
    543 }
    544 
    545 status_t StagefrightRecorder::setParamMaxFileDurationUs(int64_t timeUs) {
    546     ALOGV("setParamMaxFileDurationUs: %lld us", (long long)timeUs);
    547 
    548     // This is meant for backward compatibility for MediaRecorder.java
    549     if (timeUs <= 0) {
    550         ALOGW("Max file duration is not positive: %lld us. Disabling duration limit.",
    551                 (long long)timeUs);
    552         timeUs = 0; // Disable the duration limit for zero or negative values.
    553     } else if (timeUs <= 100000LL) {  // XXX: 100 milli-seconds
    554         ALOGE("Max file duration is too short: %lld us", (long long)timeUs);
    555         return BAD_VALUE;
    556     }
    557 
    558     if (timeUs <= 15 * 1000000LL) {
    559         ALOGW("Target duration (%lld us) too short to be respected", (long long)timeUs);
    560     }
    561     mMaxFileDurationUs = timeUs;
    562     return OK;
    563 }
    564 
    565 status_t StagefrightRecorder::setParamMaxFileSizeBytes(int64_t bytes) {
    566     ALOGV("setParamMaxFileSizeBytes: %lld bytes", (long long)bytes);
    567 
    568     // This is meant for backward compatibility for MediaRecorder.java
    569     if (bytes <= 0) {
    570         ALOGW("Max file size is not positive: %lld bytes. "
    571              "Disabling file size limit.", (long long)bytes);
    572         bytes = 0; // Disable the file size limit for zero or negative values.
    573     } else if (bytes <= 1024) {  // XXX: 1 kB
    574         ALOGE("Max file size is too small: %lld bytes", (long long)bytes);
    575         return BAD_VALUE;
    576     }
    577 
    578     if (bytes <= 100 * 1024) {
    579         ALOGW("Target file size (%lld bytes) is too small to be respected", (long long)bytes);
    580     }
    581 
    582     mMaxFileSizeBytes = bytes;
    583     return OK;
    584 }
    585 
    586 status_t StagefrightRecorder::setParamInterleaveDuration(int32_t durationUs) {
    587     ALOGV("setParamInterleaveDuration: %d", durationUs);
    588     if (durationUs <= 500000) {           //  500 ms
    589         // If interleave duration is too small, it is very inefficient to do
    590         // interleaving since the metadata overhead will count for a significant
    591         // portion of the saved contents
    592         ALOGE("Audio/video interleave duration is too small: %d us", durationUs);
    593         return BAD_VALUE;
    594     } else if (durationUs >= 10000000) {  // 10 seconds
    595         // If interleaving duration is too large, it can cause the recording
    596         // session to use too much memory since we have to save the output
    597         // data before we write them out
    598         ALOGE("Audio/video interleave duration is too large: %d us", durationUs);
    599         return BAD_VALUE;
    600     }
    601     mInterleaveDurationUs = durationUs;
    602     return OK;
    603 }
    604 
    605 // If seconds <  0, only the first frame is I frame, and rest are all P frames
    606 // If seconds == 0, all frames are encoded as I frames. No P frames
    607 // If seconds >  0, it is the time spacing (seconds) between 2 neighboring I frames
    608 status_t StagefrightRecorder::setParamVideoIFramesInterval(int32_t seconds) {
    609     ALOGV("setParamVideoIFramesInterval: %d seconds", seconds);
    610     mIFramesIntervalSec = seconds;
    611     return OK;
    612 }
    613 
    614 status_t StagefrightRecorder::setParam64BitFileOffset(bool use64Bit) {
    615     ALOGV("setParam64BitFileOffset: %s",
    616         use64Bit? "use 64 bit file offset": "use 32 bit file offset");
    617     mUse64BitFileOffset = use64Bit;
    618     return OK;
    619 }
    620 
    621 status_t StagefrightRecorder::setParamVideoCameraId(int32_t cameraId) {
    622     ALOGV("setParamVideoCameraId: %d", cameraId);
    623     if (cameraId < 0) {
    624         return BAD_VALUE;
    625     }
    626     mCameraId = cameraId;
    627     return OK;
    628 }
    629 
    630 status_t StagefrightRecorder::setParamTrackTimeStatus(int64_t timeDurationUs) {
    631     ALOGV("setParamTrackTimeStatus: %lld", (long long)timeDurationUs);
    632     if (timeDurationUs < 20000) {  // Infeasible if shorter than 20 ms?
    633         ALOGE("Tracking time duration too short: %lld us", (long long)timeDurationUs);
    634         return BAD_VALUE;
    635     }
    636     mTrackEveryTimeDurationUs = timeDurationUs;
    637     return OK;
    638 }
    639 
    640 status_t StagefrightRecorder::setParamVideoEncoderProfile(int32_t profile) {
    641     ALOGV("setParamVideoEncoderProfile: %d", profile);
    642 
    643     // Additional check will be done later when we load the encoder.
    644     // For now, we are accepting values defined in OpenMAX IL.
    645     mVideoEncoderProfile = profile;
    646     return OK;
    647 }
    648 
    649 status_t StagefrightRecorder::setParamVideoEncoderLevel(int32_t level) {
    650     ALOGV("setParamVideoEncoderLevel: %d", level);
    651 
    652     // Additional check will be done later when we load the encoder.
    653     // For now, we are accepting values defined in OpenMAX IL.
    654     mVideoEncoderLevel = level;
    655     return OK;
    656 }
    657 
    658 status_t StagefrightRecorder::setParamMovieTimeScale(int32_t timeScale) {
    659     ALOGV("setParamMovieTimeScale: %d", timeScale);
    660 
    661     // The range is set to be the same as the audio's time scale range
    662     // since audio's time scale has a wider range.
    663     if (timeScale < 600 || timeScale > 96000) {
    664         ALOGE("Time scale (%d) for movie is out of range [600, 96000]", timeScale);
    665         return BAD_VALUE;
    666     }
    667     mMovieTimeScale = timeScale;
    668     return OK;
    669 }
    670 
    671 status_t StagefrightRecorder::setParamVideoTimeScale(int32_t timeScale) {
    672     ALOGV("setParamVideoTimeScale: %d", timeScale);
    673 
    674     // 60000 is chosen to make sure that each video frame from a 60-fps
    675     // video has 1000 ticks.
    676     if (timeScale < 600 || timeScale > 60000) {
    677         ALOGE("Time scale (%d) for video is out of range [600, 60000]", timeScale);
    678         return BAD_VALUE;
    679     }
    680     mVideoTimeScale = timeScale;
    681     return OK;
    682 }
    683 
    684 status_t StagefrightRecorder::setParamAudioTimeScale(int32_t timeScale) {
    685     ALOGV("setParamAudioTimeScale: %d", timeScale);
    686 
    687     // 96000 Hz is the highest sampling rate support in AAC.
    688     if (timeScale < 600 || timeScale > 96000) {
    689         ALOGE("Time scale (%d) for audio is out of range [600, 96000]", timeScale);
    690         return BAD_VALUE;
    691     }
    692     mAudioTimeScale = timeScale;
    693     return OK;
    694 }
    695 
    696 status_t StagefrightRecorder::setParamCaptureFpsEnable(int32_t captureFpsEnable) {
    697     ALOGV("setParamCaptureFpsEnable: %d", captureFpsEnable);
    698 
    699     if(captureFpsEnable == 0) {
    700         mCaptureFpsEnable = false;
    701     } else if (captureFpsEnable == 1) {
    702         mCaptureFpsEnable = true;
    703     } else {
    704         return BAD_VALUE;
    705     }
    706     return OK;
    707 }
    708 
    709 status_t StagefrightRecorder::setParamCaptureFps(double fps) {
    710     ALOGV("setParamCaptureFps: %.2f", fps);
    711 
    712     if (!(fps >= 1.0 / 86400)) {
    713         ALOGE("FPS is too small");
    714         return BAD_VALUE;
    715     }
    716     mCaptureFps = fps;
    717     return OK;
    718 }
    719 
    720 status_t StagefrightRecorder::setParamGeoDataLongitude(
    721     int64_t longitudex10000) {
    722 
    723     if (longitudex10000 > 1800000 || longitudex10000 < -1800000) {
    724         return BAD_VALUE;
    725     }
    726     mLongitudex10000 = longitudex10000;
    727     return OK;
    728 }
    729 
    730 status_t StagefrightRecorder::setParamGeoDataLatitude(
    731     int64_t latitudex10000) {
    732 
    733     if (latitudex10000 > 900000 || latitudex10000 < -900000) {
    734         return BAD_VALUE;
    735     }
    736     mLatitudex10000 = latitudex10000;
    737     return OK;
    738 }
    739 
    740 status_t StagefrightRecorder::setParameter(
    741         const String8 &key, const String8 &value) {
    742     ALOGV("setParameter: key (%s) => value (%s)", key.string(), value.string());
    743     if (key == "max-duration") {
    744         int64_t max_duration_ms;
    745         if (safe_strtoi64(value.string(), &max_duration_ms)) {
    746             return setParamMaxFileDurationUs(1000LL * max_duration_ms);
    747         }
    748     } else if (key == "max-filesize") {
    749         int64_t max_filesize_bytes;
    750         if (safe_strtoi64(value.string(), &max_filesize_bytes)) {
    751             return setParamMaxFileSizeBytes(max_filesize_bytes);
    752         }
    753     } else if (key == "interleave-duration-us") {
    754         int32_t durationUs;
    755         if (safe_strtoi32(value.string(), &durationUs)) {
    756             return setParamInterleaveDuration(durationUs);
    757         }
    758     } else if (key == "param-movie-time-scale") {
    759         int32_t timeScale;
    760         if (safe_strtoi32(value.string(), &timeScale)) {
    761             return setParamMovieTimeScale(timeScale);
    762         }
    763     } else if (key == "param-use-64bit-offset") {
    764         int32_t use64BitOffset;
    765         if (safe_strtoi32(value.string(), &use64BitOffset)) {
    766             return setParam64BitFileOffset(use64BitOffset != 0);
    767         }
    768     } else if (key == "param-geotag-longitude") {
    769         int64_t longitudex10000;
    770         if (safe_strtoi64(value.string(), &longitudex10000)) {
    771             return setParamGeoDataLongitude(longitudex10000);
    772         }
    773     } else if (key == "param-geotag-latitude") {
    774         int64_t latitudex10000;
    775         if (safe_strtoi64(value.string(), &latitudex10000)) {
    776             return setParamGeoDataLatitude(latitudex10000);
    777         }
    778     } else if (key == "param-track-time-status") {
    779         int64_t timeDurationUs;
    780         if (safe_strtoi64(value.string(), &timeDurationUs)) {
    781             return setParamTrackTimeStatus(timeDurationUs);
    782         }
    783     } else if (key == "audio-param-sampling-rate") {
    784         int32_t sampling_rate;
    785         if (safe_strtoi32(value.string(), &sampling_rate)) {
    786             return setParamAudioSamplingRate(sampling_rate);
    787         }
    788     } else if (key == "audio-param-number-of-channels") {
    789         int32_t number_of_channels;
    790         if (safe_strtoi32(value.string(), &number_of_channels)) {
    791             return setParamAudioNumberOfChannels(number_of_channels);
    792         }
    793     } else if (key == "audio-param-encoding-bitrate") {
    794         int32_t audio_bitrate;
    795         if (safe_strtoi32(value.string(), &audio_bitrate)) {
    796             return setParamAudioEncodingBitRate(audio_bitrate);
    797         }
    798     } else if (key == "audio-param-time-scale") {
    799         int32_t timeScale;
    800         if (safe_strtoi32(value.string(), &timeScale)) {
    801             return setParamAudioTimeScale(timeScale);
    802         }
    803     } else if (key == "video-param-encoding-bitrate") {
    804         int32_t video_bitrate;
    805         if (safe_strtoi32(value.string(), &video_bitrate)) {
    806             return setParamVideoEncodingBitRate(video_bitrate);
    807         }
    808     } else if (key == "video-param-rotation-angle-degrees") {
    809         int32_t degrees;
    810         if (safe_strtoi32(value.string(), &degrees)) {
    811             return setParamVideoRotation(degrees);
    812         }
    813     } else if (key == "video-param-i-frames-interval") {
    814         int32_t seconds;
    815         if (safe_strtoi32(value.string(), &seconds)) {
    816             return setParamVideoIFramesInterval(seconds);
    817         }
    818     } else if (key == "video-param-encoder-profile") {
    819         int32_t profile;
    820         if (safe_strtoi32(value.string(), &profile)) {
    821             return setParamVideoEncoderProfile(profile);
    822         }
    823     } else if (key == "video-param-encoder-level") {
    824         int32_t level;
    825         if (safe_strtoi32(value.string(), &level)) {
    826             return setParamVideoEncoderLevel(level);
    827         }
    828     } else if (key == "video-param-camera-id") {
    829         int32_t cameraId;
    830         if (safe_strtoi32(value.string(), &cameraId)) {
    831             return setParamVideoCameraId(cameraId);
    832         }
    833     } else if (key == "video-param-time-scale") {
    834         int32_t timeScale;
    835         if (safe_strtoi32(value.string(), &timeScale)) {
    836             return setParamVideoTimeScale(timeScale);
    837         }
    838     } else if (key == "time-lapse-enable") {
    839         int32_t captureFpsEnable;
    840         if (safe_strtoi32(value.string(), &captureFpsEnable)) {
    841             return setParamCaptureFpsEnable(captureFpsEnable);
    842         }
    843     } else if (key == "time-lapse-fps") {
    844         double fps;
    845         if (safe_strtod(value.string(), &fps)) {
    846             return setParamCaptureFps(fps);
    847         }
    848     } else {
    849         ALOGE("setParameter: failed to find key %s", key.string());
    850     }
    851     return BAD_VALUE;
    852 }
    853 
    854 status_t StagefrightRecorder::setParameters(const String8 &params) {
    855     ALOGV("setParameters: %s", params.string());
    856     const char *cparams = params.string();
    857     const char *key_start = cparams;
    858     for (;;) {
    859         const char *equal_pos = strchr(key_start, '=');
    860         if (equal_pos == NULL) {
    861             ALOGE("Parameters %s miss a value", cparams);
    862             return BAD_VALUE;
    863         }
    864         String8 key(key_start, equal_pos - key_start);
    865         TrimString(&key);
    866         if (key.length() == 0) {
    867             ALOGE("Parameters %s contains an empty key", cparams);
    868             return BAD_VALUE;
    869         }
    870         const char *value_start = equal_pos + 1;
    871         const char *semicolon_pos = strchr(value_start, ';');
    872         String8 value;
    873         if (semicolon_pos == NULL) {
    874             value.setTo(value_start);
    875         } else {
    876             value.setTo(value_start, semicolon_pos - value_start);
    877         }
    878         if (setParameter(key, value) != OK) {
    879             return BAD_VALUE;
    880         }
    881         if (semicolon_pos == NULL) {
    882             break;  // Reaches the end
    883         }
    884         key_start = semicolon_pos + 1;
    885     }
    886     return OK;
    887 }
    888 
    889 status_t StagefrightRecorder::setListener(const sp<IMediaRecorderClient> &listener) {
    890     mListener = listener;
    891 
    892     return OK;
    893 }
    894 
    895 status_t StagefrightRecorder::setClientName(const String16& clientName) {
    896     mClientName = clientName;
    897 
    898     return OK;
    899 }
    900 
    901 status_t StagefrightRecorder::prepareInternal() {
    902     ALOGV("prepare");
    903     if (mOutputFd < 0) {
    904         ALOGE("Output file descriptor is invalid");
    905         return INVALID_OPERATION;
    906     }
    907 
    908     // Get UID and PID here for permission checking
    909     mClientUid = IPCThreadState::self()->getCallingUid();
    910     mClientPid = IPCThreadState::self()->getCallingPid();
    911 
    912     status_t status = OK;
    913 
    914     switch (mOutputFormat) {
    915         case OUTPUT_FORMAT_DEFAULT:
    916         case OUTPUT_FORMAT_THREE_GPP:
    917         case OUTPUT_FORMAT_MPEG_4:
    918         case OUTPUT_FORMAT_WEBM:
    919             status = setupMPEG4orWEBMRecording();
    920             break;
    921 
    922         case OUTPUT_FORMAT_AMR_NB:
    923         case OUTPUT_FORMAT_AMR_WB:
    924             status = setupAMRRecording();
    925             break;
    926 
    927         case OUTPUT_FORMAT_AAC_ADIF:
    928         case OUTPUT_FORMAT_AAC_ADTS:
    929             status = setupAACRecording();
    930             break;
    931 
    932         case OUTPUT_FORMAT_RTP_AVP:
    933             status = setupRTPRecording();
    934             break;
    935 
    936         case OUTPUT_FORMAT_MPEG2TS:
    937             status = setupMPEG2TSRecording();
    938             break;
    939 
    940         default:
    941             ALOGE("Unsupported output file format: %d", mOutputFormat);
    942             status = UNKNOWN_ERROR;
    943             break;
    944     }
    945 
    946     ALOGV("Recording frameRate: %d captureFps: %f",
    947             mFrameRate, mCaptureFps);
    948 
    949     return status;
    950 }
    951 
    952 status_t StagefrightRecorder::prepare() {
    953     ALOGV("prepare");
    954     Mutex::Autolock autolock(mLock);
    955     if (mVideoSource == VIDEO_SOURCE_SURFACE) {
    956         return prepareInternal();
    957     }
    958     return OK;
    959 }
    960 
    961 status_t StagefrightRecorder::start() {
    962     ALOGV("start");
    963     Mutex::Autolock autolock(mLock);
    964     if (mOutputFd < 0) {
    965         ALOGE("Output file descriptor is invalid");
    966         return INVALID_OPERATION;
    967     }
    968 
    969     status_t status = OK;
    970 
    971     if (mVideoSource != VIDEO_SOURCE_SURFACE) {
    972         status = prepareInternal();
    973         if (status != OK) {
    974             return status;
    975         }
    976     }
    977 
    978     if (mWriter == NULL) {
    979         ALOGE("File writer is not avaialble");
    980         return UNKNOWN_ERROR;
    981     }
    982 
    983     switch (mOutputFormat) {
    984         case OUTPUT_FORMAT_DEFAULT:
    985         case OUTPUT_FORMAT_THREE_GPP:
    986         case OUTPUT_FORMAT_MPEG_4:
    987         case OUTPUT_FORMAT_WEBM:
    988         {
    989             bool isMPEG4 = true;
    990             if (mOutputFormat == OUTPUT_FORMAT_WEBM) {
    991                 isMPEG4 = false;
    992             }
    993             sp<MetaData> meta = new MetaData;
    994             setupMPEG4orWEBMMetaData(&meta);
    995             status = mWriter->start(meta.get());
    996             break;
    997         }
    998 
    999         case OUTPUT_FORMAT_AMR_NB:
   1000         case OUTPUT_FORMAT_AMR_WB:
   1001         case OUTPUT_FORMAT_AAC_ADIF:
   1002         case OUTPUT_FORMAT_AAC_ADTS:
   1003         case OUTPUT_FORMAT_RTP_AVP:
   1004         case OUTPUT_FORMAT_MPEG2TS:
   1005         {
   1006             sp<MetaData> meta = new MetaData;
   1007             int64_t startTimeUs = systemTime() / 1000;
   1008             meta->setInt64(kKeyTime, startTimeUs);
   1009             status = mWriter->start(meta.get());
   1010             break;
   1011         }
   1012 
   1013         default:
   1014         {
   1015             ALOGE("Unsupported output file format: %d", mOutputFormat);
   1016             status = UNKNOWN_ERROR;
   1017             break;
   1018         }
   1019     }
   1020 
   1021     if (status != OK) {
   1022         mWriter.clear();
   1023         mWriter = NULL;
   1024     }
   1025 
   1026     if ((status == OK) && (!mStarted)) {
   1027         mAnalyticsDirty = true;
   1028         mStarted = true;
   1029 
   1030         uint32_t params = IMediaPlayerService::kBatteryDataCodecStarted;
   1031         if (mAudioSource != AUDIO_SOURCE_CNT) {
   1032             params |= IMediaPlayerService::kBatteryDataTrackAudio;
   1033         }
   1034         if (mVideoSource != VIDEO_SOURCE_LIST_END) {
   1035             params |= IMediaPlayerService::kBatteryDataTrackVideo;
   1036         }
   1037 
   1038         addBatteryData(params);
   1039     }
   1040 
   1041     return status;
   1042 }
   1043 
   1044 sp<MediaCodecSource> StagefrightRecorder::createAudioSource() {
   1045     int32_t sourceSampleRate = mSampleRate;
   1046 
   1047     if (mCaptureFpsEnable && mCaptureFps >= mFrameRate) {
   1048         // Upscale the sample rate for slow motion recording.
   1049         // Fail audio source creation if source sample rate is too high, as it could
   1050         // cause out-of-memory due to large input buffer size. And audio recording
   1051         // probably doesn't make sense in the scenario, since the slow-down factor
   1052         // is probably huge (eg. mSampleRate=48K, mCaptureFps=240, mFrameRate=1).
   1053         const static int32_t SAMPLE_RATE_HZ_MAX = 192000;
   1054         sourceSampleRate =
   1055                 (mSampleRate * mCaptureFps + mFrameRate / 2) / mFrameRate;
   1056         if (sourceSampleRate < mSampleRate || sourceSampleRate > SAMPLE_RATE_HZ_MAX) {
   1057             ALOGE("source sample rate out of range! "
   1058                     "(mSampleRate %d, mCaptureFps %.2f, mFrameRate %d",
   1059                     mSampleRate, mCaptureFps, mFrameRate);
   1060             return NULL;
   1061         }
   1062     }
   1063 
   1064     sp<AudioSource> audioSource =
   1065         new AudioSource(
   1066                 mAudioSource,
   1067                 mOpPackageName,
   1068                 sourceSampleRate,
   1069                 mAudioChannels,
   1070                 mSampleRate,
   1071                 mClientUid,
   1072                 mClientPid);
   1073 
   1074     status_t err = audioSource->initCheck();
   1075 
   1076     if (err != OK) {
   1077         ALOGE("audio source is not initialized");
   1078         return NULL;
   1079     }
   1080 
   1081     sp<AMessage> format = new AMessage;
   1082     switch (mAudioEncoder) {
   1083         case AUDIO_ENCODER_AMR_NB:
   1084         case AUDIO_ENCODER_DEFAULT:
   1085             format->setString("mime", MEDIA_MIMETYPE_AUDIO_AMR_NB);
   1086             break;
   1087         case AUDIO_ENCODER_AMR_WB:
   1088             format->setString("mime", MEDIA_MIMETYPE_AUDIO_AMR_WB);
   1089             break;
   1090         case AUDIO_ENCODER_AAC:
   1091             format->setString("mime", MEDIA_MIMETYPE_AUDIO_AAC);
   1092             format->setInt32("aac-profile", OMX_AUDIO_AACObjectLC);
   1093             break;
   1094         case AUDIO_ENCODER_HE_AAC:
   1095             format->setString("mime", MEDIA_MIMETYPE_AUDIO_AAC);
   1096             format->setInt32("aac-profile", OMX_AUDIO_AACObjectHE);
   1097             break;
   1098         case AUDIO_ENCODER_AAC_ELD:
   1099             format->setString("mime", MEDIA_MIMETYPE_AUDIO_AAC);
   1100             format->setInt32("aac-profile", OMX_AUDIO_AACObjectELD);
   1101             break;
   1102 
   1103         default:
   1104             ALOGE("Unknown audio encoder: %d", mAudioEncoder);
   1105             return NULL;
   1106     }
   1107 
   1108     int32_t maxInputSize;
   1109     CHECK(audioSource->getFormat()->findInt32(
   1110                 kKeyMaxInputSize, &maxInputSize));
   1111 
   1112     format->setInt32("max-input-size", maxInputSize);
   1113     format->setInt32("channel-count", mAudioChannels);
   1114     format->setInt32("sample-rate", mSampleRate);
   1115     format->setInt32("bitrate", mAudioBitRate);
   1116     if (mAudioTimeScale > 0) {
   1117         format->setInt32("time-scale", mAudioTimeScale);
   1118     }
   1119     format->setInt32("priority", 0 /* realtime */);
   1120 
   1121     sp<MediaCodecSource> audioEncoder =
   1122             MediaCodecSource::Create(mLooper, format, audioSource);
   1123     mAudioSourceNode = audioSource;
   1124 
   1125     if (audioEncoder == NULL) {
   1126         ALOGE("Failed to create audio encoder");
   1127     }
   1128 
   1129     return audioEncoder;
   1130 }
   1131 
   1132 status_t StagefrightRecorder::setupAACRecording() {
   1133     // FIXME:
   1134     // Add support for OUTPUT_FORMAT_AAC_ADIF
   1135     CHECK_EQ(mOutputFormat, OUTPUT_FORMAT_AAC_ADTS);
   1136 
   1137     CHECK(mAudioEncoder == AUDIO_ENCODER_AAC ||
   1138           mAudioEncoder == AUDIO_ENCODER_HE_AAC ||
   1139           mAudioEncoder == AUDIO_ENCODER_AAC_ELD);
   1140     CHECK(mAudioSource != AUDIO_SOURCE_CNT);
   1141 
   1142     mWriter = new AACWriter(mOutputFd);
   1143     return setupRawAudioRecording();
   1144 }
   1145 
   1146 status_t StagefrightRecorder::setupAMRRecording() {
   1147     CHECK(mOutputFormat == OUTPUT_FORMAT_AMR_NB ||
   1148           mOutputFormat == OUTPUT_FORMAT_AMR_WB);
   1149 
   1150     if (mOutputFormat == OUTPUT_FORMAT_AMR_NB) {
   1151         if (mAudioEncoder != AUDIO_ENCODER_DEFAULT &&
   1152             mAudioEncoder != AUDIO_ENCODER_AMR_NB) {
   1153             ALOGE("Invalid encoder %d used for AMRNB recording",
   1154                     mAudioEncoder);
   1155             return BAD_VALUE;
   1156         }
   1157     } else {  // mOutputFormat must be OUTPUT_FORMAT_AMR_WB
   1158         if (mAudioEncoder != AUDIO_ENCODER_AMR_WB) {
   1159             ALOGE("Invlaid encoder %d used for AMRWB recording",
   1160                     mAudioEncoder);
   1161             return BAD_VALUE;
   1162         }
   1163     }
   1164 
   1165     mWriter = new AMRWriter(mOutputFd);
   1166     return setupRawAudioRecording();
   1167 }
   1168 
   1169 status_t StagefrightRecorder::setupRawAudioRecording() {
   1170     if (mAudioSource >= AUDIO_SOURCE_CNT && mAudioSource != AUDIO_SOURCE_FM_TUNER) {
   1171         ALOGE("Invalid audio source: %d", mAudioSource);
   1172         return BAD_VALUE;
   1173     }
   1174 
   1175     status_t status = BAD_VALUE;
   1176     if (OK != (status = checkAudioEncoderCapabilities())) {
   1177         return status;
   1178     }
   1179 
   1180     sp<MediaCodecSource> audioEncoder = createAudioSource();
   1181     if (audioEncoder == NULL) {
   1182         return UNKNOWN_ERROR;
   1183     }
   1184 
   1185     CHECK(mWriter != 0);
   1186     mWriter->addSource(audioEncoder);
   1187     mAudioEncoderSource = audioEncoder;
   1188 
   1189     if (mMaxFileDurationUs != 0) {
   1190         mWriter->setMaxFileDuration(mMaxFileDurationUs);
   1191     }
   1192     if (mMaxFileSizeBytes != 0) {
   1193         mWriter->setMaxFileSize(mMaxFileSizeBytes);
   1194     }
   1195     mWriter->setListener(mListener);
   1196 
   1197     return OK;
   1198 }
   1199 
   1200 status_t StagefrightRecorder::setupRTPRecording() {
   1201     CHECK_EQ(mOutputFormat, OUTPUT_FORMAT_RTP_AVP);
   1202 
   1203     if ((mAudioSource != AUDIO_SOURCE_CNT
   1204                 && mVideoSource != VIDEO_SOURCE_LIST_END)
   1205             || (mAudioSource == AUDIO_SOURCE_CNT
   1206                 && mVideoSource == VIDEO_SOURCE_LIST_END)) {
   1207         // Must have exactly one source.
   1208         return BAD_VALUE;
   1209     }
   1210 
   1211     if (mOutputFd < 0) {
   1212         return BAD_VALUE;
   1213     }
   1214 
   1215     sp<MediaCodecSource> source;
   1216 
   1217     if (mAudioSource != AUDIO_SOURCE_CNT) {
   1218         source = createAudioSource();
   1219         mAudioEncoderSource = source;
   1220     } else {
   1221         setDefaultVideoEncoderIfNecessary();
   1222 
   1223         sp<MediaSource> mediaSource;
   1224         status_t err = setupMediaSource(&mediaSource);
   1225         if (err != OK) {
   1226             return err;
   1227         }
   1228 
   1229         err = setupVideoEncoder(mediaSource, &source);
   1230         if (err != OK) {
   1231             return err;
   1232         }
   1233         mVideoEncoderSource = source;
   1234     }
   1235 
   1236     mWriter = new ARTPWriter(mOutputFd);
   1237     mWriter->addSource(source);
   1238     mWriter->setListener(mListener);
   1239 
   1240     return OK;
   1241 }
   1242 
   1243 status_t StagefrightRecorder::setupMPEG2TSRecording() {
   1244     CHECK_EQ(mOutputFormat, OUTPUT_FORMAT_MPEG2TS);
   1245 
   1246     sp<MediaWriter> writer = new MPEG2TSWriter(mOutputFd);
   1247 
   1248     if (mAudioSource != AUDIO_SOURCE_CNT) {
   1249         if (mAudioEncoder != AUDIO_ENCODER_AAC &&
   1250             mAudioEncoder != AUDIO_ENCODER_HE_AAC &&
   1251             mAudioEncoder != AUDIO_ENCODER_AAC_ELD) {
   1252             return ERROR_UNSUPPORTED;
   1253         }
   1254 
   1255         status_t err = setupAudioEncoder(writer);
   1256 
   1257         if (err != OK) {
   1258             return err;
   1259         }
   1260     }
   1261 
   1262     if (mVideoSource < VIDEO_SOURCE_LIST_END) {
   1263         if (mVideoEncoder != VIDEO_ENCODER_H264) {
   1264             ALOGE("MPEG2TS recording only supports H.264 encoding!");
   1265             return ERROR_UNSUPPORTED;
   1266         }
   1267 
   1268         sp<MediaSource> mediaSource;
   1269         status_t err = setupMediaSource(&mediaSource);
   1270         if (err != OK) {
   1271             return err;
   1272         }
   1273 
   1274         sp<MediaCodecSource> encoder;
   1275         err = setupVideoEncoder(mediaSource, &encoder);
   1276 
   1277         if (err != OK) {
   1278             return err;
   1279         }
   1280 
   1281         writer->addSource(encoder);
   1282         mVideoEncoderSource = encoder;
   1283     }
   1284 
   1285     if (mMaxFileDurationUs != 0) {
   1286         writer->setMaxFileDuration(mMaxFileDurationUs);
   1287     }
   1288 
   1289     if (mMaxFileSizeBytes != 0) {
   1290         writer->setMaxFileSize(mMaxFileSizeBytes);
   1291     }
   1292 
   1293     mWriter = writer;
   1294 
   1295     return OK;
   1296 }
   1297 
   1298 void StagefrightRecorder::clipVideoFrameRate() {
   1299     ALOGV("clipVideoFrameRate: encoder %d", mVideoEncoder);
   1300     if (mFrameRate == -1) {
   1301         mFrameRate = mEncoderProfiles->getCamcorderProfileParamByName(
   1302                 "vid.fps", mCameraId, CAMCORDER_QUALITY_LOW);
   1303         ALOGW("Using default video fps %d", mFrameRate);
   1304     }
   1305 
   1306     int minFrameRate = mEncoderProfiles->getVideoEncoderParamByName(
   1307                         "enc.vid.fps.min", mVideoEncoder);
   1308     int maxFrameRate = mEncoderProfiles->getVideoEncoderParamByName(
   1309                         "enc.vid.fps.max", mVideoEncoder);
   1310     if (mFrameRate < minFrameRate && minFrameRate != -1) {
   1311         ALOGW("Intended video encoding frame rate (%d fps) is too small"
   1312              " and will be set to (%d fps)", mFrameRate, minFrameRate);
   1313         mFrameRate = minFrameRate;
   1314     } else if (mFrameRate > maxFrameRate && maxFrameRate != -1) {
   1315         ALOGW("Intended video encoding frame rate (%d fps) is too large"
   1316              " and will be set to (%d fps)", mFrameRate, maxFrameRate);
   1317         mFrameRate = maxFrameRate;
   1318     }
   1319 }
   1320 
   1321 void StagefrightRecorder::clipVideoBitRate() {
   1322     ALOGV("clipVideoBitRate: encoder %d", mVideoEncoder);
   1323     int minBitRate = mEncoderProfiles->getVideoEncoderParamByName(
   1324                         "enc.vid.bps.min", mVideoEncoder);
   1325     int maxBitRate = mEncoderProfiles->getVideoEncoderParamByName(
   1326                         "enc.vid.bps.max", mVideoEncoder);
   1327     if (mVideoBitRate < minBitRate && minBitRate != -1) {
   1328         ALOGW("Intended video encoding bit rate (%d bps) is too small"
   1329              " and will be set to (%d bps)", mVideoBitRate, minBitRate);
   1330         mVideoBitRate = minBitRate;
   1331     } else if (mVideoBitRate > maxBitRate && maxBitRate != -1) {
   1332         ALOGW("Intended video encoding bit rate (%d bps) is too large"
   1333              " and will be set to (%d bps)", mVideoBitRate, maxBitRate);
   1334         mVideoBitRate = maxBitRate;
   1335     }
   1336 }
   1337 
   1338 void StagefrightRecorder::clipVideoFrameWidth() {
   1339     ALOGV("clipVideoFrameWidth: encoder %d", mVideoEncoder);
   1340     int minFrameWidth = mEncoderProfiles->getVideoEncoderParamByName(
   1341                         "enc.vid.width.min", mVideoEncoder);
   1342     int maxFrameWidth = mEncoderProfiles->getVideoEncoderParamByName(
   1343                         "enc.vid.width.max", mVideoEncoder);
   1344     if (mVideoWidth < minFrameWidth && minFrameWidth != -1) {
   1345         ALOGW("Intended video encoding frame width (%d) is too small"
   1346              " and will be set to (%d)", mVideoWidth, minFrameWidth);
   1347         mVideoWidth = minFrameWidth;
   1348     } else if (mVideoWidth > maxFrameWidth && maxFrameWidth != -1) {
   1349         ALOGW("Intended video encoding frame width (%d) is too large"
   1350              " and will be set to (%d)", mVideoWidth, maxFrameWidth);
   1351         mVideoWidth = maxFrameWidth;
   1352     }
   1353 }
   1354 
   1355 status_t StagefrightRecorder::checkVideoEncoderCapabilities() {
   1356     if (!mCaptureFpsEnable) {
   1357         // Dont clip for time lapse capture as encoder will have enough
   1358         // time to encode because of slow capture rate of time lapse.
   1359         clipVideoBitRate();
   1360         clipVideoFrameRate();
   1361         clipVideoFrameWidth();
   1362         clipVideoFrameHeight();
   1363         setDefaultProfileIfNecessary();
   1364     }
   1365     return OK;
   1366 }
   1367 
   1368 // Set to use AVC baseline profile if the encoding parameters matches
   1369 // CAMCORDER_QUALITY_LOW profile; this is for the sake of MMS service.
   1370 void StagefrightRecorder::setDefaultProfileIfNecessary() {
   1371     ALOGV("setDefaultProfileIfNecessary");
   1372 
   1373     camcorder_quality quality = CAMCORDER_QUALITY_LOW;
   1374 
   1375     int64_t durationUs   = mEncoderProfiles->getCamcorderProfileParamByName(
   1376                                 "duration", mCameraId, quality) * 1000000LL;
   1377 
   1378     int fileFormat       = mEncoderProfiles->getCamcorderProfileParamByName(
   1379                                 "file.format", mCameraId, quality);
   1380 
   1381     int videoCodec       = mEncoderProfiles->getCamcorderProfileParamByName(
   1382                                 "vid.codec", mCameraId, quality);
   1383 
   1384     int videoBitRate     = mEncoderProfiles->getCamcorderProfileParamByName(
   1385                                 "vid.bps", mCameraId, quality);
   1386 
   1387     int videoFrameRate   = mEncoderProfiles->getCamcorderProfileParamByName(
   1388                                 "vid.fps", mCameraId, quality);
   1389 
   1390     int videoFrameWidth  = mEncoderProfiles->getCamcorderProfileParamByName(
   1391                                 "vid.width", mCameraId, quality);
   1392 
   1393     int videoFrameHeight = mEncoderProfiles->getCamcorderProfileParamByName(
   1394                                 "vid.height", mCameraId, quality);
   1395 
   1396     int audioCodec       = mEncoderProfiles->getCamcorderProfileParamByName(
   1397                                 "aud.codec", mCameraId, quality);
   1398 
   1399     int audioBitRate     = mEncoderProfiles->getCamcorderProfileParamByName(
   1400                                 "aud.bps", mCameraId, quality);
   1401 
   1402     int audioSampleRate  = mEncoderProfiles->getCamcorderProfileParamByName(
   1403                                 "aud.hz", mCameraId, quality);
   1404 
   1405     int audioChannels    = mEncoderProfiles->getCamcorderProfileParamByName(
   1406                                 "aud.ch", mCameraId, quality);
   1407 
   1408     if (durationUs == mMaxFileDurationUs &&
   1409         fileFormat == mOutputFormat &&
   1410         videoCodec == mVideoEncoder &&
   1411         videoBitRate == mVideoBitRate &&
   1412         videoFrameRate == mFrameRate &&
   1413         videoFrameWidth == mVideoWidth &&
   1414         videoFrameHeight == mVideoHeight &&
   1415         audioCodec == mAudioEncoder &&
   1416         audioBitRate == mAudioBitRate &&
   1417         audioSampleRate == mSampleRate &&
   1418         audioChannels == mAudioChannels) {
   1419         if (videoCodec == VIDEO_ENCODER_H264) {
   1420             ALOGI("Force to use AVC baseline profile");
   1421             setParamVideoEncoderProfile(OMX_VIDEO_AVCProfileBaseline);
   1422             // set 0 for invalid levels - this will be rejected by the
   1423             // codec if it cannot handle it during configure
   1424             setParamVideoEncoderLevel(ACodec::getAVCLevelFor(
   1425                     videoFrameWidth, videoFrameHeight, videoFrameRate, videoBitRate));
   1426         }
   1427     }
   1428 }
   1429 
   1430 void StagefrightRecorder::setDefaultVideoEncoderIfNecessary() {
   1431     if (mVideoEncoder == VIDEO_ENCODER_DEFAULT) {
   1432         if (mOutputFormat == OUTPUT_FORMAT_WEBM) {
   1433             // default to VP8 for WEBM recording
   1434             mVideoEncoder = VIDEO_ENCODER_VP8;
   1435         } else {
   1436             // pick the default encoder for CAMCORDER_QUALITY_LOW
   1437             int videoCodec = mEncoderProfiles->getCamcorderProfileParamByName(
   1438                     "vid.codec", mCameraId, CAMCORDER_QUALITY_LOW);
   1439 
   1440             if (videoCodec > VIDEO_ENCODER_DEFAULT &&
   1441                 videoCodec < VIDEO_ENCODER_LIST_END) {
   1442                 mVideoEncoder = (video_encoder)videoCodec;
   1443             } else {
   1444                 // default to H.264 if camcorder profile not available
   1445                 mVideoEncoder = VIDEO_ENCODER_H264;
   1446             }
   1447         }
   1448     }
   1449 }
   1450 
   1451 status_t StagefrightRecorder::checkAudioEncoderCapabilities() {
   1452     clipAudioBitRate();
   1453     clipAudioSampleRate();
   1454     clipNumberOfAudioChannels();
   1455     return OK;
   1456 }
   1457 
   1458 void StagefrightRecorder::clipAudioBitRate() {
   1459     ALOGV("clipAudioBitRate: encoder %d", mAudioEncoder);
   1460 
   1461     int minAudioBitRate =
   1462             mEncoderProfiles->getAudioEncoderParamByName(
   1463                 "enc.aud.bps.min", mAudioEncoder);
   1464     if (minAudioBitRate != -1 && mAudioBitRate < minAudioBitRate) {
   1465         ALOGW("Intended audio encoding bit rate (%d) is too small"
   1466             " and will be set to (%d)", mAudioBitRate, minAudioBitRate);
   1467         mAudioBitRate = minAudioBitRate;
   1468     }
   1469 
   1470     int maxAudioBitRate =
   1471             mEncoderProfiles->getAudioEncoderParamByName(
   1472                 "enc.aud.bps.max", mAudioEncoder);
   1473     if (maxAudioBitRate != -1 && mAudioBitRate > maxAudioBitRate) {
   1474         ALOGW("Intended audio encoding bit rate (%d) is too large"
   1475             " and will be set to (%d)", mAudioBitRate, maxAudioBitRate);
   1476         mAudioBitRate = maxAudioBitRate;
   1477     }
   1478 }
   1479 
   1480 void StagefrightRecorder::clipAudioSampleRate() {
   1481     ALOGV("clipAudioSampleRate: encoder %d", mAudioEncoder);
   1482 
   1483     int minSampleRate =
   1484             mEncoderProfiles->getAudioEncoderParamByName(
   1485                 "enc.aud.hz.min", mAudioEncoder);
   1486     if (minSampleRate != -1 && mSampleRate < minSampleRate) {
   1487         ALOGW("Intended audio sample rate (%d) is too small"
   1488             " and will be set to (%d)", mSampleRate, minSampleRate);
   1489         mSampleRate = minSampleRate;
   1490     }
   1491 
   1492     int maxSampleRate =
   1493             mEncoderProfiles->getAudioEncoderParamByName(
   1494                 "enc.aud.hz.max", mAudioEncoder);
   1495     if (maxSampleRate != -1 && mSampleRate > maxSampleRate) {
   1496         ALOGW("Intended audio sample rate (%d) is too large"
   1497             " and will be set to (%d)", mSampleRate, maxSampleRate);
   1498         mSampleRate = maxSampleRate;
   1499     }
   1500 }
   1501 
   1502 void StagefrightRecorder::clipNumberOfAudioChannels() {
   1503     ALOGV("clipNumberOfAudioChannels: encoder %d", mAudioEncoder);
   1504 
   1505     int minChannels =
   1506             mEncoderProfiles->getAudioEncoderParamByName(
   1507                 "enc.aud.ch.min", mAudioEncoder);
   1508     if (minChannels != -1 && mAudioChannels < minChannels) {
   1509         ALOGW("Intended number of audio channels (%d) is too small"
   1510             " and will be set to (%d)", mAudioChannels, minChannels);
   1511         mAudioChannels = minChannels;
   1512     }
   1513 
   1514     int maxChannels =
   1515             mEncoderProfiles->getAudioEncoderParamByName(
   1516                 "enc.aud.ch.max", mAudioEncoder);
   1517     if (maxChannels != -1 && mAudioChannels > maxChannels) {
   1518         ALOGW("Intended number of audio channels (%d) is too large"
   1519             " and will be set to (%d)", mAudioChannels, maxChannels);
   1520         mAudioChannels = maxChannels;
   1521     }
   1522 }
   1523 
   1524 void StagefrightRecorder::clipVideoFrameHeight() {
   1525     ALOGV("clipVideoFrameHeight: encoder %d", mVideoEncoder);
   1526     int minFrameHeight = mEncoderProfiles->getVideoEncoderParamByName(
   1527                         "enc.vid.height.min", mVideoEncoder);
   1528     int maxFrameHeight = mEncoderProfiles->getVideoEncoderParamByName(
   1529                         "enc.vid.height.max", mVideoEncoder);
   1530     if (minFrameHeight != -1 && mVideoHeight < minFrameHeight) {
   1531         ALOGW("Intended video encoding frame height (%d) is too small"
   1532              " and will be set to (%d)", mVideoHeight, minFrameHeight);
   1533         mVideoHeight = minFrameHeight;
   1534     } else if (maxFrameHeight != -1 && mVideoHeight > maxFrameHeight) {
   1535         ALOGW("Intended video encoding frame height (%d) is too large"
   1536              " and will be set to (%d)", mVideoHeight, maxFrameHeight);
   1537         mVideoHeight = maxFrameHeight;
   1538     }
   1539 }
   1540 
   1541 // Set up the appropriate MediaSource depending on the chosen option
   1542 status_t StagefrightRecorder::setupMediaSource(
   1543                       sp<MediaSource> *mediaSource) {
   1544     if (mVideoSource == VIDEO_SOURCE_DEFAULT
   1545             || mVideoSource == VIDEO_SOURCE_CAMERA) {
   1546         sp<CameraSource> cameraSource;
   1547         status_t err = setupCameraSource(&cameraSource);
   1548         if (err != OK) {
   1549             return err;
   1550         }
   1551         *mediaSource = cameraSource;
   1552     } else if (mVideoSource == VIDEO_SOURCE_SURFACE) {
   1553         *mediaSource = NULL;
   1554     } else {
   1555         return INVALID_OPERATION;
   1556     }
   1557     return OK;
   1558 }
   1559 
   1560 status_t StagefrightRecorder::setupCameraSource(
   1561         sp<CameraSource> *cameraSource) {
   1562     status_t err = OK;
   1563     if ((err = checkVideoEncoderCapabilities()) != OK) {
   1564         return err;
   1565     }
   1566     Size videoSize;
   1567     videoSize.width = mVideoWidth;
   1568     videoSize.height = mVideoHeight;
   1569     if (mCaptureFpsEnable) {
   1570         if (!(mCaptureFps > 0.)) {
   1571             ALOGE("Invalid mCaptureFps value: %lf", mCaptureFps);
   1572             return BAD_VALUE;
   1573         }
   1574 
   1575         mCameraSourceTimeLapse = CameraSourceTimeLapse::CreateFromCamera(
   1576                 mCamera, mCameraProxy, mCameraId, mClientName, mClientUid, mClientPid,
   1577                 videoSize, mFrameRate, mPreviewSurface,
   1578                 std::llround(1e6 / mCaptureFps));
   1579         *cameraSource = mCameraSourceTimeLapse;
   1580     } else {
   1581         *cameraSource = CameraSource::CreateFromCamera(
   1582                 mCamera, mCameraProxy, mCameraId, mClientName, mClientUid, mClientPid,
   1583                 videoSize, mFrameRate,
   1584                 mPreviewSurface);
   1585     }
   1586     mCamera.clear();
   1587     mCameraProxy.clear();
   1588     if (*cameraSource == NULL) {
   1589         return UNKNOWN_ERROR;
   1590     }
   1591 
   1592     if ((*cameraSource)->initCheck() != OK) {
   1593         (*cameraSource).clear();
   1594         *cameraSource = NULL;
   1595         return NO_INIT;
   1596     }
   1597 
   1598     // When frame rate is not set, the actual frame rate will be set to
   1599     // the current frame rate being used.
   1600     if (mFrameRate == -1) {
   1601         int32_t frameRate = 0;
   1602         CHECK ((*cameraSource)->getFormat()->findInt32(
   1603                     kKeyFrameRate, &frameRate));
   1604         ALOGI("Frame rate is not explicitly set. Use the current frame "
   1605              "rate (%d fps)", frameRate);
   1606         mFrameRate = frameRate;
   1607     }
   1608 
   1609     CHECK(mFrameRate != -1);
   1610 
   1611     mMetaDataStoredInVideoBuffers =
   1612         (*cameraSource)->metaDataStoredInVideoBuffers();
   1613 
   1614     return OK;
   1615 }
   1616 
   1617 status_t StagefrightRecorder::setupVideoEncoder(
   1618         const sp<MediaSource> &cameraSource,
   1619         sp<MediaCodecSource> *source) {
   1620     source->clear();
   1621 
   1622     sp<AMessage> format = new AMessage();
   1623 
   1624     switch (mVideoEncoder) {
   1625         case VIDEO_ENCODER_H263:
   1626             format->setString("mime", MEDIA_MIMETYPE_VIDEO_H263);
   1627             break;
   1628 
   1629         case VIDEO_ENCODER_MPEG_4_SP:
   1630             format->setString("mime", MEDIA_MIMETYPE_VIDEO_MPEG4);
   1631             break;
   1632 
   1633         case VIDEO_ENCODER_H264:
   1634             format->setString("mime", MEDIA_MIMETYPE_VIDEO_AVC);
   1635             break;
   1636 
   1637         case VIDEO_ENCODER_VP8:
   1638             format->setString("mime", MEDIA_MIMETYPE_VIDEO_VP8);
   1639             break;
   1640 
   1641         case VIDEO_ENCODER_HEVC:
   1642             format->setString("mime", MEDIA_MIMETYPE_VIDEO_HEVC);
   1643             break;
   1644 
   1645         default:
   1646             CHECK(!"Should not be here, unsupported video encoding.");
   1647             break;
   1648     }
   1649 
   1650     if (cameraSource != NULL) {
   1651         sp<MetaData> meta = cameraSource->getFormat();
   1652 
   1653         int32_t width, height, stride, sliceHeight, colorFormat;
   1654         CHECK(meta->findInt32(kKeyWidth, &width));
   1655         CHECK(meta->findInt32(kKeyHeight, &height));
   1656         CHECK(meta->findInt32(kKeyStride, &stride));
   1657         CHECK(meta->findInt32(kKeySliceHeight, &sliceHeight));
   1658         CHECK(meta->findInt32(kKeyColorFormat, &colorFormat));
   1659 
   1660         format->setInt32("width", width);
   1661         format->setInt32("height", height);
   1662         format->setInt32("stride", stride);
   1663         format->setInt32("slice-height", sliceHeight);
   1664         format->setInt32("color-format", colorFormat);
   1665     } else {
   1666         format->setInt32("width", mVideoWidth);
   1667         format->setInt32("height", mVideoHeight);
   1668         format->setInt32("stride", mVideoWidth);
   1669         format->setInt32("slice-height", mVideoHeight);
   1670         format->setInt32("color-format", OMX_COLOR_FormatAndroidOpaque);
   1671 
   1672         // set up time lapse/slow motion for surface source
   1673         if (mCaptureFpsEnable) {
   1674             if (!(mCaptureFps > 0.)) {
   1675                 ALOGE("Invalid mCaptureFps value: %lf", mCaptureFps);
   1676                 return BAD_VALUE;
   1677             }
   1678             format->setDouble("time-lapse-fps", mCaptureFps);
   1679         }
   1680     }
   1681 
   1682     format->setInt32("bitrate", mVideoBitRate);
   1683     format->setInt32("frame-rate", mFrameRate);
   1684     format->setInt32("i-frame-interval", mIFramesIntervalSec);
   1685 
   1686     if (mVideoTimeScale > 0) {
   1687         format->setInt32("time-scale", mVideoTimeScale);
   1688     }
   1689     if (mVideoEncoderProfile != -1) {
   1690         format->setInt32("profile", mVideoEncoderProfile);
   1691     }
   1692     if (mVideoEncoderLevel != -1) {
   1693         format->setInt32("level", mVideoEncoderLevel);
   1694     }
   1695 
   1696     uint32_t tsLayers = 1;
   1697     bool preferBFrames = true; // we like B-frames as it produces better quality per bitrate
   1698     format->setInt32("priority", 0 /* realtime */);
   1699     float maxPlaybackFps = mFrameRate; // assume video is only played back at normal speed
   1700 
   1701     if (mCaptureFpsEnable) {
   1702         format->setFloat("operating-rate", mCaptureFps);
   1703 
   1704         // enable layering for all time lapse and high frame rate recordings
   1705         if (mFrameRate / mCaptureFps >= 1.9) { // time lapse
   1706             preferBFrames = false;
   1707             tsLayers = 2; // use at least two layers as resulting video will likely be sped up
   1708         } else if (mCaptureFps > maxPlaybackFps) { // slow-mo
   1709             maxPlaybackFps = mCaptureFps; // assume video will be played back at full capture speed
   1710             preferBFrames = false;
   1711         }
   1712     }
   1713 
   1714     for (uint32_t tryLayers = 1; tryLayers <= kMaxNumVideoTemporalLayers; ++tryLayers) {
   1715         if (tryLayers > tsLayers) {
   1716             tsLayers = tryLayers;
   1717         }
   1718         // keep going until the base layer fps falls below the typical display refresh rate
   1719         float baseLayerFps = maxPlaybackFps / (1 << (tryLayers - 1));
   1720         if (baseLayerFps < kMinTypicalDisplayRefreshingRate / 0.9) {
   1721             break;
   1722         }
   1723     }
   1724 
   1725     if (tsLayers > 1) {
   1726         uint32_t bLayers = std::min(2u, tsLayers - 1); // use up-to 2 B-layers
   1727         uint32_t pLayers = tsLayers - bLayers;
   1728         format->setString(
   1729                 "ts-schema", AStringPrintf("android.generic.%u+%u", pLayers, bLayers));
   1730 
   1731         // TODO: some encoders do not support B-frames with temporal layering, and we have a
   1732         // different preference based on use-case. We could move this into camera profiles.
   1733         format->setInt32("android._prefer-b-frames", preferBFrames);
   1734     }
   1735 
   1736     if (mMetaDataStoredInVideoBuffers != kMetadataBufferTypeInvalid) {
   1737         format->setInt32("android._input-metadata-buffer-type", mMetaDataStoredInVideoBuffers);
   1738     }
   1739 
   1740     uint32_t flags = 0;
   1741     if (cameraSource == NULL) {
   1742         flags |= MediaCodecSource::FLAG_USE_SURFACE_INPUT;
   1743     } else {
   1744         // require dataspace setup even if not using surface input
   1745         format->setInt32("android._using-recorder", 1);
   1746     }
   1747 
   1748     sp<MediaCodecSource> encoder = MediaCodecSource::Create(
   1749             mLooper, format, cameraSource, mPersistentSurface, flags);
   1750     if (encoder == NULL) {
   1751         ALOGE("Failed to create video encoder");
   1752         // When the encoder fails to be created, we need
   1753         // release the camera source due to the camera's lock
   1754         // and unlock mechanism.
   1755         if (cameraSource != NULL) {
   1756             cameraSource->stop();
   1757         }
   1758         return UNKNOWN_ERROR;
   1759     }
   1760 
   1761     if (cameraSource == NULL) {
   1762         mGraphicBufferProducer = encoder->getGraphicBufferProducer();
   1763     }
   1764 
   1765     *source = encoder;
   1766 
   1767     return OK;
   1768 }
   1769 
   1770 status_t StagefrightRecorder::setupAudioEncoder(const sp<MediaWriter>& writer) {
   1771     status_t status = BAD_VALUE;
   1772     if (OK != (status = checkAudioEncoderCapabilities())) {
   1773         return status;
   1774     }
   1775 
   1776     switch(mAudioEncoder) {
   1777         case AUDIO_ENCODER_AMR_NB:
   1778         case AUDIO_ENCODER_AMR_WB:
   1779         case AUDIO_ENCODER_AAC:
   1780         case AUDIO_ENCODER_HE_AAC:
   1781         case AUDIO_ENCODER_AAC_ELD:
   1782             break;
   1783 
   1784         default:
   1785             ALOGE("Unsupported audio encoder: %d", mAudioEncoder);
   1786             return UNKNOWN_ERROR;
   1787     }
   1788 
   1789     sp<MediaCodecSource> audioEncoder = createAudioSource();
   1790     if (audioEncoder == NULL) {
   1791         return UNKNOWN_ERROR;
   1792     }
   1793 
   1794     writer->addSource(audioEncoder);
   1795     mAudioEncoderSource = audioEncoder;
   1796     return OK;
   1797 }
   1798 
   1799 status_t StagefrightRecorder::setupMPEG4orWEBMRecording() {
   1800     mWriter.clear();
   1801     mTotalBitRate = 0;
   1802 
   1803     status_t err = OK;
   1804     sp<MediaWriter> writer;
   1805     sp<MPEG4Writer> mp4writer;
   1806     if (mOutputFormat == OUTPUT_FORMAT_WEBM) {
   1807         writer = new WebmWriter(mOutputFd);
   1808     } else {
   1809         writer = mp4writer = new MPEG4Writer(mOutputFd);
   1810     }
   1811 
   1812     if (mVideoSource < VIDEO_SOURCE_LIST_END) {
   1813         setDefaultVideoEncoderIfNecessary();
   1814 
   1815         sp<MediaSource> mediaSource;
   1816         err = setupMediaSource(&mediaSource);
   1817         if (err != OK) {
   1818             return err;
   1819         }
   1820 
   1821         sp<MediaCodecSource> encoder;
   1822         err = setupVideoEncoder(mediaSource, &encoder);
   1823         if (err != OK) {
   1824             return err;
   1825         }
   1826 
   1827         writer->addSource(encoder);
   1828         mVideoEncoderSource = encoder;
   1829         mTotalBitRate += mVideoBitRate;
   1830     }
   1831 
   1832     if (mOutputFormat != OUTPUT_FORMAT_WEBM) {
   1833         // Audio source is added at the end if it exists.
   1834         // This help make sure that the "recoding" sound is suppressed for
   1835         // camcorder applications in the recorded files.
   1836         // TODO Audio source is currently unsupported for webm output; vorbis encoder needed.
   1837         // disable audio for time lapse recording
   1838         bool disableAudio = mCaptureFpsEnable && mCaptureFps < mFrameRate;
   1839         if (!disableAudio && mAudioSource != AUDIO_SOURCE_CNT) {
   1840             err = setupAudioEncoder(writer);
   1841             if (err != OK) return err;
   1842             mTotalBitRate += mAudioBitRate;
   1843         }
   1844 
   1845         if (mCaptureFpsEnable) {
   1846             mp4writer->setCaptureRate(mCaptureFps);
   1847         }
   1848 
   1849         if (mInterleaveDurationUs > 0) {
   1850             mp4writer->setInterleaveDuration(mInterleaveDurationUs);
   1851         }
   1852         if (mLongitudex10000 > -3600000 && mLatitudex10000 > -3600000) {
   1853             mp4writer->setGeoData(mLatitudex10000, mLongitudex10000);
   1854         }
   1855     }
   1856     if (mMaxFileDurationUs != 0) {
   1857         writer->setMaxFileDuration(mMaxFileDurationUs);
   1858     }
   1859     if (mMaxFileSizeBytes != 0) {
   1860         writer->setMaxFileSize(mMaxFileSizeBytes);
   1861     }
   1862     if (mVideoSource == VIDEO_SOURCE_DEFAULT
   1863             || mVideoSource == VIDEO_SOURCE_CAMERA) {
   1864         mStartTimeOffsetMs = mEncoderProfiles->getStartTimeOffsetMs(mCameraId);
   1865     } else if (mVideoSource == VIDEO_SOURCE_SURFACE) {
   1866         // surface source doesn't need large initial delay
   1867         mStartTimeOffsetMs = 100;
   1868     }
   1869     if (mStartTimeOffsetMs > 0) {
   1870         writer->setStartTimeOffsetMs(mStartTimeOffsetMs);
   1871     }
   1872 
   1873     writer->setListener(mListener);
   1874     mWriter = writer;
   1875     return OK;
   1876 }
   1877 
   1878 void StagefrightRecorder::setupMPEG4orWEBMMetaData(sp<MetaData> *meta) {
   1879     int64_t startTimeUs = systemTime() / 1000;
   1880     (*meta)->setInt64(kKeyTime, startTimeUs);
   1881     (*meta)->setInt32(kKeyFileType, mOutputFormat);
   1882     (*meta)->setInt32(kKeyBitRate, mTotalBitRate);
   1883     if (mMovieTimeScale > 0) {
   1884         (*meta)->setInt32(kKeyTimeScale, mMovieTimeScale);
   1885     }
   1886     if (mOutputFormat != OUTPUT_FORMAT_WEBM) {
   1887         (*meta)->setInt32(kKey64BitFileOffset, mUse64BitFileOffset);
   1888         if (mTrackEveryTimeDurationUs > 0) {
   1889             (*meta)->setInt64(kKeyTrackTimeStatus, mTrackEveryTimeDurationUs);
   1890         }
   1891         if (mRotationDegrees != 0) {
   1892             (*meta)->setInt32(kKeyRotation, mRotationDegrees);
   1893         }
   1894     }
   1895 }
   1896 
   1897 status_t StagefrightRecorder::pause() {
   1898     ALOGV("pause");
   1899     if (!mStarted) {
   1900         return INVALID_OPERATION;
   1901     }
   1902 
   1903     // Already paused --- no-op.
   1904     if (mPauseStartTimeUs != 0) {
   1905         return OK;
   1906     }
   1907 
   1908     mPauseStartTimeUs = systemTime() / 1000;
   1909     sp<MetaData> meta = new MetaData;
   1910     meta->setInt64(kKeyTime, mPauseStartTimeUs);
   1911 
   1912     if (mAudioEncoderSource != NULL) {
   1913         mAudioEncoderSource->pause();
   1914     }
   1915     if (mVideoEncoderSource != NULL) {
   1916         mVideoEncoderSource->pause(meta.get());
   1917     }
   1918 
   1919     return OK;
   1920 }
   1921 
   1922 status_t StagefrightRecorder::resume() {
   1923     ALOGV("resume");
   1924     if (!mStarted) {
   1925         return INVALID_OPERATION;
   1926     }
   1927 
   1928     // Not paused --- no-op.
   1929     if (mPauseStartTimeUs == 0) {
   1930         return OK;
   1931     }
   1932 
   1933     int64_t resumeStartTimeUs = systemTime() / 1000;
   1934 
   1935     int64_t bufferStartTimeUs = 0;
   1936     bool allSourcesStarted = true;
   1937     for (const auto &source : { mAudioEncoderSource, mVideoEncoderSource }) {
   1938         if (source == nullptr) {
   1939             continue;
   1940         }
   1941         int64_t timeUs = source->getFirstSampleSystemTimeUs();
   1942         if (timeUs < 0) {
   1943             allSourcesStarted = false;
   1944         }
   1945         if (bufferStartTimeUs < timeUs) {
   1946             bufferStartTimeUs = timeUs;
   1947         }
   1948     }
   1949 
   1950     if (allSourcesStarted) {
   1951         if (mPauseStartTimeUs < bufferStartTimeUs) {
   1952             mPauseStartTimeUs = bufferStartTimeUs;
   1953         }
   1954         // 30 ms buffer to avoid timestamp overlap
   1955         mTotalPausedDurationUs += resumeStartTimeUs - mPauseStartTimeUs - 30000;
   1956     }
   1957     double timeOffset = -mTotalPausedDurationUs;
   1958     if (mCaptureFpsEnable) {
   1959         timeOffset *= mCaptureFps / mFrameRate;
   1960     }
   1961     sp<MetaData> meta = new MetaData;
   1962     meta->setInt64(kKeyTime, resumeStartTimeUs);
   1963     for (const auto &source : { mAudioEncoderSource, mVideoEncoderSource }) {
   1964         if (source == nullptr) {
   1965             continue;
   1966         }
   1967         source->setInputBufferTimeOffset((int64_t)timeOffset);
   1968         source->start(meta.get());
   1969     }
   1970     mPauseStartTimeUs = 0;
   1971 
   1972     return OK;
   1973 }
   1974 
   1975 status_t StagefrightRecorder::stop() {
   1976     ALOGV("stop");
   1977     Mutex::Autolock autolock(mLock);
   1978     status_t err = OK;
   1979 
   1980     if (mCaptureFpsEnable && mCameraSourceTimeLapse != NULL) {
   1981         mCameraSourceTimeLapse->startQuickReadReturns();
   1982         mCameraSourceTimeLapse = NULL;
   1983     }
   1984 
   1985     int64_t stopTimeUs = systemTime() / 1000;
   1986     for (const auto &source : { mAudioEncoderSource, mVideoEncoderSource }) {
   1987         if (source != nullptr && OK != source->setStopTimeUs(stopTimeUs)) {
   1988             ALOGW("Failed to set stopTime %lld us for %s",
   1989                     (long long)stopTimeUs, source->isVideo() ? "Video" : "Audio");
   1990         }
   1991     }
   1992 
   1993     if (mWriter != NULL) {
   1994         err = mWriter->stop();
   1995         mWriter.clear();
   1996     }
   1997 
   1998     resetMetrics();
   1999 
   2000     mTotalPausedDurationUs = 0;
   2001     mPauseStartTimeUs = 0;
   2002 
   2003     mGraphicBufferProducer.clear();
   2004     mPersistentSurface.clear();
   2005     mAudioEncoderSource.clear();
   2006     mVideoEncoderSource.clear();
   2007 
   2008     if (mOutputFd >= 0) {
   2009         ::close(mOutputFd);
   2010         mOutputFd = -1;
   2011     }
   2012 
   2013     if (mStarted) {
   2014         mStarted = false;
   2015 
   2016         uint32_t params = 0;
   2017         if (mAudioSource != AUDIO_SOURCE_CNT) {
   2018             params |= IMediaPlayerService::kBatteryDataTrackAudio;
   2019         }
   2020         if (mVideoSource != VIDEO_SOURCE_LIST_END) {
   2021             params |= IMediaPlayerService::kBatteryDataTrackVideo;
   2022         }
   2023 
   2024         addBatteryData(params);
   2025     }
   2026 
   2027     return err;
   2028 }
   2029 
   2030 status_t StagefrightRecorder::close() {
   2031     ALOGV("close");
   2032     stop();
   2033 
   2034     return OK;
   2035 }
   2036 
   2037 status_t StagefrightRecorder::reset() {
   2038     ALOGV("reset");
   2039     stop();
   2040 
   2041     // No audio or video source by default
   2042     mAudioSource = AUDIO_SOURCE_CNT;
   2043     mVideoSource = VIDEO_SOURCE_LIST_END;
   2044 
   2045     // Default parameters
   2046     mOutputFormat  = OUTPUT_FORMAT_THREE_GPP;
   2047     mAudioEncoder  = AUDIO_ENCODER_AMR_NB;
   2048     mVideoEncoder  = VIDEO_ENCODER_DEFAULT;
   2049     mVideoWidth    = 176;
   2050     mVideoHeight   = 144;
   2051     mFrameRate     = -1;
   2052     mVideoBitRate  = 192000;
   2053     mSampleRate    = 8000;
   2054     mAudioChannels = 1;
   2055     mAudioBitRate  = 12200;
   2056     mInterleaveDurationUs = 0;
   2057     mIFramesIntervalSec = 1;
   2058     mAudioSourceNode = 0;
   2059     mUse64BitFileOffset = false;
   2060     mMovieTimeScale  = -1;
   2061     mAudioTimeScale  = -1;
   2062     mVideoTimeScale  = -1;
   2063     mCameraId        = 0;
   2064     mStartTimeOffsetMs = -1;
   2065     mVideoEncoderProfile = -1;
   2066     mVideoEncoderLevel   = -1;
   2067     mMaxFileDurationUs = 0;
   2068     mMaxFileSizeBytes = 0;
   2069     mTrackEveryTimeDurationUs = 0;
   2070     mCaptureFpsEnable = false;
   2071     mCaptureFps = -1.0;
   2072     mCameraSourceTimeLapse = NULL;
   2073     mMetaDataStoredInVideoBuffers = kMetadataBufferTypeInvalid;
   2074     mEncoderProfiles = MediaProfiles::getInstance();
   2075     mRotationDegrees = 0;
   2076     mLatitudex10000 = -3600000;
   2077     mLongitudex10000 = -3600000;
   2078     mTotalBitRate = 0;
   2079 
   2080     mOutputFd = -1;
   2081 
   2082     return OK;
   2083 }
   2084 
   2085 status_t StagefrightRecorder::getMaxAmplitude(int *max) {
   2086     ALOGV("getMaxAmplitude");
   2087 
   2088     if (max == NULL) {
   2089         ALOGE("Null pointer argument");
   2090         return BAD_VALUE;
   2091     }
   2092 
   2093     if (mAudioSourceNode != 0) {
   2094         *max = mAudioSourceNode->getMaxAmplitude();
   2095     } else {
   2096         *max = 0;
   2097     }
   2098 
   2099     return OK;
   2100 }
   2101 
   2102 status_t StagefrightRecorder::getMetrics(Parcel *reply) {
   2103     ALOGD("StagefrightRecorder::getMetrics");
   2104 
   2105     if (reply == NULL) {
   2106         ALOGE("Null pointer argument");
   2107         return BAD_VALUE;
   2108     }
   2109 
   2110     if (mAnalyticsItem == NULL) {
   2111         return UNKNOWN_ERROR;
   2112     }
   2113 
   2114     updateMetrics();
   2115     mAnalyticsItem->writeToParcel(reply);
   2116     return OK;
   2117 }
   2118 
   2119 status_t StagefrightRecorder::dump(
   2120         int fd, const Vector<String16>& args) const {
   2121     ALOGV("dump");
   2122     Mutex::Autolock autolock(mLock);
   2123     const size_t SIZE = 256;
   2124     char buffer[SIZE];
   2125     String8 result;
   2126     if (mWriter != 0) {
   2127         mWriter->dump(fd, args);
   2128     } else {
   2129         snprintf(buffer, SIZE, "   No file writer\n");
   2130         result.append(buffer);
   2131     }
   2132     snprintf(buffer, SIZE, "   Recorder: %p\n", this);
   2133     snprintf(buffer, SIZE, "   Output file (fd %d):\n", mOutputFd);
   2134     result.append(buffer);
   2135     snprintf(buffer, SIZE, "     File format: %d\n", mOutputFormat);
   2136     result.append(buffer);
   2137     snprintf(buffer, SIZE, "     Max file size (bytes): %" PRId64 "\n", mMaxFileSizeBytes);
   2138     result.append(buffer);
   2139     snprintf(buffer, SIZE, "     Max file duration (us): %" PRId64 "\n", mMaxFileDurationUs);
   2140     result.append(buffer);
   2141     snprintf(buffer, SIZE, "     File offset length (bits): %d\n", mUse64BitFileOffset? 64: 32);
   2142     result.append(buffer);
   2143     snprintf(buffer, SIZE, "     Interleave duration (us): %d\n", mInterleaveDurationUs);
   2144     result.append(buffer);
   2145     snprintf(buffer, SIZE, "     Progress notification: %" PRId64 " us\n", mTrackEveryTimeDurationUs);
   2146     result.append(buffer);
   2147     snprintf(buffer, SIZE, "   Audio\n");
   2148     result.append(buffer);
   2149     snprintf(buffer, SIZE, "     Source: %d\n", mAudioSource);
   2150     result.append(buffer);
   2151     snprintf(buffer, SIZE, "     Encoder: %d\n", mAudioEncoder);
   2152     result.append(buffer);
   2153     snprintf(buffer, SIZE, "     Bit rate (bps): %d\n", mAudioBitRate);
   2154     result.append(buffer);
   2155     snprintf(buffer, SIZE, "     Sampling rate (hz): %d\n", mSampleRate);
   2156     result.append(buffer);
   2157     snprintf(buffer, SIZE, "     Number of channels: %d\n", mAudioChannels);
   2158     result.append(buffer);
   2159     snprintf(buffer, SIZE, "     Max amplitude: %d\n", mAudioSourceNode == 0? 0: mAudioSourceNode->getMaxAmplitude());
   2160     result.append(buffer);
   2161     snprintf(buffer, SIZE, "   Video\n");
   2162     result.append(buffer);
   2163     snprintf(buffer, SIZE, "     Source: %d\n", mVideoSource);
   2164     result.append(buffer);
   2165     snprintf(buffer, SIZE, "     Camera Id: %d\n", mCameraId);
   2166     result.append(buffer);
   2167     snprintf(buffer, SIZE, "     Start time offset (ms): %d\n", mStartTimeOffsetMs);
   2168     result.append(buffer);
   2169     snprintf(buffer, SIZE, "     Encoder: %d\n", mVideoEncoder);
   2170     result.append(buffer);
   2171     snprintf(buffer, SIZE, "     Encoder profile: %d\n", mVideoEncoderProfile);
   2172     result.append(buffer);
   2173     snprintf(buffer, SIZE, "     Encoder level: %d\n", mVideoEncoderLevel);
   2174     result.append(buffer);
   2175     snprintf(buffer, SIZE, "     I frames interval (s): %d\n", mIFramesIntervalSec);
   2176     result.append(buffer);
   2177     snprintf(buffer, SIZE, "     Frame size (pixels): %dx%d\n", mVideoWidth, mVideoHeight);
   2178     result.append(buffer);
   2179     snprintf(buffer, SIZE, "     Frame rate (fps): %d\n", mFrameRate);
   2180     result.append(buffer);
   2181     snprintf(buffer, SIZE, "     Bit rate (bps): %d\n", mVideoBitRate);
   2182     result.append(buffer);
   2183     ::write(fd, result.string(), result.size());
   2184     return OK;
   2185 }
   2186 }  // namespace android
   2187