Merge "stagefright: request IDR on MediaRecorder.resume" into nyc-dev
diff --git a/camera/ndk/NdkCameraCaptureSession.cpp b/camera/ndk/NdkCameraCaptureSession.cpp
index ab93bd6..d6eff24 100644
--- a/camera/ndk/NdkCameraCaptureSession.cpp
+++ b/camera/ndk/NdkCameraCaptureSession.cpp
@@ -122,7 +122,16 @@
}
EXPORT
-camera_status_t ACameraCaptureSession_abortCaptures(ACameraCaptureSession*) {
+camera_status_t ACameraCaptureSession_abortCaptures(ACameraCaptureSession* session) {
ATRACE_CALL();
- return ACAMERA_OK;
+ if (session == nullptr) {
+ ALOGE("%s: Error: session is null", __FUNCTION__);
+ return ACAMERA_ERROR_INVALID_PARAMETER;
+ }
+
+ if (session->isClosed()) {
+ ALOGE("%s: session %p is already closed", __FUNCTION__, session);
+ return ACAMERA_ERROR_SESSION_CLOSED;
+ }
+ return session->abortCaptures();
}
diff --git a/camera/ndk/impl/ACameraCaptureSession.cpp b/camera/ndk/impl/ACameraCaptureSession.cpp
index b741e46..b9c159d 100644
--- a/camera/ndk/impl/ACameraCaptureSession.cpp
+++ b/camera/ndk/impl/ACameraCaptureSession.cpp
@@ -90,6 +90,24 @@
}
camera_status_t
+ACameraCaptureSession::abortCaptures() {
+ sp<CameraDevice> dev = getDeviceSp();
+ if (dev == nullptr) {
+ ALOGE("Error: Device associated with session %p has been closed!", this);
+ return ACAMERA_ERROR_SESSION_CLOSED;
+ }
+
+ camera_status_t ret;
+ dev->lockDeviceForSessionOps();
+ {
+ Mutex::Autolock _l(mSessionLock);
+ ret = dev->flushLocked(this);
+ }
+ dev->unlockDevice();
+ return ret;
+}
+
+camera_status_t
ACameraCaptureSession::setRepeatingRequest(
/*optional*/ACameraCaptureSession_captureCallbacks* cbs,
int numRequests, ACaptureRequest** requests,
diff --git a/camera/ndk/impl/ACameraCaptureSession.h b/camera/ndk/impl/ACameraCaptureSession.h
index f20b324..58428e6 100644
--- a/camera/ndk/impl/ACameraCaptureSession.h
+++ b/camera/ndk/impl/ACameraCaptureSession.h
@@ -77,6 +77,8 @@
camera_status_t stopRepeating();
+ camera_status_t abortCaptures();
+
camera_status_t setRepeatingRequest(
/*optional*/ACameraCaptureSession_captureCallbacks* cbs,
int numRequests, ACaptureRequest** requests,
@@ -104,7 +106,6 @@
const wp<CameraDevice> mDevice;
bool mIsClosed = false;
bool mClosedByApp = false;
- bool mIdle = true;
Mutex mSessionLock;
};
diff --git a/camera/ndk/impl/ACameraDevice.cpp b/camera/ndk/impl/ACameraDevice.cpp
index 6bca692..8f1115a 100644
--- a/camera/ndk/impl/ACameraDevice.cpp
+++ b/camera/ndk/impl/ACameraDevice.cpp
@@ -170,6 +170,7 @@
// set new session as current session
newSession->incStrong((void *) ACameraDevice_createCaptureSession);
mCurrentSession = newSession;
+ mFlushing = false;
*session = newSession;
return ACAMERA_OK;
}
@@ -389,6 +390,58 @@
}
camera_status_t
+CameraDevice::flushLocked(ACameraCaptureSession* session) {
+ camera_status_t ret = checkCameraClosedOrErrorLocked();
+ if (ret != ACAMERA_OK) {
+ ALOGE("Camera %s abort captures failed! ret %d", getId(), ret);
+ return ret;
+ }
+
+ // This should never happen because creating a new session will close
+ // previous one and thus reject any API call from previous session.
+ // But still good to check here in case something unexpected happen.
+ if (session != mCurrentSession) {
+ ALOGE("Camera %s session %p is not current active session!", getId(), session);
+ return ACAMERA_ERROR_INVALID_OPERATION;
+ }
+
+ if (mFlushing) {
+ ALOGW("Camera %s is already aborting captures", getId());
+ return ACAMERA_OK;
+ }
+
+ mFlushing = true;
+ // Send onActive callback to guarantee there is always active->ready transition
+ sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler);
+ msg->setPointer(kContextKey, session->mUserSessionCallback.context);
+ msg->setObject(kSessionSpKey, session);
+ msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onActive);
+ msg->post();
+
+ // If device is already idling, send callback and exit early
+ if (mIdle) {
+ sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler);
+ msg->setPointer(kContextKey, session->mUserSessionCallback.context);
+ msg->setObject(kSessionSpKey, session);
+ msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onReady);
+ msg->post();
+ mFlushing = false;
+ return ACAMERA_OK;
+ }
+
+ int64_t lastFrameNumber;
+ binder::Status remoteRet = mRemote->flush(&lastFrameNumber);
+ if (!remoteRet.isOk()) {
+ ALOGE("Abort captures fails in remote: %s", remoteRet.toString8().string());
+ return ACAMERA_ERROR_UNKNOWN;
+ }
+ if (mRepeatingSequenceId != REQUEST_ID_NONE) {
+ checkRepeatingSequenceCompleteLocked(mRepeatingSequenceId, lastFrameNumber);
+ }
+ return ACAMERA_OK;
+}
+
+camera_status_t
CameraDevice::waitUntilIdleLocked() {
camera_status_t ret = checkCameraClosedOrErrorLocked();
if (ret != ACAMERA_OK) {
@@ -1109,6 +1162,7 @@
msg->post();
}
dev->mIdle = true;
+ dev->mFlushing = false;
return ret;
}
diff --git a/camera/ndk/impl/ACameraDevice.h b/camera/ndk/impl/ACameraDevice.h
index 46243b9..fd51a81 100644
--- a/camera/ndk/impl/ACameraDevice.h
+++ b/camera/ndk/impl/ACameraDevice.h
@@ -96,6 +96,8 @@
camera_status_t stopRepeatingLocked();
+ camera_status_t flushLocked(ACameraCaptureSession*);
+
camera_status_t waitUntilIdleLocked();
@@ -152,13 +154,13 @@
std::atomic_bool mClosing;
inline bool isClosed() { return mClosing; }
- bool mInError;
- camera_status_t mError;
+ bool mInError = false;
+ camera_status_t mError = ACAMERA_OK;
void onCaptureErrorLocked(
int32_t errorCode,
const CaptureResultExtras& resultExtras);
- bool mIdle;
+ bool mIdle = true;
// This will avoid a busy session being deleted before it's back to idle state
sp<ACameraCaptureSession> mBusySession;
@@ -203,6 +205,7 @@
***********************************/
// The current active session
ACameraCaptureSession* mCurrentSession = nullptr;
+ bool mFlushing = false;
int mNextSessionId = 0;
// TODO: might need another looper/handler to handle callbacks from service
diff --git a/include/camera/ndk/NdkCameraMetadataTags.h b/include/camera/ndk/NdkCameraMetadataTags.h
index a1d3bf7..afdd269 100644
--- a/include/camera/ndk/NdkCameraMetadataTags.h
+++ b/include/camera/ndk/NdkCameraMetadataTags.h
@@ -514,478 +514,476 @@
// ACAMERA_COLOR_CORRECTION_MODE
typedef enum acamera_metadata_enum_acamera_color_correction_mode {
- ACAMERA_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX,
- ACAMERA_COLOR_CORRECTION_MODE_FAST,
- ACAMERA_COLOR_CORRECTION_MODE_HIGH_QUALITY,
+ ACAMERA_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX = 0,
+ ACAMERA_COLOR_CORRECTION_MODE_FAST = 1,
+ ACAMERA_COLOR_CORRECTION_MODE_HIGH_QUALITY = 2,
} acamera_metadata_enum_android_color_correction_mode_t;
// ACAMERA_COLOR_CORRECTION_ABERRATION_MODE
typedef enum acamera_metadata_enum_acamera_color_correction_aberration_mode {
- ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_OFF,
- ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_FAST,
- ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY,
+ ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_OFF = 0,
+ ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_FAST = 1,
+ ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY = 2,
} acamera_metadata_enum_android_color_correction_aberration_mode_t;
// ACAMERA_CONTROL_AE_ANTIBANDING_MODE
typedef enum acamera_metadata_enum_acamera_control_ae_antibanding_mode {
- ACAMERA_CONTROL_AE_ANTIBANDING_MODE_OFF,
- ACAMERA_CONTROL_AE_ANTIBANDING_MODE_50HZ,
- ACAMERA_CONTROL_AE_ANTIBANDING_MODE_60HZ,
- ACAMERA_CONTROL_AE_ANTIBANDING_MODE_AUTO,
+ ACAMERA_CONTROL_AE_ANTIBANDING_MODE_OFF = 0,
+ ACAMERA_CONTROL_AE_ANTIBANDING_MODE_50HZ = 1,
+ ACAMERA_CONTROL_AE_ANTIBANDING_MODE_60HZ = 2,
+ ACAMERA_CONTROL_AE_ANTIBANDING_MODE_AUTO = 3,
} acamera_metadata_enum_android_control_ae_antibanding_mode_t;
// ACAMERA_CONTROL_AE_LOCK
typedef enum acamera_metadata_enum_acamera_control_ae_lock {
- ACAMERA_CONTROL_AE_LOCK_OFF,
- ACAMERA_CONTROL_AE_LOCK_ON,
+ ACAMERA_CONTROL_AE_LOCK_OFF = 0,
+ ACAMERA_CONTROL_AE_LOCK_ON = 1,
} acamera_metadata_enum_android_control_ae_lock_t;
// ACAMERA_CONTROL_AE_MODE
typedef enum acamera_metadata_enum_acamera_control_ae_mode {
- ACAMERA_CONTROL_AE_MODE_OFF,
- ACAMERA_CONTROL_AE_MODE_ON,
- ACAMERA_CONTROL_AE_MODE_ON_AUTO_FLASH,
- ACAMERA_CONTROL_AE_MODE_ON_ALWAYS_FLASH,
- ACAMERA_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE,
+ ACAMERA_CONTROL_AE_MODE_OFF = 0,
+ ACAMERA_CONTROL_AE_MODE_ON = 1,
+ ACAMERA_CONTROL_AE_MODE_ON_AUTO_FLASH = 2,
+ ACAMERA_CONTROL_AE_MODE_ON_ALWAYS_FLASH = 3,
+ ACAMERA_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE = 4,
} acamera_metadata_enum_android_control_ae_mode_t;
// ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
typedef enum acamera_metadata_enum_acamera_control_ae_precapture_trigger {
- ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE,
- ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_START,
- ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL,
+ ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE = 0,
+ ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_START = 1,
+ ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL = 2,
} acamera_metadata_enum_android_control_ae_precapture_trigger_t;
// ACAMERA_CONTROL_AF_MODE
typedef enum acamera_metadata_enum_acamera_control_af_mode {
- ACAMERA_CONTROL_AF_MODE_OFF,
- ACAMERA_CONTROL_AF_MODE_AUTO,
- ACAMERA_CONTROL_AF_MODE_MACRO,
- ACAMERA_CONTROL_AF_MODE_CONTINUOUS_VIDEO,
- ACAMERA_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
- ACAMERA_CONTROL_AF_MODE_EDOF,
+ ACAMERA_CONTROL_AF_MODE_OFF = 0,
+ ACAMERA_CONTROL_AF_MODE_AUTO = 1,
+ ACAMERA_CONTROL_AF_MODE_MACRO = 2,
+ ACAMERA_CONTROL_AF_MODE_CONTINUOUS_VIDEO = 3,
+ ACAMERA_CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4,
+ ACAMERA_CONTROL_AF_MODE_EDOF = 5,
} acamera_metadata_enum_android_control_af_mode_t;
// ACAMERA_CONTROL_AF_TRIGGER
typedef enum acamera_metadata_enum_acamera_control_af_trigger {
- ACAMERA_CONTROL_AF_TRIGGER_IDLE,
- ACAMERA_CONTROL_AF_TRIGGER_START,
- ACAMERA_CONTROL_AF_TRIGGER_CANCEL,
+ ACAMERA_CONTROL_AF_TRIGGER_IDLE = 0,
+ ACAMERA_CONTROL_AF_TRIGGER_START = 1,
+ ACAMERA_CONTROL_AF_TRIGGER_CANCEL = 2,
} acamera_metadata_enum_android_control_af_trigger_t;
// ACAMERA_CONTROL_AWB_LOCK
typedef enum acamera_metadata_enum_acamera_control_awb_lock {
- ACAMERA_CONTROL_AWB_LOCK_OFF,
- ACAMERA_CONTROL_AWB_LOCK_ON,
+ ACAMERA_CONTROL_AWB_LOCK_OFF = 0,
+ ACAMERA_CONTROL_AWB_LOCK_ON = 1,
} acamera_metadata_enum_android_control_awb_lock_t;
// ACAMERA_CONTROL_AWB_MODE
typedef enum acamera_metadata_enum_acamera_control_awb_mode {
- ACAMERA_CONTROL_AWB_MODE_OFF,
- ACAMERA_CONTROL_AWB_MODE_AUTO,
- ACAMERA_CONTROL_AWB_MODE_INCANDESCENT,
- ACAMERA_CONTROL_AWB_MODE_FLUORESCENT,
- ACAMERA_CONTROL_AWB_MODE_WARM_FLUORESCENT,
- ACAMERA_CONTROL_AWB_MODE_DAYLIGHT,
- ACAMERA_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT,
- ACAMERA_CONTROL_AWB_MODE_TWILIGHT,
- ACAMERA_CONTROL_AWB_MODE_SHADE,
+ ACAMERA_CONTROL_AWB_MODE_OFF = 0,
+ ACAMERA_CONTROL_AWB_MODE_AUTO = 1,
+ ACAMERA_CONTROL_AWB_MODE_INCANDESCENT = 2,
+ ACAMERA_CONTROL_AWB_MODE_FLUORESCENT = 3,
+ ACAMERA_CONTROL_AWB_MODE_WARM_FLUORESCENT = 4,
+ ACAMERA_CONTROL_AWB_MODE_DAYLIGHT = 5,
+ ACAMERA_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT = 6,
+ ACAMERA_CONTROL_AWB_MODE_TWILIGHT = 7,
+ ACAMERA_CONTROL_AWB_MODE_SHADE = 8,
} acamera_metadata_enum_android_control_awb_mode_t;
// ACAMERA_CONTROL_CAPTURE_INTENT
typedef enum acamera_metadata_enum_acamera_control_capture_intent {
- ACAMERA_CONTROL_CAPTURE_INTENT_CUSTOM,
- ACAMERA_CONTROL_CAPTURE_INTENT_PREVIEW,
- ACAMERA_CONTROL_CAPTURE_INTENT_STILL_CAPTURE,
- ACAMERA_CONTROL_CAPTURE_INTENT_VIDEO_RECORD,
- ACAMERA_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT,
- ACAMERA_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG,
- ACAMERA_CONTROL_CAPTURE_INTENT_MANUAL,
+ ACAMERA_CONTROL_CAPTURE_INTENT_CUSTOM = 0,
+ ACAMERA_CONTROL_CAPTURE_INTENT_PREVIEW = 1,
+ ACAMERA_CONTROL_CAPTURE_INTENT_STILL_CAPTURE = 2,
+ ACAMERA_CONTROL_CAPTURE_INTENT_VIDEO_RECORD = 3,
+ ACAMERA_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT = 4,
+ ACAMERA_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG = 5,
+ ACAMERA_CONTROL_CAPTURE_INTENT_MANUAL = 6,
} acamera_metadata_enum_android_control_capture_intent_t;
// ACAMERA_CONTROL_EFFECT_MODE
typedef enum acamera_metadata_enum_acamera_control_effect_mode {
- ACAMERA_CONTROL_EFFECT_MODE_OFF,
- ACAMERA_CONTROL_EFFECT_MODE_MONO,
- ACAMERA_CONTROL_EFFECT_MODE_NEGATIVE,
- ACAMERA_CONTROL_EFFECT_MODE_SOLARIZE,
- ACAMERA_CONTROL_EFFECT_MODE_SEPIA,
- ACAMERA_CONTROL_EFFECT_MODE_POSTERIZE,
- ACAMERA_CONTROL_EFFECT_MODE_WHITEBOARD,
- ACAMERA_CONTROL_EFFECT_MODE_BLACKBOARD,
- ACAMERA_CONTROL_EFFECT_MODE_AQUA,
+ ACAMERA_CONTROL_EFFECT_MODE_OFF = 0,
+ ACAMERA_CONTROL_EFFECT_MODE_MONO = 1,
+ ACAMERA_CONTROL_EFFECT_MODE_NEGATIVE = 2,
+ ACAMERA_CONTROL_EFFECT_MODE_SOLARIZE = 3,
+ ACAMERA_CONTROL_EFFECT_MODE_SEPIA = 4,
+ ACAMERA_CONTROL_EFFECT_MODE_POSTERIZE = 5,
+ ACAMERA_CONTROL_EFFECT_MODE_WHITEBOARD = 6,
+ ACAMERA_CONTROL_EFFECT_MODE_BLACKBOARD = 7,
+ ACAMERA_CONTROL_EFFECT_MODE_AQUA = 8,
} acamera_metadata_enum_android_control_effect_mode_t;
// ACAMERA_CONTROL_MODE
typedef enum acamera_metadata_enum_acamera_control_mode {
- ACAMERA_CONTROL_MODE_OFF,
- ACAMERA_CONTROL_MODE_AUTO,
- ACAMERA_CONTROL_MODE_USE_SCENE_MODE,
- ACAMERA_CONTROL_MODE_OFF_KEEP_STATE,
+ ACAMERA_CONTROL_MODE_OFF = 0,
+ ACAMERA_CONTROL_MODE_AUTO = 1,
+ ACAMERA_CONTROL_MODE_USE_SCENE_MODE = 2,
+ ACAMERA_CONTROL_MODE_OFF_KEEP_STATE = 3,
} acamera_metadata_enum_android_control_mode_t;
// ACAMERA_CONTROL_SCENE_MODE
typedef enum acamera_metadata_enum_acamera_control_scene_mode {
- ACAMERA_CONTROL_SCENE_MODE_DISABLED = 0,
- ACAMERA_CONTROL_SCENE_MODE_FACE_PRIORITY,
- ACAMERA_CONTROL_SCENE_MODE_ACTION,
- ACAMERA_CONTROL_SCENE_MODE_PORTRAIT,
- ACAMERA_CONTROL_SCENE_MODE_LANDSCAPE,
- ACAMERA_CONTROL_SCENE_MODE_NIGHT,
- ACAMERA_CONTROL_SCENE_MODE_NIGHT_PORTRAIT,
- ACAMERA_CONTROL_SCENE_MODE_THEATRE,
- ACAMERA_CONTROL_SCENE_MODE_BEACH,
- ACAMERA_CONTROL_SCENE_MODE_SNOW,
- ACAMERA_CONTROL_SCENE_MODE_SUNSET,
- ACAMERA_CONTROL_SCENE_MODE_STEADYPHOTO,
- ACAMERA_CONTROL_SCENE_MODE_FIREWORKS,
- ACAMERA_CONTROL_SCENE_MODE_SPORTS,
- ACAMERA_CONTROL_SCENE_MODE_PARTY,
- ACAMERA_CONTROL_SCENE_MODE_CANDLELIGHT,
- ACAMERA_CONTROL_SCENE_MODE_BARCODE,
- ACAMERA_CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO,
- ACAMERA_CONTROL_SCENE_MODE_HDR,
- ACAMERA_CONTROL_SCENE_MODE_FACE_PRIORITY_LOW_LIGHT,
- ACAMERA_CONTROL_SCENE_MODE_DEVICE_CUSTOM_START = 100,
- ACAMERA_CONTROL_SCENE_MODE_DEVICE_CUSTOM_END = 127,
+ ACAMERA_CONTROL_SCENE_MODE_DISABLED = 0,
+ ACAMERA_CONTROL_SCENE_MODE_FACE_PRIORITY = 1,
+ ACAMERA_CONTROL_SCENE_MODE_ACTION = 2,
+ ACAMERA_CONTROL_SCENE_MODE_PORTRAIT = 3,
+ ACAMERA_CONTROL_SCENE_MODE_LANDSCAPE = 4,
+ ACAMERA_CONTROL_SCENE_MODE_NIGHT = 5,
+ ACAMERA_CONTROL_SCENE_MODE_NIGHT_PORTRAIT = 6,
+ ACAMERA_CONTROL_SCENE_MODE_THEATRE = 7,
+ ACAMERA_CONTROL_SCENE_MODE_BEACH = 8,
+ ACAMERA_CONTROL_SCENE_MODE_SNOW = 9,
+ ACAMERA_CONTROL_SCENE_MODE_SUNSET = 10,
+ ACAMERA_CONTROL_SCENE_MODE_STEADYPHOTO = 11,
+ ACAMERA_CONTROL_SCENE_MODE_FIREWORKS = 12,
+ ACAMERA_CONTROL_SCENE_MODE_SPORTS = 13,
+ ACAMERA_CONTROL_SCENE_MODE_PARTY = 14,
+ ACAMERA_CONTROL_SCENE_MODE_CANDLELIGHT = 15,
+ ACAMERA_CONTROL_SCENE_MODE_BARCODE = 16,
+ ACAMERA_CONTROL_SCENE_MODE_HIGH_SPEED_VIDEO = 17,
+ ACAMERA_CONTROL_SCENE_MODE_HDR = 18,
} acamera_metadata_enum_android_control_scene_mode_t;
// ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE
typedef enum acamera_metadata_enum_acamera_control_video_stabilization_mode {
- ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
- ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_ON,
+ ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_OFF = 0,
+ ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_ON = 1,
} acamera_metadata_enum_android_control_video_stabilization_mode_t;
// ACAMERA_CONTROL_AE_STATE
typedef enum acamera_metadata_enum_acamera_control_ae_state {
- ACAMERA_CONTROL_AE_STATE_INACTIVE,
- ACAMERA_CONTROL_AE_STATE_SEARCHING,
- ACAMERA_CONTROL_AE_STATE_CONVERGED,
- ACAMERA_CONTROL_AE_STATE_LOCKED,
- ACAMERA_CONTROL_AE_STATE_FLASH_REQUIRED,
- ACAMERA_CONTROL_AE_STATE_PRECAPTURE,
+ ACAMERA_CONTROL_AE_STATE_INACTIVE = 0,
+ ACAMERA_CONTROL_AE_STATE_SEARCHING = 1,
+ ACAMERA_CONTROL_AE_STATE_CONVERGED = 2,
+ ACAMERA_CONTROL_AE_STATE_LOCKED = 3,
+ ACAMERA_CONTROL_AE_STATE_FLASH_REQUIRED = 4,
+ ACAMERA_CONTROL_AE_STATE_PRECAPTURE = 5,
} acamera_metadata_enum_android_control_ae_state_t;
// ACAMERA_CONTROL_AF_STATE
typedef enum acamera_metadata_enum_acamera_control_af_state {
- ACAMERA_CONTROL_AF_STATE_INACTIVE,
- ACAMERA_CONTROL_AF_STATE_PASSIVE_SCAN,
- ACAMERA_CONTROL_AF_STATE_PASSIVE_FOCUSED,
- ACAMERA_CONTROL_AF_STATE_ACTIVE_SCAN,
- ACAMERA_CONTROL_AF_STATE_FOCUSED_LOCKED,
- ACAMERA_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED,
- ACAMERA_CONTROL_AF_STATE_PASSIVE_UNFOCUSED,
+ ACAMERA_CONTROL_AF_STATE_INACTIVE = 0,
+ ACAMERA_CONTROL_AF_STATE_PASSIVE_SCAN = 1,
+ ACAMERA_CONTROL_AF_STATE_PASSIVE_FOCUSED = 2,
+ ACAMERA_CONTROL_AF_STATE_ACTIVE_SCAN = 3,
+ ACAMERA_CONTROL_AF_STATE_FOCUSED_LOCKED = 4,
+ ACAMERA_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED = 5,
+ ACAMERA_CONTROL_AF_STATE_PASSIVE_UNFOCUSED = 6,
} acamera_metadata_enum_android_control_af_state_t;
// ACAMERA_CONTROL_AWB_STATE
typedef enum acamera_metadata_enum_acamera_control_awb_state {
- ACAMERA_CONTROL_AWB_STATE_INACTIVE,
- ACAMERA_CONTROL_AWB_STATE_SEARCHING,
- ACAMERA_CONTROL_AWB_STATE_CONVERGED,
- ACAMERA_CONTROL_AWB_STATE_LOCKED,
+ ACAMERA_CONTROL_AWB_STATE_INACTIVE = 0,
+ ACAMERA_CONTROL_AWB_STATE_SEARCHING = 1,
+ ACAMERA_CONTROL_AWB_STATE_CONVERGED = 2,
+ ACAMERA_CONTROL_AWB_STATE_LOCKED = 3,
} acamera_metadata_enum_android_control_awb_state_t;
// ACAMERA_CONTROL_AE_LOCK_AVAILABLE
typedef enum acamera_metadata_enum_acamera_control_ae_lock_available {
- ACAMERA_CONTROL_AE_LOCK_AVAILABLE_FALSE,
- ACAMERA_CONTROL_AE_LOCK_AVAILABLE_TRUE,
+ ACAMERA_CONTROL_AE_LOCK_AVAILABLE_FALSE = 0,
+ ACAMERA_CONTROL_AE_LOCK_AVAILABLE_TRUE = 1,
} acamera_metadata_enum_android_control_ae_lock_available_t;
// ACAMERA_CONTROL_AWB_LOCK_AVAILABLE
typedef enum acamera_metadata_enum_acamera_control_awb_lock_available {
- ACAMERA_CONTROL_AWB_LOCK_AVAILABLE_FALSE,
- ACAMERA_CONTROL_AWB_LOCK_AVAILABLE_TRUE,
+ ACAMERA_CONTROL_AWB_LOCK_AVAILABLE_FALSE = 0,
+ ACAMERA_CONTROL_AWB_LOCK_AVAILABLE_TRUE = 1,
} acamera_metadata_enum_android_control_awb_lock_available_t;
// ACAMERA_EDGE_MODE
typedef enum acamera_metadata_enum_acamera_edge_mode {
- ACAMERA_EDGE_MODE_OFF,
- ACAMERA_EDGE_MODE_FAST,
- ACAMERA_EDGE_MODE_HIGH_QUALITY,
- ACAMERA_EDGE_MODE_ZERO_SHUTTER_LAG,
+ ACAMERA_EDGE_MODE_OFF = 0,
+ ACAMERA_EDGE_MODE_FAST = 1,
+ ACAMERA_EDGE_MODE_HIGH_QUALITY = 2,
+ ACAMERA_EDGE_MODE_ZERO_SHUTTER_LAG = 3,
} acamera_metadata_enum_android_edge_mode_t;
// ACAMERA_FLASH_MODE
typedef enum acamera_metadata_enum_acamera_flash_mode {
- ACAMERA_FLASH_MODE_OFF,
- ACAMERA_FLASH_MODE_SINGLE,
- ACAMERA_FLASH_MODE_TORCH,
+ ACAMERA_FLASH_MODE_OFF = 0,
+ ACAMERA_FLASH_MODE_SINGLE = 1,
+ ACAMERA_FLASH_MODE_TORCH = 2,
} acamera_metadata_enum_android_flash_mode_t;
// ACAMERA_FLASH_STATE
typedef enum acamera_metadata_enum_acamera_flash_state {
- ACAMERA_FLASH_STATE_UNAVAILABLE,
- ACAMERA_FLASH_STATE_CHARGING,
- ACAMERA_FLASH_STATE_READY,
- ACAMERA_FLASH_STATE_FIRED,
- ACAMERA_FLASH_STATE_PARTIAL,
+ ACAMERA_FLASH_STATE_UNAVAILABLE = 0,
+ ACAMERA_FLASH_STATE_CHARGING = 1,
+ ACAMERA_FLASH_STATE_READY = 2,
+ ACAMERA_FLASH_STATE_FIRED = 3,
+ ACAMERA_FLASH_STATE_PARTIAL = 4,
} acamera_metadata_enum_android_flash_state_t;
// ACAMERA_FLASH_INFO_AVAILABLE
typedef enum acamera_metadata_enum_acamera_flash_info_available {
- ACAMERA_FLASH_INFO_AVAILABLE_FALSE,
- ACAMERA_FLASH_INFO_AVAILABLE_TRUE,
+ ACAMERA_FLASH_INFO_AVAILABLE_FALSE = 0,
+ ACAMERA_FLASH_INFO_AVAILABLE_TRUE = 1,
} acamera_metadata_enum_android_flash_info_available_t;
// ACAMERA_HOT_PIXEL_MODE
typedef enum acamera_metadata_enum_acamera_hot_pixel_mode {
- ACAMERA_HOT_PIXEL_MODE_OFF,
- ACAMERA_HOT_PIXEL_MODE_FAST,
- ACAMERA_HOT_PIXEL_MODE_HIGH_QUALITY,
+ ACAMERA_HOT_PIXEL_MODE_OFF = 0,
+ ACAMERA_HOT_PIXEL_MODE_FAST = 1,
+ ACAMERA_HOT_PIXEL_MODE_HIGH_QUALITY = 2,
} acamera_metadata_enum_android_hot_pixel_mode_t;
// ACAMERA_LENS_OPTICAL_STABILIZATION_MODE
typedef enum acamera_metadata_enum_acamera_lens_optical_stabilization_mode {
- ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_OFF,
- ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_ON,
+ ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_OFF = 0,
+ ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_ON = 1,
} acamera_metadata_enum_android_lens_optical_stabilization_mode_t;
// ACAMERA_LENS_FACING
typedef enum acamera_metadata_enum_acamera_lens_facing {
- ACAMERA_LENS_FACING_FRONT,
- ACAMERA_LENS_FACING_BACK,
- ACAMERA_LENS_FACING_EXTERNAL,
+ ACAMERA_LENS_FACING_FRONT = 0,
+ ACAMERA_LENS_FACING_BACK = 1,
+ ACAMERA_LENS_FACING_EXTERNAL = 2,
} acamera_metadata_enum_android_lens_facing_t;
// ACAMERA_LENS_STATE
typedef enum acamera_metadata_enum_acamera_lens_state {
- ACAMERA_LENS_STATE_STATIONARY,
- ACAMERA_LENS_STATE_MOVING,
+ ACAMERA_LENS_STATE_STATIONARY = 0,
+ ACAMERA_LENS_STATE_MOVING = 1,
} acamera_metadata_enum_android_lens_state_t;
// ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION
typedef enum acamera_metadata_enum_acamera_lens_info_focus_distance_calibration {
- ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED,
- ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE,
- ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED,
+ ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED = 0,
+ ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE = 1,
+ ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED = 2,
} acamera_metadata_enum_android_lens_info_focus_distance_calibration_t;
// ACAMERA_NOISE_REDUCTION_MODE
typedef enum acamera_metadata_enum_acamera_noise_reduction_mode {
- ACAMERA_NOISE_REDUCTION_MODE_OFF,
- ACAMERA_NOISE_REDUCTION_MODE_FAST,
- ACAMERA_NOISE_REDUCTION_MODE_HIGH_QUALITY,
- ACAMERA_NOISE_REDUCTION_MODE_MINIMAL,
- ACAMERA_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG,
+ ACAMERA_NOISE_REDUCTION_MODE_OFF = 0,
+ ACAMERA_NOISE_REDUCTION_MODE_FAST = 1,
+ ACAMERA_NOISE_REDUCTION_MODE_HIGH_QUALITY = 2,
+ ACAMERA_NOISE_REDUCTION_MODE_MINIMAL = 3,
+ ACAMERA_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG = 4,
} acamera_metadata_enum_android_noise_reduction_mode_t;
// ACAMERA_QUIRKS_PARTIAL_RESULT
typedef enum acamera_metadata_enum_acamera_quirks_partial_result {
- ACAMERA_QUIRKS_PARTIAL_RESULT_FINAL,
- ACAMERA_QUIRKS_PARTIAL_RESULT_PARTIAL,
+ ACAMERA_QUIRKS_PARTIAL_RESULT_FINAL = 0,
+ ACAMERA_QUIRKS_PARTIAL_RESULT_PARTIAL = 1,
} acamera_metadata_enum_android_quirks_partial_result_t;
// ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
typedef enum acamera_metadata_enum_acamera_request_available_capabilities {
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_RAW,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT,
- ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE = 0,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR = 1,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING = 2,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_RAW = 3,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING = 4,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS = 5,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE = 6,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING = 7,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT = 8,
+ ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO
+ = 9,
} acamera_metadata_enum_android_request_available_capabilities_t;
// ACAMERA_SCALER_AVAILABLE_FORMATS
typedef enum acamera_metadata_enum_acamera_scaler_available_formats {
- ACAMERA_SCALER_AVAILABLE_FORMATS_RAW16 = 0x20,
- ACAMERA_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE = 0x24,
- ACAMERA_SCALER_AVAILABLE_FORMATS_YV12 = 0x32315659,
- ACAMERA_SCALER_AVAILABLE_FORMATS_YCrCb_420_SP = 0x11,
- ACAMERA_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED = 0x22,
- ACAMERA_SCALER_AVAILABLE_FORMATS_YCbCr_420_888 = 0x23,
- ACAMERA_SCALER_AVAILABLE_FORMATS_BLOB = 0x21,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_RAW16 = 0x20,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE = 0x24,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_YV12 = 0x32315659,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_YCrCb_420_SP = 0x11,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_IMPLEMENTATION_DEFINED = 0x22,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_YCbCr_420_888 = 0x23,
+ ACAMERA_SCALER_AVAILABLE_FORMATS_BLOB = 0x21,
} acamera_metadata_enum_android_scaler_available_formats_t;
// ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS
typedef enum acamera_metadata_enum_acamera_scaler_available_stream_configurations {
- ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
- ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT,
+ ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT = 0,
+ ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT = 1,
} acamera_metadata_enum_android_scaler_available_stream_configurations_t;
// ACAMERA_SCALER_CROPPING_TYPE
typedef enum acamera_metadata_enum_acamera_scaler_cropping_type {
- ACAMERA_SCALER_CROPPING_TYPE_CENTER_ONLY,
- ACAMERA_SCALER_CROPPING_TYPE_FREEFORM,
+ ACAMERA_SCALER_CROPPING_TYPE_CENTER_ONLY = 0,
+ ACAMERA_SCALER_CROPPING_TYPE_FREEFORM = 1,
} acamera_metadata_enum_android_scaler_cropping_type_t;
// ACAMERA_SENSOR_REFERENCE_ILLUMINANT1
typedef enum acamera_metadata_enum_acamera_sensor_reference_illuminant1 {
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT = 1,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT = 2,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN = 3,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FLASH = 4,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER = 9,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER = 10,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_SHADE = 11,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT = 12,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT = 13,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT = 14,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT = 15,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A = 17,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B = 18,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C = 19,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D55 = 20,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D65 = 21,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D75 = 22,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D50 = 23,
- ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN = 24,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT = 1,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT = 2,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN = 3,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FLASH = 4,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER = 9,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER = 10,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_SHADE = 11,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT = 12,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT = 13,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT = 14,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT = 15,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A = 17,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B = 18,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C = 19,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D55 = 20,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D65 = 21,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D75 = 22,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D50 = 23,
+ ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN = 24,
} acamera_metadata_enum_android_sensor_reference_illuminant1_t;
// ACAMERA_SENSOR_TEST_PATTERN_MODE
typedef enum acamera_metadata_enum_acamera_sensor_test_pattern_mode {
- ACAMERA_SENSOR_TEST_PATTERN_MODE_OFF,
- ACAMERA_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR,
- ACAMERA_SENSOR_TEST_PATTERN_MODE_COLOR_BARS,
- ACAMERA_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY,
- ACAMERA_SENSOR_TEST_PATTERN_MODE_PN9,
- ACAMERA_SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 256,
+ ACAMERA_SENSOR_TEST_PATTERN_MODE_OFF = 0,
+ ACAMERA_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR = 1,
+ ACAMERA_SENSOR_TEST_PATTERN_MODE_COLOR_BARS = 2,
+ ACAMERA_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY = 3,
+ ACAMERA_SENSOR_TEST_PATTERN_MODE_PN9 = 4,
+ ACAMERA_SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 256,
} acamera_metadata_enum_android_sensor_test_pattern_mode_t;
// ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
typedef enum acamera_metadata_enum_acamera_sensor_info_color_filter_arrangement {
- ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB,
- ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG,
- ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG,
- ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR,
- ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB,
+ ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB = 0,
+ ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG = 1,
+ ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG = 2,
+ ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR = 3,
+ ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB = 4,
} acamera_metadata_enum_android_sensor_info_color_filter_arrangement_t;
// ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE
typedef enum acamera_metadata_enum_acamera_sensor_info_timestamp_source {
- ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN,
- ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME,
+ ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN = 0,
+ ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME = 1,
} acamera_metadata_enum_android_sensor_info_timestamp_source_t;
// ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED
typedef enum acamera_metadata_enum_acamera_sensor_info_lens_shading_applied {
- ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED_FALSE,
- ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED_TRUE,
+ ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED_FALSE = 0,
+ ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED_TRUE = 1,
} acamera_metadata_enum_android_sensor_info_lens_shading_applied_t;
// ACAMERA_SHADING_MODE
typedef enum acamera_metadata_enum_acamera_shading_mode {
- ACAMERA_SHADING_MODE_OFF,
- ACAMERA_SHADING_MODE_FAST,
- ACAMERA_SHADING_MODE_HIGH_QUALITY,
+ ACAMERA_SHADING_MODE_OFF = 0,
+ ACAMERA_SHADING_MODE_FAST = 1,
+ ACAMERA_SHADING_MODE_HIGH_QUALITY = 2,
} acamera_metadata_enum_android_shading_mode_t;
// ACAMERA_STATISTICS_FACE_DETECT_MODE
typedef enum acamera_metadata_enum_acamera_statistics_face_detect_mode {
- ACAMERA_STATISTICS_FACE_DETECT_MODE_OFF,
- ACAMERA_STATISTICS_FACE_DETECT_MODE_SIMPLE,
- ACAMERA_STATISTICS_FACE_DETECT_MODE_FULL,
+ ACAMERA_STATISTICS_FACE_DETECT_MODE_OFF = 0,
+ ACAMERA_STATISTICS_FACE_DETECT_MODE_SIMPLE = 1,
+ ACAMERA_STATISTICS_FACE_DETECT_MODE_FULL = 2,
} acamera_metadata_enum_android_statistics_face_detect_mode_t;
// ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE
typedef enum acamera_metadata_enum_acamera_statistics_hot_pixel_map_mode {
- ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE_OFF,
- ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE_ON,
+ ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE_OFF = 0,
+ ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE_ON = 1,
} acamera_metadata_enum_android_statistics_hot_pixel_map_mode_t;
// ACAMERA_STATISTICS_SCENE_FLICKER
typedef enum acamera_metadata_enum_acamera_statistics_scene_flicker {
- ACAMERA_STATISTICS_SCENE_FLICKER_NONE,
- ACAMERA_STATISTICS_SCENE_FLICKER_50HZ,
- ACAMERA_STATISTICS_SCENE_FLICKER_60HZ,
+ ACAMERA_STATISTICS_SCENE_FLICKER_NONE = 0,
+ ACAMERA_STATISTICS_SCENE_FLICKER_50HZ = 1,
+ ACAMERA_STATISTICS_SCENE_FLICKER_60HZ = 2,
} acamera_metadata_enum_android_statistics_scene_flicker_t;
// ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE
typedef enum acamera_metadata_enum_acamera_statistics_lens_shading_map_mode {
- ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE_OFF,
- ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE_ON,
+ ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE_OFF = 0,
+ ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE_ON = 1,
} acamera_metadata_enum_android_statistics_lens_shading_map_mode_t;
// ACAMERA_TONEMAP_MODE
typedef enum acamera_metadata_enum_acamera_tonemap_mode {
- ACAMERA_TONEMAP_MODE_CONTRAST_CURVE,
- ACAMERA_TONEMAP_MODE_FAST,
- ACAMERA_TONEMAP_MODE_HIGH_QUALITY,
- ACAMERA_TONEMAP_MODE_GAMMA_VALUE,
- ACAMERA_TONEMAP_MODE_PRESET_CURVE,
+ ACAMERA_TONEMAP_MODE_CONTRAST_CURVE = 0,
+ ACAMERA_TONEMAP_MODE_FAST = 1,
+ ACAMERA_TONEMAP_MODE_HIGH_QUALITY = 2,
+ ACAMERA_TONEMAP_MODE_GAMMA_VALUE = 3,
+ ACAMERA_TONEMAP_MODE_PRESET_CURVE = 4,
} acamera_metadata_enum_android_tonemap_mode_t;
// ACAMERA_TONEMAP_PRESET_CURVE
typedef enum acamera_metadata_enum_acamera_tonemap_preset_curve {
- ACAMERA_TONEMAP_PRESET_CURVE_SRGB,
- ACAMERA_TONEMAP_PRESET_CURVE_REC709,
+ ACAMERA_TONEMAP_PRESET_CURVE_SRGB = 0,
+ ACAMERA_TONEMAP_PRESET_CURVE_REC709 = 1,
} acamera_metadata_enum_android_tonemap_preset_curve_t;
// ACAMERA_LED_TRANSMIT
typedef enum acamera_metadata_enum_acamera_led_transmit {
- ACAMERA_LED_TRANSMIT_OFF,
- ACAMERA_LED_TRANSMIT_ON,
+ ACAMERA_LED_TRANSMIT_OFF = 0,
+ ACAMERA_LED_TRANSMIT_ON = 1,
} acamera_metadata_enum_android_led_transmit_t;
// ACAMERA_LED_AVAILABLE_LEDS
typedef enum acamera_metadata_enum_acamera_led_available_leds {
- ACAMERA_LED_AVAILABLE_LEDS_TRANSMIT,
+ ACAMERA_LED_AVAILABLE_LEDS_TRANSMIT = 0,
} acamera_metadata_enum_android_led_available_leds_t;
// ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL
typedef enum acamera_metadata_enum_acamera_info_supported_hardware_level {
- ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
- ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
- ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY,
- ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_3,
+ ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED = 0,
+ ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_FULL = 1,
+ ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY = 2,
+ ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_3 = 3,
} acamera_metadata_enum_android_info_supported_hardware_level_t;
// ACAMERA_BLACK_LEVEL_LOCK
typedef enum acamera_metadata_enum_acamera_black_level_lock {
- ACAMERA_BLACK_LEVEL_LOCK_OFF,
- ACAMERA_BLACK_LEVEL_LOCK_ON,
+ ACAMERA_BLACK_LEVEL_LOCK_OFF = 0,
+ ACAMERA_BLACK_LEVEL_LOCK_ON = 1,
} acamera_metadata_enum_android_black_level_lock_t;
// ACAMERA_SYNC_FRAME_NUMBER
typedef enum acamera_metadata_enum_acamera_sync_frame_number {
- ACAMERA_SYNC_FRAME_NUMBER_CONVERGING = -1,
- ACAMERA_SYNC_FRAME_NUMBER_UNKNOWN = -2,
+ ACAMERA_SYNC_FRAME_NUMBER_CONVERGING = -1,
+ ACAMERA_SYNC_FRAME_NUMBER_UNKNOWN = -2,
} acamera_metadata_enum_android_sync_frame_number_t;
// ACAMERA_SYNC_MAX_LATENCY
typedef enum acamera_metadata_enum_acamera_sync_max_latency {
- ACAMERA_SYNC_MAX_LATENCY_PER_FRAME_CONTROL = 0,
- ACAMERA_SYNC_MAX_LATENCY_UNKNOWN = -1,
+ ACAMERA_SYNC_MAX_LATENCY_PER_FRAME_CONTROL = 0,
+ ACAMERA_SYNC_MAX_LATENCY_UNKNOWN = -1,
} acamera_metadata_enum_android_sync_max_latency_t;
// ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS
typedef enum acamera_metadata_enum_acamera_depth_available_depth_stream_configurations {
- ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT,
- ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT,
+ ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT = 0,
+ ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT = 1,
} acamera_metadata_enum_android_depth_available_depth_stream_configurations_t;
// ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE
typedef enum acamera_metadata_enum_acamera_depth_depth_is_exclusive {
- ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE,
- ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE,
+ ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE = 0,
+ ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE = 1,
} acamera_metadata_enum_android_depth_depth_is_exclusive_t;
diff --git a/include/media/AudioTrack.h b/include/media/AudioTrack.h
index 9e0e98b..bdd6372 100644
--- a/include/media/AudioTrack.h
+++ b/include/media/AudioTrack.h
@@ -830,6 +830,11 @@
bool isDirect_l() const
{ return (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) != 0; }
+ // pure pcm data is mixable (which excludes HW_AV_SYNC, with embedded timing)
+ bool isPurePcmData_l() const
+ { return audio_is_linear_pcm(mFormat)
+ && (mAttributes.flags & AUDIO_FLAG_HW_AV_SYNC) == 0; }
+
// increment mPosition by the delta of mServer, and return new value of mPosition
Modulo<uint32_t> updateAndGetPosition_l();
diff --git a/media/libmedia/AudioTrack.cpp b/media/libmedia/AudioTrack.cpp
index a731354..e70c611 100644
--- a/media/libmedia/AudioTrack.cpp
+++ b/media/libmedia/AudioTrack.cpp
@@ -1016,7 +1016,11 @@
}
AutoMutex lock(mLock);
- if (isOffloadedOrDirect_l()) {
+ // FIXME: offloaded and direct tracks call into the HAL for render positions
+ // for compressed/synced data; however, we use proxy position for pure linear pcm data
+ // as we do not know the capability of the HAL for pcm position support and standby.
+ // There may be some latency differences between the HAL position and the proxy position.
+ if (isOffloadedOrDirect_l() && !isPurePcmData_l()) {
uint32_t dspFrames = 0;
if (isOffloaded_l() && ((mState == STATE_PAUSED) || (mState == STATE_PAUSED_STOPPING))) {
diff --git a/media/libmedia/AudioTrackShared.cpp b/media/libmedia/AudioTrackShared.cpp
index f7baa15..2396d87 100644
--- a/media/libmedia/AudioTrackShared.cpp
+++ b/media/libmedia/AudioTrackShared.cpp
@@ -107,6 +107,7 @@
return clippedSize;
}
+__attribute__((no_sanitize("integer")))
status_t ClientProxy::obtainBuffer(Buffer* buffer, const struct timespec *requested,
struct timespec *elapsed)
{
@@ -332,6 +333,7 @@
return status;
}
+__attribute__((no_sanitize("integer")))
void ClientProxy::releaseBuffer(Buffer* buffer)
{
LOG_ALWAYS_FATAL_IF(buffer == NULL);
@@ -619,6 +621,7 @@
cblk->mBufferSizeInFrames = frameCount;
}
+__attribute__((no_sanitize("integer")))
status_t ServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush)
{
LOG_ALWAYS_FATAL_IF(buffer == NULL || buffer->mFrameCount == 0);
@@ -728,6 +731,7 @@
return NO_INIT;
}
+__attribute__((no_sanitize("integer")))
void ServerProxy::releaseBuffer(Buffer* buffer)
{
LOG_ALWAYS_FATAL_IF(buffer == NULL);
@@ -780,6 +784,7 @@
// ---------------------------------------------------------------------------
+__attribute__((no_sanitize("integer")))
size_t AudioTrackServerProxy::framesReady()
{
LOG_ALWAYS_FATAL_IF(!mIsOut);
diff --git a/media/libmedia/IAudioFlinger.cpp b/media/libmedia/IAudioFlinger.cpp
index 042eac5..7543b60 100644
--- a/media/libmedia/IAudioFlinger.cpp
+++ b/media/libmedia/IAudioFlinger.cpp
@@ -1355,7 +1355,7 @@
CHECK_INTERFACE(IAudioFlinger, data, reply);
struct audio_patch patch;
data.read(&patch, sizeof(struct audio_patch));
- audio_patch_handle_t handle = {};
+ audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) {
ALOGE("b/23905951");
}
diff --git a/media/libmedia/IAudioPolicyService.cpp b/media/libmedia/IAudioPolicyService.cpp
index 16e8f11..4ea67da 100644
--- a/media/libmedia/IAudioPolicyService.cpp
+++ b/media/libmedia/IAudioPolicyService.cpp
@@ -965,7 +965,7 @@
audio_channel_mask_t channelMask = data.readInt32();
audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();
audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32();
- audio_io_handle_t input = {};
+ audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
status_t status = getInputForAttr(&attr, &input, session, uid,
samplingRate, format, channelMask,
flags, selectedDeviceId);
@@ -1197,7 +1197,7 @@
CHECK_INTERFACE(IAudioPolicyService, data, reply);
struct audio_patch patch;
data.read(&patch, sizeof(struct audio_patch));
- audio_patch_handle_t handle = {};
+ audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) {
ALOGE("b/23912202");
}
@@ -1275,9 +1275,9 @@
CHECK_INTERFACE(IAudioPolicyService, data, reply);
sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(
data.readStrongBinder());
- audio_session_t session = {};
- audio_io_handle_t ioHandle = {};
- audio_devices_t device = {};
+ audio_session_t session = AUDIO_SESSION_NONE;
+ audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE;
+ audio_devices_t device = AUDIO_DEVICE_NONE;
status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device);
reply->writeInt32(status);
if (status == NO_ERROR) {
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
index 6c54e3f..42a82ac 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
@@ -1150,8 +1150,8 @@
}
restartAudio(
- positionUs, false /* forceNonOffload */,
- reason == Renderer::kDueToError /* needsToCreateAudioDecoder */);
+ positionUs, reason == Renderer::kForceNonOffload /* forceNonOffload */,
+ reason != Renderer::kDueToTimeout /* needsToCreateAudioDecoder */);
}
break;
}
@@ -1490,9 +1490,11 @@
void NuPlayer::restartAudio(
int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder) {
- mAudioDecoder->pause();
- mAudioDecoder.clear();
- ++mAudioDecoderGeneration;
+ if (mAudioDecoder != NULL) {
+ mAudioDecoder->pause();
+ mAudioDecoder.clear();
+ ++mAudioDecoderGeneration;
+ }
if (mFlushingAudio == FLUSHING_DECODER) {
mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
mFlushingAudio = FLUSHED;
@@ -1520,7 +1522,7 @@
mOffloadAudio = false;
}
if (needsToCreateAudioDecoder) {
- instantiateDecoder(true /* audio */, &mAudioDecoder);
+ instantiateDecoder(true /* audio */, &mAudioDecoder, !forceNonOffload);
}
}
@@ -1557,7 +1559,8 @@
}
}
-status_t NuPlayer::instantiateDecoder(bool audio, sp<DecoderBase> *decoder) {
+status_t NuPlayer::instantiateDecoder(
+ bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange) {
// The audio decoder could be cleared by tear down. If still in shut down
// process, no need to create a new audio decoder.
if (*decoder != NULL || (audio && mFlushingAudio == SHUT_DOWN)) {
@@ -1605,7 +1608,9 @@
++mAudioDecoderGeneration;
notify->setInt32("generation", mAudioDecoderGeneration);
- determineAudioModeChange();
+ if (checkAudioModeChange) {
+ determineAudioModeChange();
+ }
if (mOffloadAudio) {
mSource->setOffloadAudio(true /* offload */);
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.h b/media/libmediaplayerservice/nuplayer/NuPlayer.h
index a55aa5f..369590b 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.h
@@ -234,10 +234,11 @@
void tryOpenAudioSinkForOffload(const sp<AMessage> &format, bool hasVideo);
void closeAudioSink();
void restartAudio(
- int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder);
+ int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder);
void determineAudioModeChange();
- status_t instantiateDecoder(bool audio, sp<DecoderBase> *decoder);
+ status_t instantiateDecoder(
+ bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange = true);
status_t onInstantiateSecureDecoders();
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
index 0e6a6e6..cbb9d95 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
@@ -647,7 +647,10 @@
case kWhatAudioTearDown:
{
- onAudioTearDown(kDueToError);
+ int32_t reason;
+ CHECK(msg->findInt32("reason", &reason));
+
+ onAudioTearDown((AudioTearDownReason)reason);
break;
}
@@ -741,7 +744,7 @@
case MediaPlayerBase::AudioSink::CB_EVENT_TEAR_DOWN:
{
ALOGV("AudioSink::CB_EVENT_TEAR_DOWN");
- me->notifyAudioTearDown();
+ me->notifyAudioTearDown(kDueToError);
break;
}
}
@@ -946,7 +949,7 @@
ALOGE("AudioSink write error(%zd) when writing %zu bytes", written, copy);
// This can only happen when AudioSink was opened with doNotReconnect flag set to
// true, in which case the NuPlayer will handle the reconnect.
- notifyAudioTearDown();
+ notifyAudioTearDown(kDueToError);
}
break;
}
@@ -1299,8 +1302,10 @@
notify->post(delayUs);
}
-void NuPlayer::Renderer::notifyAudioTearDown() {
- (new AMessage(kWhatAudioTearDown, this))->post();
+void NuPlayer::Renderer::notifyAudioTearDown(AudioTearDownReason reason) {
+ sp<AMessage> msg = new AMessage(kWhatAudioTearDown, this);
+ msg->setInt32("reason", reason);
+ msg->post();
}
void NuPlayer::Renderer::onQueueBuffer(const sp<AMessage> &msg) {
@@ -1630,7 +1635,7 @@
status_t err = mAudioSink->start();
if (err != OK) {
ALOGE("cannot start AudioSink err %d", err);
- notifyAudioTearDown();
+ notifyAudioTearDown(kDueToError);
}
}
@@ -1823,6 +1828,9 @@
onDisableOffloadAudio();
mCurrentOffloadInfo = AUDIO_INFO_INITIALIZER;
ALOGV("openAudioSink: offload failed");
+ if (offloadOnly) {
+ notifyAudioTearDown(kForceNonOffload);
+ }
} else {
mUseAudioCallback = true; // offload mode transfers data through callback
++mAudioDrainGeneration; // discard pending kWhatDrainAudioQueue message.
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h
index c3ce511..004e21c 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.h
@@ -92,8 +92,9 @@
};
enum AudioTearDownReason {
- kDueToError = 0,
+ kDueToError = 0, // Could restart with either offload or non-offload.
kDueToTimeout,
+ kForceNonOffload, // Restart only with non-offload.
};
protected:
@@ -262,7 +263,7 @@
void notifyPosition();
void notifyVideoLateBy(int64_t lateByUs);
void notifyVideoRenderingStart();
- void notifyAudioTearDown();
+ void notifyAudioTearDown(AudioTearDownReason reason);
void flushQueue(List<QueueEntry> *queue);
bool dropBufferIfStale(bool audio, const sp<AMessage> &msg);
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index d6a9f53..aebe479 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -3945,15 +3945,14 @@
h264type.eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(profile);
h264type.eLevel = static_cast<OMX_VIDEO_AVCLEVELTYPE>(level);
- }
-
- // XXX
- if (h264type.eProfile != OMX_VIDEO_AVCProfileBaseline) {
- ALOGW("Use baseline profile instead of %d for AVC recording",
- h264type.eProfile);
+ } else {
+ // Use baseline profile for AVC recording if profile is not specified.
h264type.eProfile = OMX_VIDEO_AVCProfileBaseline;
}
+ ALOGI("setupAVCEncoderParameters with [profile: %s] [level: %s]",
+ asString(h264type.eProfile), asString(h264type.eLevel));
+
if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline) {
h264type.nSliceHeaderSpacing = 0;
h264type.bUseHadamard = OMX_TRUE;
@@ -3971,6 +3970,23 @@
h264type.bDirect8x8Inference = OMX_FALSE;
h264type.bDirectSpatialTemporal = OMX_FALSE;
h264type.nCabacInitIdc = 0;
+ } else if (h264type.eProfile == OMX_VIDEO_AVCProfileMain ||
+ h264type.eProfile == OMX_VIDEO_AVCProfileHigh) {
+ h264type.nSliceHeaderSpacing = 0;
+ h264type.bUseHadamard = OMX_TRUE;
+ h264type.nRefFrames = 2;
+ h264type.nBFrames = 1;
+ h264type.nPFrames = setPFramesSpacing(iFrameInterval, frameRate);
+ h264type.nAllowedPictureTypes =
+ OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP | OMX_VIDEO_PictureTypeB;
+ h264type.nRefIdx10ActiveMinus1 = 0;
+ h264type.nRefIdx11ActiveMinus1 = 0;
+ h264type.bEntropyCodingCABAC = OMX_TRUE;
+ h264type.bWeightedPPrediction = OMX_TRUE;
+ h264type.bconstIpred = OMX_TRUE;
+ h264type.bDirect8x8Inference = OMX_TRUE;
+ h264type.bDirectSpatialTemporal = OMX_TRUE;
+ h264type.nCabacInitIdc = 1;
}
if (h264type.nBFrames != 0) {
diff --git a/media/libstagefright/MPEG4Writer.cpp b/media/libstagefright/MPEG4Writer.cpp
index 58bfa67..7a8f4c0 100644
--- a/media/libstagefright/MPEG4Writer.cpp
+++ b/media/libstagefright/MPEG4Writer.cpp
@@ -2550,8 +2550,8 @@
((timestampUs * mTimeScale + 500000LL) / 1000000LL -
(lastTimestampUs * mTimeScale + 500000LL) / 1000000LL);
if (currDurationTicks < 0ll) {
- ALOGE("timestampUs %" PRId64 " < lastTimestampUs %" PRId64 " for %s track",
- timestampUs, lastTimestampUs, trackName);
+ ALOGE("do not support out of order frames (timestamp: %lld < last: %lld for %s track",
+ (long long)timestampUs, (long long)lastTimestampUs, trackName);
copy->release();
mSource->stop();
return UNKNOWN_ERROR;
diff --git a/media/libstagefright/codecs/amrwbenc/src/voAMRWBEnc.c b/media/libstagefright/codecs/amrwbenc/src/voAMRWBEnc.c
index 4cafb01..3bdf93a 100644
--- a/media/libstagefright/codecs/amrwbenc/src/voAMRWBEnc.c
+++ b/media/libstagefright/codecs/amrwbenc/src/voAMRWBEnc.c
@@ -1301,10 +1301,10 @@
for (i = 0; i < L_SUBFR; i++)
{
- L_tmp = (code2[i] * gain_code)<<1;
- L_tmp = (L_tmp << 5);
- L_tmp += (exc2[i] * gain_pit)<<1;
- L_tmp = (L_tmp << 1);
+ L_tmp = L_mult(code2[i], gain_code);
+ L_tmp = L_shl(L_tmp, 5);
+ L_tmp = L_add(L_tmp, L_mult(exc2[i], gain_pit));
+ L_tmp = L_shl(L_tmp, 1);
exc2[i] = voround(L_tmp);
}
diff --git a/media/libstagefright/codecs/avcdec/SoftAVCDec.cpp b/media/libstagefright/codecs/avcdec/SoftAVCDec.cpp
index ae0741d..1e64b49 100644
--- a/media/libstagefright/codecs/avcdec/SoftAVCDec.cpp
+++ b/media/libstagefright/codecs/avcdec/SoftAVCDec.cpp
@@ -381,7 +381,7 @@
resetPlugin();
}
-void SoftAVC::setDecodeArgs(
+bool SoftAVC::setDecodeArgs(
ivd_video_decode_ip_t *ps_dec_ip,
ivd_video_decode_op_t *ps_dec_op,
OMX_BUFFERHEADERTYPE *inHeader,
@@ -389,7 +389,6 @@
size_t timeStampIx) {
size_t sizeY = outputBufferWidth() * outputBufferHeight();
size_t sizeUV;
- uint8_t *pBuf;
ps_dec_ip->u4_size = sizeof(ivd_video_decode_ip_t);
ps_dec_op->u4_size = sizeof(ivd_video_decode_op_t);
@@ -409,22 +408,28 @@
ps_dec_ip->u4_num_Bytes = 0;
}
- if (outHeader) {
- pBuf = outHeader->pBuffer;
- } else {
- pBuf = mFlushOutBuffer;
- }
-
sizeUV = sizeY / 4;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[0] = sizeY;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[1] = sizeUV;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[2] = sizeUV;
+ uint8_t *pBuf;
+ if (outHeader) {
+ if (outHeader->nAllocLen < sizeY + (sizeUV * 2)) {
+ android_errorWriteLog(0x534e4554, "27833616");
+ return false;
+ }
+ pBuf = outHeader->pBuffer;
+ } else {
+ // mFlushOutBuffer always has the right size.
+ pBuf = mFlushOutBuffer;
+ }
+
ps_dec_ip->s_out_buffer.pu1_bufs[0] = pBuf;
ps_dec_ip->s_out_buffer.pu1_bufs[1] = pBuf + sizeY;
ps_dec_ip->s_out_buffer.pu1_bufs[2] = pBuf + sizeY + sizeUV;
ps_dec_ip->s_out_buffer.u4_num_bufs = 3;
- return;
+ return true;
}
void SoftAVC::onPortFlushCompleted(OMX_U32 portIndex) {
/* Once the output buffers are flushed, ignore any buffers that are held in decoder */
@@ -573,7 +578,12 @@
WORD32 timeDelay, timeTaken;
size_t sizeY, sizeUV;
- setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx);
+ if (!setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx)) {
+ ALOGE("Decoder arg setup failed");
+ notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
+ mSignalledError = true;
+ return;
+ }
// If input dump is enabled, then write to file
DUMP_TO_FILE(mInFile, s_dec_ip.pv_stream_buffer, s_dec_ip.u4_num_Bytes);
diff --git a/media/libstagefright/codecs/avcdec/SoftAVCDec.h b/media/libstagefright/codecs/avcdec/SoftAVCDec.h
index 9dcabb4..c710c76 100644
--- a/media/libstagefright/codecs/avcdec/SoftAVCDec.h
+++ b/media/libstagefright/codecs/avcdec/SoftAVCDec.h
@@ -109,7 +109,7 @@
status_t resetPlugin();
- void setDecodeArgs(
+ bool setDecodeArgs(
ivd_video_decode_ip_t *ps_dec_ip,
ivd_video_decode_op_t *ps_dec_op,
OMX_BUFFERHEADERTYPE *inHeader,
diff --git a/media/libstagefright/codecs/hevcdec/SoftHEVC.cpp b/media/libstagefright/codecs/hevcdec/SoftHEVC.cpp
index 4aa23c1..7df6156 100644
--- a/media/libstagefright/codecs/hevcdec/SoftHEVC.cpp
+++ b/media/libstagefright/codecs/hevcdec/SoftHEVC.cpp
@@ -343,14 +343,13 @@
resetPlugin();
}
-void SoftHEVC::setDecodeArgs(ivd_video_decode_ip_t *ps_dec_ip,
+bool SoftHEVC::setDecodeArgs(ivd_video_decode_ip_t *ps_dec_ip,
ivd_video_decode_op_t *ps_dec_op,
OMX_BUFFERHEADERTYPE *inHeader,
OMX_BUFFERHEADERTYPE *outHeader,
size_t timeStampIx) {
size_t sizeY = outputBufferWidth() * outputBufferHeight();
size_t sizeUV;
- uint8_t *pBuf;
ps_dec_ip->u4_size = sizeof(ivd_video_decode_ip_t);
ps_dec_op->u4_size = sizeof(ivd_video_decode_op_t);
@@ -370,22 +369,28 @@
ps_dec_ip->u4_num_Bytes = 0;
}
- if (outHeader) {
- pBuf = outHeader->pBuffer;
- } else {
- pBuf = mFlushOutBuffer;
- }
-
sizeUV = sizeY / 4;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[0] = sizeY;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[1] = sizeUV;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[2] = sizeUV;
+ uint8_t *pBuf;
+ if (outHeader) {
+ if (outHeader->nAllocLen < sizeY + (sizeUV * 2)) {
+ android_errorWriteLog(0x534e4554, "27833616");
+ return false;
+ }
+ pBuf = outHeader->pBuffer;
+ } else {
+ // mFlushOutBuffer always has the right size.
+ pBuf = mFlushOutBuffer;
+ }
+
ps_dec_ip->s_out_buffer.pu1_bufs[0] = pBuf;
ps_dec_ip->s_out_buffer.pu1_bufs[1] = pBuf + sizeY;
ps_dec_ip->s_out_buffer.pu1_bufs[2] = pBuf + sizeY + sizeUV;
ps_dec_ip->s_out_buffer.u4_num_bufs = 3;
- return;
+ return true;
}
void SoftHEVC::onPortFlushCompleted(OMX_U32 portIndex) {
/* Once the output buffers are flushed, ignore any buffers that are held in decoder */
@@ -520,7 +525,12 @@
WORD32 timeDelay, timeTaken;
size_t sizeY, sizeUV;
- setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx);
+ if (!setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx)) {
+ ALOGE("Decoder arg setup failed");
+ notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
+ mSignalledError = true;
+ return;
+ }
GETTIME(&mTimeStart, NULL);
/* Compute time elapsed between end of previous decode()
diff --git a/media/libstagefright/codecs/hevcdec/SoftHEVC.h b/media/libstagefright/codecs/hevcdec/SoftHEVC.h
index 21bb99e..943edfd 100644
--- a/media/libstagefright/codecs/hevcdec/SoftHEVC.h
+++ b/media/libstagefright/codecs/hevcdec/SoftHEVC.h
@@ -106,7 +106,7 @@
status_t resetDecoder();
status_t resetPlugin();
- void setDecodeArgs(ivd_video_decode_ip_t *ps_dec_ip,
+ bool setDecodeArgs(ivd_video_decode_ip_t *ps_dec_ip,
ivd_video_decode_op_t *ps_dec_op,
OMX_BUFFERHEADERTYPE *inHeader,
OMX_BUFFERHEADERTYPE *outHeader,
diff --git a/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.cpp b/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.cpp
index 4307c4e..8283ab5 100644
--- a/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.cpp
+++ b/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.cpp
@@ -466,7 +466,7 @@
return ret;
}
-void SoftMPEG2::setDecodeArgs(
+bool SoftMPEG2::setDecodeArgs(
ivd_video_decode_ip_t *ps_dec_ip,
ivd_video_decode_op_t *ps_dec_op,
OMX_BUFFERHEADERTYPE *inHeader,
@@ -474,7 +474,6 @@
size_t timeStampIx) {
size_t sizeY = outputBufferWidth() * outputBufferHeight();
size_t sizeUV;
- uint8_t *pBuf;
ps_dec_ip->u4_size = sizeof(ivd_video_decode_ip_t);
ps_dec_op->u4_size = sizeof(ivd_video_decode_op_t);
@@ -494,22 +493,28 @@
ps_dec_ip->u4_num_Bytes = 0;
}
- if (outHeader) {
- pBuf = outHeader->pBuffer;
- } else {
- pBuf = mFlushOutBuffer;
- }
-
sizeUV = sizeY / 4;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[0] = sizeY;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[1] = sizeUV;
ps_dec_ip->s_out_buffer.u4_min_out_buf_size[2] = sizeUV;
+ uint8_t *pBuf;
+ if (outHeader) {
+ if (outHeader->nAllocLen < sizeY + (sizeUV * 2)) {
+ android_errorWriteLog(0x534e4554, "27833616");
+ return false;
+ }
+ pBuf = outHeader->pBuffer;
+ } else {
+ // mFlushOutBuffer always has the right size.
+ pBuf = mFlushOutBuffer;
+ }
+
ps_dec_ip->s_out_buffer.pu1_bufs[0] = pBuf;
ps_dec_ip->s_out_buffer.pu1_bufs[1] = pBuf + sizeY;
ps_dec_ip->s_out_buffer.pu1_bufs[2] = pBuf + sizeY + sizeUV;
ps_dec_ip->s_out_buffer.u4_num_bufs = 3;
- return;
+ return true;
}
void SoftMPEG2::onPortFlushCompleted(OMX_U32 portIndex) {
/* Once the output buffers are flushed, ignore any buffers that are held in decoder */
@@ -622,7 +627,11 @@
WORD32 timeDelay, timeTaken;
size_t sizeY, sizeUV;
- setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx);
+ if (!setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx)) {
+ ALOGE("Decoder arg setup failed");
+ notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
+ return;
+ }
// If input dump is enabled, then write to file
DUMP_TO_FILE(mInFile, s_dec_ip.pv_stream_buffer, s_dec_ip.u4_num_Bytes);
@@ -665,9 +674,9 @@
CHECK_EQ(reInitDecoder(), (status_t)OK);
- setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx);
-
- ivdec_api_function(mCodecCtx, (void *)&s_dec_ip, (void *)&s_dec_op);
+ if (setDecodeArgs(&s_dec_ip, &s_dec_op, inHeader, outHeader, timeStampIx)) {
+ ivdec_api_function(mCodecCtx, (void *)&s_dec_ip, (void *)&s_dec_op);
+ }
return;
}
diff --git a/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.h b/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.h
index a625e08..f48b70b 100644
--- a/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.h
+++ b/media/libstagefright/codecs/mpeg2dec/SoftMPEG2.h
@@ -117,7 +117,7 @@
status_t resetPlugin();
status_t reInitDecoder();
- void setDecodeArgs(
+ bool setDecodeArgs(
ivd_video_decode_ip_t *ps_dec_ip,
ivd_video_decode_op_t *ps_dec_op,
OMX_BUFFERHEADERTYPE *inHeader,
diff --git a/media/libstagefright/codecs/opus/dec/SoftOpus.cpp b/media/libstagefright/codecs/opus/dec/SoftOpus.cpp
index 2afa0ed..2e44ed7 100644
--- a/media/libstagefright/codecs/opus/dec/SoftOpus.cpp
+++ b/media/libstagefright/codecs/opus/dec/SoftOpus.cpp
@@ -458,12 +458,17 @@
const uint8_t *data = inHeader->pBuffer + inHeader->nOffset;
const uint32_t size = inHeader->nFilledLen;
+ size_t frameSize = kMaxOpusOutputPacketSizeSamples;
+ if (frameSize > outHeader->nAllocLen / sizeof(int16_t) / mHeader->channels) {
+ frameSize = outHeader->nAllocLen / sizeof(int16_t) / mHeader->channels;
+ android_errorWriteLog(0x534e4554, "27833616");
+ }
int numFrames = opus_multistream_decode(mDecoder,
data,
size,
(int16_t *)outHeader->pBuffer,
- kMaxOpusOutputPacketSizeSamples,
+ frameSize,
0);
if (numFrames < 0) {
ALOGE("opus_multistream_decode returned %d", numFrames);
diff --git a/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp b/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
index 6a689c4..f648bb3 100644
--- a/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
+++ b/media/libstagefright/codecs/vorbis/dec/SoftVorbis.cpp
@@ -274,6 +274,13 @@
const uint8_t *data = header->pBuffer + header->nOffset;
size_t size = header->nFilledLen;
+ if (size < 7) {
+ ALOGE("Too small input buffer: %zu bytes", size);
+ android_errorWriteLog(0x534e4554, "27833616");
+ notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
+ mSignalledError = true;
+ return;
+ }
ogg_buffer buf;
ogg_reference ref;
@@ -395,9 +402,14 @@
ALOGW("vorbis_dsp_synthesis returned %d", err);
#endif
} else {
+ size_t numSamplesPerBuffer = kMaxNumSamplesPerBuffer;
+ if (numSamplesPerBuffer > outHeader->nAllocLen / sizeof(int16_t)) {
+ numSamplesPerBuffer = outHeader->nAllocLen / sizeof(int16_t);
+ android_errorWriteLog(0x534e4554, "27833616");
+ }
numFrames = vorbis_dsp_pcmout(
mState, (int16_t *)outHeader->pBuffer,
- (kMaxNumSamplesPerBuffer / mVi->channels));
+ (numSamplesPerBuffer / mVi->channels));
if (numFrames < 0) {
ALOGE("vorbis_dsp_pcmout returned %d", numFrames);
diff --git a/media/libstagefright/foundation/ABitReader.cpp b/media/libstagefright/foundation/ABitReader.cpp
index beb5cc0..1582b67 100644
--- a/media/libstagefright/foundation/ABitReader.cpp
+++ b/media/libstagefright/foundation/ABitReader.cpp
@@ -114,7 +114,7 @@
return false;
}
- ssize_t numBitsRemaining = n - mNumBitsLeft;
+ ssize_t numBitsRemaining = (ssize_t)n - (ssize_t)mNumBitsLeft;
size_t size = mSize;
const uint8_t *data = mData;
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 016c25e..e5c7177 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -1540,10 +1540,10 @@
audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
{
if (name == NULL) {
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
if (!settingsAllowed()) {
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
Mutex::Autolock _l(mLock);
return loadHwModule_l(name);
@@ -1564,7 +1564,7 @@
int rc = load_audio_interface(name, &dev);
if (rc) {
ALOGE("loadHwModule() error %d loading module %s", rc, name);
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
mHardwareStatus = AUDIO_HW_INIT;
@@ -1572,7 +1572,7 @@
mHardwareStatus = AUDIO_HW_IDLE;
if (rc) {
ALOGE("loadHwModule() init check error %d for module %s", rc, name);
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
// Check and cache this HAL's level of support for master mute and master
@@ -1619,7 +1619,7 @@
mHardwareStatus = AUDIO_HW_IDLE;
}
- audio_module_handle_t handle = nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
+ audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags));
ALOGI("loadHwModule() Loaded %s audio interface from %s (%s) handle %d",
diff --git a/services/audioflinger/PatchPanel.cpp b/services/audioflinger/PatchPanel.cpp
index bf6763f..d85ac87 100644
--- a/services/audioflinger/PatchPanel.cpp
+++ b/services/audioflinger/PatchPanel.cpp
@@ -349,7 +349,7 @@
exit:
ALOGV("createAudioPatch() status %d", status);
if (status == NO_ERROR) {
- *handle = audioflinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_PATCH);
+ *handle = (audio_patch_handle_t) audioflinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_PATCH);
newPatch->mHandle = *handle;
newPatch->mHalHandle = halHandle;
mPatches.add(newPatch);
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 04cd91f..87374bc 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -1786,20 +1786,6 @@
// client expresses a preference for FAST, but we get the final say
if (*flags & IAudioFlinger::TRACK_FAST) {
if (
- // either of these use cases:
- (
- // use case 1: shared buffer with any frame count
- (
- (sharedBuffer != 0)
- ) ||
- // use case 2: frame count is default or at least as large as HAL
- (
- // we formerly checked for a callback handler (non-0 tid),
- // but that is no longer required for TRANSFER_OBTAIN mode
- ((frameCount == 0) ||
- (frameCount >= mFrameCount))
- )
- ) &&
// PCM data
audio_is_linear_pcm(format) &&
// TODO: extract as a data library function that checks that a computationally
@@ -1817,14 +1803,14 @@
// FIXME test that MixerThread for this fast track has a capable output HAL
// FIXME add a permission test also?
) {
- // if frameCount not specified, then it defaults to fast mixer (HAL) frame count
- if (frameCount == 0) {
+ // static tracks can have any nonzero framecount, streaming tracks check against minimum.
+ if (sharedBuffer == 0) {
// read the fast track multiplier property the first time it is needed
int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
if (ok != 0) {
ALOGE("%s pthread_once failed: %d", __func__, ok);
}
- frameCount = mFrameCount * sFastTrackMultiplier;
+ frameCount = max(frameCount, mFrameCount * sFastTrackMultiplier); // incl framecount 0
}
ALOGV("AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
frameCount, mFrameCount);
@@ -2545,6 +2531,10 @@
{
if (!mMasterMute) {
char value[PROPERTY_VALUE_MAX];
+ if (mOutDevice == AUDIO_DEVICE_OUT_REMOTE_SUBMIX) {
+ ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
+ return;
+ }
if (property_get("ro.audio.silent", value, "0") > 0) {
char *endptr;
unsigned long ul = strtoul(value, &endptr, 0);
@@ -2938,11 +2928,7 @@
break;
}
bool released = false;
- // The following works around a bug in the offload driver. Ideally we would release
- // the wake lock every time, but that causes the last offload buffer(s) to be
- // dropped while the device is on battery, so we need to hold a wake lock during
- // the drain phase.
- if (mBytesRemaining && !(mDrainSequence & 1)) {
+ if (!keepWakeLock()) {
releaseWakeLock_l();
released = true;
}
@@ -3176,20 +3162,23 @@
if ((mType == OFFLOAD) && !audio_has_proportional_frames(mFormat)) {
Mutex::Autolock _l(mLock);
if (!mSignalPending && !exitPending()) {
- // Do not sleep more than one buffer duration since last write and not
- // less than kDirectMinSleepTimeUs
+ // If more than one buffer has been written to the audio HAL since exiting
+ // standby or last flush, do not sleep more than one buffer duration
+ // since last write and not less than kDirectMinSleepTimeUs.
// Wake up if a command is received
- nsecs_t now = systemTime();
- uint32_t deltaUs = (uint32_t)((now - mLastWriteTime) / 1000);
uint32_t timeoutUs = mSleepTimeUs;
- if (timeoutUs + deltaUs > mBufferDurationUs) {
- if (mBufferDurationUs > deltaUs) {
- timeoutUs = mBufferDurationUs - deltaUs;
- if (timeoutUs < kDirectMinSleepTimeUs) {
+ if (mBytesWritten >= (int64_t) mBufferSize) {
+ nsecs_t now = systemTime();
+ uint32_t deltaUs = (uint32_t)((now - mLastWriteTime) / 1000);
+ if (timeoutUs + deltaUs > mBufferDurationUs) {
+ if (mBufferDurationUs > deltaUs) {
+ timeoutUs = mBufferDurationUs - deltaUs;
+ if (timeoutUs < kDirectMinSleepTimeUs) {
+ timeoutUs = kDirectMinSleepTimeUs;
+ }
+ } else {
timeoutUs = kDirectMinSleepTimeUs;
}
- } else {
- timeoutUs = kDirectMinSleepTimeUs;
}
}
mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)timeoutUs));
@@ -5179,10 +5168,11 @@
AudioStreamOut* output, audio_io_handle_t id, uint32_t device, bool systemReady,
uint32_t bitRate)
: DirectOutputThread(audioFlinger, output, id, device, OFFLOAD, systemReady, bitRate),
- mPausedBytesRemaining(0)
+ mPausedWriteLength(0), mPausedBytesRemaining(0), mKeepWakeLock(true)
{
//FIXME: mStandby should be set to true by ThreadBase constructor
mStandby = true;
+ mKeepWakeLock = property_get_bool("ro.audio.offload_wakelock", true /* default_value */);
}
void AudioFlinger::OffloadThread::threadLoop_exit()
@@ -5431,6 +5421,8 @@
mBytesRemaining = 0;
mPausedWriteLength = 0;
mPausedBytesRemaining = 0;
+ // reset bytes written count to reflect that DSP buffers are empty after flush.
+ mBytesWritten = 0;
if (mUseAsyncWrite) {
// discard any pending drain or write ack by incrementing sequence
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index 761fc71..cf896e0 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -527,6 +527,8 @@
// ThreadBase virtuals
virtual void preExit();
+ virtual bool keepWakeLock() const { return true; }
+
public:
virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
@@ -996,9 +998,12 @@
virtual bool waitingAsyncCallback();
virtual bool waitingAsyncCallback_l();
+ virtual bool keepWakeLock() const { return mKeepWakeLock; }
+
private:
size_t mPausedWriteLength; // length in bytes of write interrupted by pause
size_t mPausedBytesRemaining; // bytes still waiting in mixbuffer after resume
+ bool mKeepWakeLock; // keep wake lock while waiting for write callback
};
class AsyncCallbackThread : public Thread {
diff --git a/services/audiopolicy/common/managerdefinitions/include/AudioSourceDescriptor.h b/services/audiopolicy/common/managerdefinitions/include/AudioSourceDescriptor.h
index 7e1e24d..4ab7cf0 100644
--- a/services/audiopolicy/common/managerdefinitions/include/AudioSourceDescriptor.h
+++ b/services/audiopolicy/common/managerdefinitions/include/AudioSourceDescriptor.h
@@ -50,7 +50,7 @@
};
class AudioSourceCollection :
- public DefaultKeyedVector< audio_patch_handle_t, sp<AudioSourceDescriptor> >
+ public DefaultKeyedVector< audio_io_handle_t, sp<AudioSourceDescriptor> >
{
public:
status_t dump(int fd) const;
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
index d4992b0..6dacaa4 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
@@ -29,7 +29,7 @@
AudioInputDescriptor::AudioInputDescriptor(const sp<IOProfile>& profile)
: mIoHandle(0),
mDevice(AUDIO_DEVICE_NONE), mPolicyMix(NULL),
- mProfile(profile), mPatchHandle(0), mId(0)
+ mProfile(profile), mPatchHandle(AUDIO_PATCH_HANDLE_NONE), mId(0)
{
if (profile != NULL) {
profile->pickAudioProfile(mSamplingRate, mChannelMask, mFormat);
@@ -48,7 +48,7 @@
audio_module_handle_t AudioInputDescriptor::getModuleHandle() const
{
if (mProfile == 0) {
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
return mProfile->getModuleHandle();
}
@@ -157,7 +157,7 @@
return mSessions.removeSession(session);
}
-audio_port_handle_t AudioInputDescriptor::getPatchHandle() const
+audio_patch_handle_t AudioInputDescriptor::getPatchHandle() const
{
return mPatchHandle;
}
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
index c5fee50..79bbc54 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp
@@ -34,7 +34,7 @@
AudioOutputDescriptor::AudioOutputDescriptor(const sp<AudioPort>& port,
AudioPolicyClientInterface *clientInterface)
: mPort(port), mDevice(AUDIO_DEVICE_NONE),
- mClientInterface(clientInterface), mPatchHandle(0), mId(0)
+ mClientInterface(clientInterface), mPatchHandle(AUDIO_PATCH_HANDLE_NONE), mId(0)
{
// clear usage count for all stream types
for (int i = 0; i < AUDIO_STREAM_CNT; i++) {
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp
index 9c28e8f..b8c0550 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioPatch.cpp
@@ -31,7 +31,7 @@
mHandle(static_cast<audio_patch_handle_t>(android_atomic_inc(&mNextUniqueId))),
mPatch(*patch),
mUid(uid),
- mAfPatchHandle(0)
+ mAfPatchHandle(AUDIO_PATCH_HANDLE_NONE)
{
}
diff --git a/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp b/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
index 19b179e..17ed537 100644
--- a/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp
@@ -45,7 +45,7 @@
audio_module_handle_t AudioPort::getModuleHandle() const
{
if (mModule == 0) {
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
return mModule->mHandle;
}
diff --git a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
index cf7c8fc..fe03429 100644
--- a/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/DeviceDescriptor.cpp
@@ -245,7 +245,7 @@
// without the test?
// This has been demonstrated to NOT be true (at start up)
// ALOG_ASSERT(mModule != NULL);
- dstConfig->ext.device.hw_module = mModule != 0 ? mModule->mHandle : AUDIO_IO_HANDLE_NONE;
+ dstConfig->ext.device.hw_module = mModule != 0 ? mModule->mHandle : AUDIO_MODULE_HANDLE_NONE;
strncpy(dstConfig->ext.device.address, mAddress.string(), AUDIO_DEVICE_MAX_ADDRESS_LEN);
}
diff --git a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
index b7c7879..2d67bd2 100644
--- a/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
+++ b/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
@@ -27,7 +27,7 @@
HwModule::HwModule(const char *name, uint32_t halVersion)
: mName(String8(name)),
- mHandle(0),
+ mHandle(AUDIO_MODULE_HANDLE_NONE),
mHalVersion(halVersion)
{
}
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index ae8cf15..35c868e 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -2412,7 +2412,7 @@
return INVALID_OPERATION;
}
} else {
- *handle = 0;
+ *handle = AUDIO_PATCH_HANDLE_NONE;
}
if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
@@ -3678,7 +3678,7 @@
mpClientInterface->setParameters(output, String8(param));
free(param);
}
- updateAudioProfiles(output, profile->getAudioProfiles());
+ updateAudioProfiles(device, output, profile->getAudioProfiles());
if (!profile->hasValidAudioProfile()) {
ALOGW("checkOutputsForDevice() missing param");
mpClientInterface->closeOutput(output);
@@ -3916,7 +3916,7 @@
mpClientInterface->setParameters(input, String8(param));
free(param);
}
- updateAudioProfiles(input, profile->getAudioProfiles());
+ updateAudioProfiles(device, input, profile->getAudioProfiles());
if (!profile->hasValidAudioProfile()) {
ALOGW("checkInputsForDevice() direct input missing param");
mpClientInterface->closeInput(input);
@@ -4692,7 +4692,7 @@
sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, delayMs);
ALOGV("resetOutputDevice() releaseAudioPatch returned %d", status);
- outputDesc->setPatchHandle(0);
+ outputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
removeAudioPatch(patchDesc->mHandle);
nextAudioPortGeneration();
mpClientInterface->onAudioPatchListUpdate();
@@ -4778,7 +4778,7 @@
sp< AudioPatch> patchDesc = mAudioPatches.valueAt(index);
status_t status = mpClientInterface->releaseAudioPatch(patchDesc->mAfPatchHandle, 0);
ALOGV("resetInputDevice() releaseAudioPatch returned %d", status);
- inputDesc->setPatchHandle(0);
+ inputDesc->setPatchHandle(AUDIO_PATCH_HANDLE_NONE);
removeAudioPatch(patchDesc->mHandle);
nextAudioPortGeneration();
mpClientInterface->onAudioPatchListUpdate();
@@ -4936,7 +4936,7 @@
voiceVolume = 1.0;
}
- if (voiceVolume != mLastVoiceVolume && outputDesc == mPrimaryOutput) {
+ if (voiceVolume != mLastVoiceVolume) {
mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
mLastVoiceVolume = voiceVolume;
}
@@ -5210,15 +5210,14 @@
}
// Modify the list of surround sound formats supported.
-void AudioPolicyManager::filterSurroundFormats(FormatVector &formats) {
- // TODO Change the ALOGIs to ALOGVs in this function after the feature is verified.
-
+void AudioPolicyManager::filterSurroundFormats(FormatVector *formatsPtr) {
+ FormatVector &formats = *formatsPtr;
// TODO Set this based on Config properties.
const bool alwaysForceAC3 = true;
audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
- ALOGI("%s: forced use = %d", __FUNCTION__, forceUse);
+ ALOGD("%s: forced use = %d", __FUNCTION__, forceUse);
// Analyze original support for various formats.
bool supportsAC3 = false;
@@ -5226,7 +5225,6 @@
bool supportsIEC61937 = false;
for (size_t formatIndex = 0; formatIndex < formats.size(); formatIndex++) {
audio_format_t format = formats[formatIndex];
- ALOGI("%s: original formats: 0x%08x", __FUNCTION__, format);
switch (format) {
case AUDIO_FORMAT_AC3:
supportsAC3 = true;
@@ -5243,8 +5241,6 @@
break;
}
}
- ALOGI("%s: original, supportsAC3 = %d, supportsOtherSurround = %d, supportsIEC61937 = %d",
- __FUNCTION__, supportsAC3, supportsOtherSurround, supportsIEC61937);
// Modify formats based on surround preferences.
// If NEVER, remove support for surround formats.
@@ -5259,7 +5255,6 @@
case AUDIO_FORMAT_DTS:
case AUDIO_FORMAT_DTS_HD:
case AUDIO_FORMAT_IEC61937:
- ALOGI("%s: remove format 0x%08x", __FUNCTION__, format);
formats.removeAt(formatIndex);
break;
default:
@@ -5297,25 +5292,56 @@
supportsIEC61937 = true;
}
}
- // Just for debugging.
- for (size_t formatIndex = 0; formatIndex < formats.size(); formatIndex++) {
- audio_format_t format = formats[formatIndex];
- ALOGI("%s: final formats: 0x%08x", __FUNCTION__, format);
- }
- ALOGI("%s: final, supportsAC3 = %d, supportsOtherSurround = %d, supportsIEC61937 = %d",
- __FUNCTION__, supportsAC3, supportsOtherSurround, supportsIEC61937);
}
-void AudioPolicyManager::updateAudioProfiles(audio_io_handle_t ioHandle,
+// Modify the list of channel masks supported.
+void AudioPolicyManager::filterSurroundChannelMasks(ChannelsVector *channelMasksPtr) {
+ ChannelsVector &channelMasks = *channelMasksPtr;
+ audio_policy_forced_cfg_t forceUse = mEngine->getForceUse(
+ AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND);
+
+ // If NEVER, then remove support for channelMasks > stereo.
+ if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER) {
+ for (size_t maskIndex = 0; maskIndex < channelMasks.size(); ) {
+ audio_channel_mask_t channelMask = channelMasks[maskIndex];
+ if (channelMask & ~AUDIO_CHANNEL_OUT_STEREO) {
+ ALOGI("%s: force NEVER, so remove channelMask 0x%08x", __FUNCTION__, channelMask);
+ channelMasks.removeAt(maskIndex);
+ } else {
+ maskIndex++;
+ }
+ }
+ // If ALWAYS, then make sure we at least support 5.1
+ } else if (forceUse == AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS) {
+ bool supports5dot1 = false;
+ // Are there any channel masks that can be considered "surround"?
+ for (size_t maskIndex = 0; maskIndex < channelMasks.size(); maskIndex++) {
+ audio_channel_mask_t channelMask = channelMasks[maskIndex];
+ if ((channelMask & AUDIO_CHANNEL_OUT_5POINT1) == AUDIO_CHANNEL_OUT_5POINT1) {
+ supports5dot1 = true;
+ break;
+ }
+ }
+ // If not then add 5.1 support.
+ if (!supports5dot1) {
+ channelMasks.add(AUDIO_CHANNEL_OUT_5POINT1);
+ ALOGI("%s: force ALWAYS, so adding channelMask for 5.1 surround", __FUNCTION__);
+ }
+ }
+}
+
+void AudioPolicyManager::updateAudioProfiles(audio_devices_t device,
+ audio_io_handle_t ioHandle,
AudioProfileVector &profiles)
{
String8 reply;
char *value;
+
// Format MUST be checked first to update the list of AudioProfile
if (profiles.hasDynamicFormat()) {
reply = mpClientInterface->getParameters(ioHandle,
String8(AUDIO_PARAMETER_STREAM_SUP_FORMATS));
- ALOGI("%s: supported formats %s", __FUNCTION__, reply.string());
+ ALOGV("%s: supported formats %s", __FUNCTION__, reply.string());
AudioParameter repliedParameters(reply);
if (repliedParameters.get(
String8(AUDIO_PARAMETER_STREAM_SUP_FORMATS), reply) != NO_ERROR) {
@@ -5323,7 +5349,9 @@
return;
}
FormatVector formats = formatsFromString(reply.string());
- filterSurroundFormats(formats);
+ if (device == AUDIO_DEVICE_OUT_HDMI) {
+ filterSurroundFormats(&formats);
+ }
profiles.setFormats(formats);
}
const FormatVector &supportedFormats = profiles.getSupportedFormats();
@@ -5355,6 +5383,9 @@
if (repliedParameters.get(
String8(AUDIO_PARAMETER_STREAM_SUP_CHANNELS), reply) == NO_ERROR) {
channelMasks = channelMasksFromString(reply.string());
+ if (device == AUDIO_DEVICE_OUT_HDMI) {
+ filterSurroundChannelMasks(&channelMasks);
+ }
}
}
profiles.addProfileFromHal(new AudioProfile(format, channelMasks, samplingRates));
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index 1ef896f..0420679 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -586,10 +586,12 @@
AudioPolicyManagerInterface *mEngine;
private:
// Add or remove AC3 DTS encodings based on user preferences.
- void filterSurroundFormats(FormatVector &formats);
+ void filterSurroundFormats(FormatVector *formatsPtr);
+ void filterSurroundChannelMasks(ChannelsVector *channelMasksPtr);
// If any, resolve any "dynamic" fields of an Audio Profiles collection
- void updateAudioProfiles(audio_io_handle_t ioHandle, AudioProfileVector &profiles);
+ void updateAudioProfiles(audio_devices_t device, audio_io_handle_t ioHandle,
+ AudioProfileVector &profiles);
// updates device caching and output for streams that can influence the
// routing of notifications
diff --git a/services/audiopolicy/service/AudioPolicyClientImpl.cpp b/services/audiopolicy/service/AudioPolicyClientImpl.cpp
index 08f9cc1..dbcc070 100644
--- a/services/audiopolicy/service/AudioPolicyClientImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyClientImpl.cpp
@@ -30,7 +30,7 @@
sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
if (af == 0) {
ALOGW("%s: could not get AudioFlinger", __func__);
- return 0;
+ return AUDIO_MODULE_HANDLE_NONE;
}
return af->loadHwModule(name);
diff --git a/services/audiopolicy/service/AudioPolicyClientImplLegacy.cpp b/services/audiopolicy/service/AudioPolicyClientImplLegacy.cpp
index 580d740..09a931f 100644
--- a/services/audiopolicy/service/AudioPolicyClientImplLegacy.cpp
+++ b/services/audiopolicy/service/AudioPolicyClientImplLegacy.cpp
@@ -111,7 +111,7 @@
uint32_t *pLatencyMs,
audio_output_flags_t flags)
{
- return open_output((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask,
+ return open_output(AUDIO_MODULE_HANDLE_NONE, pDevices, pSamplingRate, pFormat, pChannelMask,
pLatencyMs, flags, NULL);
}
@@ -219,7 +219,7 @@
audio_channel_mask_t *pChannelMask,
audio_in_acoustics_t acoustics __unused)
{
- return open_input((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask);
+ return open_input(AUDIO_MODULE_HANDLE_NONE, pDevices, pSamplingRate, pFormat, pChannelMask);
}
audio_io_handle_t aps_open_input_on_module(void *service __unused,
diff --git a/services/camera/libcameraservice/device3/Camera3InputStream.cpp b/services/camera/libcameraservice/device3/Camera3InputStream.cpp
index 7dab2e3..f781ded 100644
--- a/services/camera/libcameraservice/device3/Camera3InputStream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3InputStream.cpp
@@ -116,6 +116,7 @@
bufferFound = true;
bufferItem = tmp;
mBuffersInFlight.erase(it);
+ break;
}
}
}
diff --git a/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-arm.policy b/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-arm.policy
index cc9a580..165694c 100644
--- a/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-arm.policy
+++ b/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-arm.policy
@@ -33,6 +33,10 @@
rt_sigprocmask: 1
sched_yield: 1
ugetrlimit: 1
+geteuid32: 1
+getgid32: 1
+getegid32: 1
+getgroups32: 1
# for attaching to debuggerd on process crash
sigaction: 1
diff --git a/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-x86.policy b/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-x86.policy
index 516ca60..67976ff 100644
--- a/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-x86.policy
+++ b/services/mediaextractor/minijail/seccomp_policy/mediaextractor-seccomp-x86.policy
@@ -31,6 +31,10 @@
sched_setscheduler: 1
ugetrlimit: 1
getrlimit: 1
+geteuid32: 1
+getgid32: 1
+getegid32: 1
+getgroups32: 1
# for attaching to debuggerd on process crash
socketcall: 1
diff --git a/services/mediaresourcemanager/ResourceManagerService.cpp b/services/mediaresourcemanager/ResourceManagerService.cpp
index 64534bf..3ed0189 100644
--- a/services/mediaresourcemanager/ResourceManagerService.cpp
+++ b/services/mediaresourcemanager/ResourceManagerService.cpp
@@ -92,7 +92,7 @@
static void notifyResourceGranted(int pid, const Vector<MediaResource> &resources) {
static const char* const kServiceName = "media_resource_monitor";
- sp<IBinder> binder = defaultServiceManager()->getService(String16(kServiceName));
+ sp<IBinder> binder = defaultServiceManager()->checkService(String16(kServiceName));
if (binder != NULL) {
sp<IMediaResourceMonitor> service = interface_cast<IMediaResourceMonitor>(binder);
for (size_t i = 0; i < resources.size(); ++i) {
@@ -170,10 +170,7 @@
}
ResourceManagerService::ResourceManagerService()
- : mProcessInfo(new ProcessInfo()),
- mServiceLog(new ServiceLog()),
- mSupportsMultipleSecureCodecs(true),
- mSupportsSecureWithNonSecureCodec(true) {}
+ : ResourceManagerService(new ProcessInfo()) {}
ResourceManagerService::ResourceManagerService(sp<ProcessInfoInterface> processInfo)
: mProcessInfo(processInfo),
diff --git a/services/soundtrigger/SoundTriggerHwService.cpp b/services/soundtrigger/SoundTriggerHwService.cpp
index 66310b5..8f37bed 100644
--- a/services/soundtrigger/SoundTriggerHwService.cpp
+++ b/services/soundtrigger/SoundTriggerHwService.cpp
@@ -70,7 +70,8 @@
SOUND_TRIGGER_HARDWARE_MODULE_ID, HW_MODULE_PREFIX, strerror(-rc));
return;
}
- if (dev->common.version != SOUND_TRIGGER_DEVICE_API_VERSION_CURRENT) {
+ if (dev->common.version < SOUND_TRIGGER_DEVICE_API_VERSION_1_0 ||
+ dev->common.version > SOUND_TRIGGER_DEVICE_API_VERSION_CURRENT) {
ALOGE("wrong sound trigger hw device version %04x", dev->common.version);
return;
}
@@ -808,10 +809,20 @@
goto exit;
}
+ const bool supports_stop_all =
+ (mHwDevice->common.version >= SOUND_TRIGGER_DEVICE_API_VERSION_1_1 &&
+ mHwDevice->stop_all_recognitions);
+
+ if (supports_stop_all) {
+ mHwDevice->stop_all_recognitions(mHwDevice);
+ }
+
for (size_t i = 0; i < mModels.size(); i++) {
sp<Model> model = mModels.valueAt(i);
if (model->mState == Model::STATE_ACTIVE) {
- mHwDevice->stop_recognition(mHwDevice, model->mHandle);
+ if (!supports_stop_all) {
+ mHwDevice->stop_recognition(mHwDevice, model->mHandle);
+ }
// keep model in ACTIVE state so that event is processed by onCallbackEvent()
if (model->mType == SOUND_MODEL_TYPE_KEYPHRASE) {
struct sound_trigger_phrase_recognition_event event;