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