改为单个请求连拍4帧

app/src/main/cpp/camera2/ndkcamera.cpp

@@ -1182,6 +1182,7 @@ void NdkCamera::close()
 	 */
 
 	mCaptureFrames.clear();
+    mCaptureResultMap.clear();
 
 	if ((ACameraManager *)camera_manager != NULL)
 	{
@@ -1469,13 +1470,40 @@ void NdkCamera::onImageAvailable(AImageReader* reader)
 						}
 					}
 
-					ConvertYUV21ToMat(nv21, width, height,mWidth, mHeight, camera_orientation,
+                int64_t frameTs = 0;
-									  camera_facing == ACAMERA_LENS_FACING_FRONT, m_params.orientation, mOneFrame);
+                mstatus = AImage_getTimestamp(image, &frameTs);
+				AImage_delete(image);
 
-					delete[] nv21;
+				bool captureCompleted = false;
+				bool captureDispatchable = false;
+				m_locker.lock();
+				if (!frame.empty())
+				{
+					mOneFrame.push_back(std::make_pair<>(frameTs, frame));
 				}
-			}
+                if (mOneFrame.size() >= expectedTimes)
-			m_photoTaken = true;
+                {
+                    bool allExisted = true;
+                    for (auto itFrame = mOneFrame.cbegin(); itFrame != mOneFrame.cend(); ++itFrame)
+                    {
+                        if (mCaptureResultMap.find(itFrame->first) == mCaptureResultMap.cend())
+                        {
+                            allExisted = false;
+                            break;
+                        }
+                    }
+                    if (allExisted)
+                    {
+                        captureCompleted = true;
+                    }
+                }
+
+                if (captureCompleted && !mCaptureDispatched)
+				{
+					mCaptureDispatched = true;
+					captureDispatchable = true;
+				}
+				m_locker.unlock();
 
             AImage_delete(image);
 
@@ -1931,12 +1959,32 @@ void NdkCamera::onCaptureCompleted(ACameraCaptureSession* session, ACaptureReque
 		bool captureDispatchable = false;
 		size_t expectedTimes = mCaptureRequests.size() - 1;
 
+        int64_t resultTimestamp = GetTimestamp(result);
         std::shared_ptr<ACameraMetadata> captureResult(pCopy, ACameraMetadata_free);
-		if (expectedTimes == 1)
+
+		if (m_params.burstRawCapture == 0)
 		{
 			m_locker.lock();
 			mCaptureResults.push_back(captureResult);
-			captureCompleted = !mOneFrame.empty();
+            mCaptureResultMap[resultTimestamp] = captureResult;
+
+			if (mOneFrame.size() >= expectedTimes)
+            {
+                bool allExisted = true;
+                for (auto itFrame = mOneFrame.cbegin(); itFrame != mOneFrame.cend(); ++itFrame)
+                {
+                    if (mCaptureResultMap.find(itFrame->first) == mCaptureResultMap.cend())
+                    {
+                        allExisted = false;
+                        break;
+                    }
+                }
+                if (allExisted)
+                {
+                    captureCompleted = true;
+                }
+            }
+
 			if (captureCompleted && !mCaptureDispatched)
 			{
 				mCaptureDispatched = true;
@@ -1970,6 +2018,44 @@ void NdkCamera::onCaptureCompleted(ACameraCaptureSession* session, ACaptureReque
 	}
 }
 
+int64_t NdkCamera::GetTimestamp(const ACameraMetadata* result)
+{
+    ACameraMetadata_const_entry entry;
+    camera_status_t status = ACameraMetadata_getConstEntry(result, ACAMERA_SENSOR_TIMESTAMP, &entry);
+
+    if (status == ACAMERA_OK && entry.count > 0) {
+        return entry.data.i64[0];
+    }
+
+    return 0;
+}
+
+void NdkCamera::FireOneCapture(uint64_t ts)
+{
+#ifdef OUTPUT_DBG_INFO
+    if (mWidth == 1920 && mOneFrame.size() > 1)
+    {
+        std::string dt = FormatLocalDateTime("%d%02d%02d%02d%02d%02d", ts / 1000);
+        std::vector<int> params;
+        params.push_back(cv::IMWRITE_JPEG_QUALITY);
+        params.push_back(50);
+
+        for (auto it = mOneFrame.cbegin(); it != mOneFrame.cend(); ++it)
+        {
+            std::string fileName = "/sdcard/com.xypower.mpapp/tmp/" + dt;
+            size_t idx = std::distance(mOneFrame.cbegin(), it);
+            std::shared_ptr<ACameraMetadata> result = mCaptureResults[idx];
+            CAPTURE_RESULT captureResult = { 0 };
+            EnumCameraResult(result.get(), captureResult);
+
+            fileName += "_" + mCameraId + "_" + std::to_string(captureResult.aeState) + "_" + std::to_string(idx) + ".jpg";
+            cv::imwrite(fileName, it->second, params);
+        }
+    }
+#endif
+	onOneCapture(mCharacteristics, mCaptureResults.back(), mFinalLdr, ts - m_startTime, mOneFrame.back().second);
+}
+
 void NdkCamera::FireBurstCapture()
 {
     unsigned long long ts = GetMicroTimeStamp();

app/src/main/cpp/camera2/ndkcamera.h

@@ -23,6 +23,7 @@
 #include <opencv2/core/core.hpp>
 #include "Camera2Helper.h"
 #include <mutex>
+#include <map>
 #include <set>
 
 /**
@@ -192,6 +193,7 @@ public:
     }
 
     bool IsCameraAvailable(const std::string& cameraId);
+    int64_t GetTimestamp(const ACameraMetadata* result);
 
     static bool convertAImageToNv21(AImage* image, uint8_t** nv21, int32_t& width, int32_t& height);
     static void EnumCameraResult(ACameraMetadata* result, CAPTURE_RESULT& captureResult);
@@ -266,13 +268,15 @@ protected:
 
     std::shared_ptr<ACameraMetadata> mPreviewResults;
     std::vector<std::shared_ptr<ACameraMetadata> > mCaptureResults;
+    std::map<int64_t, std::shared_ptr<ACameraMetadata> > mCaptureResultMap;
     uint32_t mLdr;
     uint32_t mFinalLdr;
     uint32_t mFinalBurstCaptures;
     int32_t mFinalOutputFormat;
     std::vector<std::shared_ptr<AImage> > mCaptureFrames;
 
-    cv::Mat mOneFrame;
+    // cv::Mat mOneFrame;
+    std::vector<std::pair<int64_t, cv::Mat> > mOneFrame;
     std::vector<std::vector<uint8_t> >  mRawFrames;
 
     ACameraCaptureSession* capture_session;