bumped API version to 34, fixed some bugs that crept up from that

Author: diminDDL

app/build.gradle

@@ -8,16 +8,16 @@ android {
 	defaultConfig {
 		applicationId "be.ntmn.inficam"
 		minSdkVersion 21
-		versionCode 2
-		versionName "1.0.1"
+		versionCode 3
+		versionName "1.0.2"
 		vectorDrawables.useSupportLibrary true // To support older minSdk
 
 		/* We need targetSdkVersion <= 27 for some Android 10 devices to work:
 		 *   https://issuetracker.google.com/issues/145082934
 		 *   https://issuetracker.google.com/issues/139087809
 		 */
 		//noinspection ExpiredTargetSdkVersion
-		targetSdkVersion 27
+		targetSdkVersion 34
 	}
 
 	buildTypes {

app/src/main/java/be/ntmn/inficam/MainActivity.java

@@ -298,6 +298,37 @@ public void onDisplayRemoved(int displayId) { /* Empty. */ }
 		private final Runnable handleFrameRunnable = () -> handleFrame();
 		Overlay.MinMaxAvg mma = new Overlay.MinMaxAvg();
 
+		private boolean isFinite(float v) {
+			return !isNaN(v) && !isInfinite(v);
+		}
+
+		private void mmaDownsample(Overlay.MinMaxAvg out, float[] temp, int w, int h, int step) {
+			out.min = out.max = NaN;
+			out.avg = 0.0f;
+			out.min_x = out.min_y = out.max_x = out.max_y = 0;
+			int n = 0;
+			for (int y = 0; y < h; y += step) {
+				int row = y * w;
+				for (int x = 0; x < w; x += step) {
+					float t = temp[row + x];
+					if (t < out.min || isNaN(out.min)) {
+						out.min = t;
+						out.min_x = x;
+						out.min_y = y;
+					}
+					if (t > out.max || isNaN(out.max)) {
+						out.max = t;
+						out.max_x = x;
+						out.max_y = y;
+					}
+					out.avg += t;
+					++n;
+				}
+			}
+			if (n > 0)
+				out.avg /= n;
+		}
+
 		@Override
 		public void onFrame(InfiCam.FrameInfo fi, float[] temp) {
 			synchronized (frameLock) { /* Note this is called from another thread. */
@@ -360,6 +391,48 @@ public void onFrame(InfiCam.FrameInfo fi, float[] temp) {
                     }
                 }
 
+				/*
+				 * avoid passing NaN to native and fall back to computing min/max from the buffer when
+				 * the camera-provided range looks invalid (e.g. clamps everything to the minimum).
+				 */
+				final boolean autoMin = isNaN(overlayData.rangeMin) || isInfinite(overlayData.rangeMin);
+				final boolean autoMax = isNaN(overlayData.rangeMax) || isInfinite(overlayData.rangeMax);
+				if (autoMin && !isFinite(rangeMin))
+					rangeMin = fi.min;
+				if (autoMax && !isFinite(rangeMax))
+					rangeMax = fi.max;
+
+				boolean suspectRange = !isFinite(rangeMin) || !isFinite(rangeMax) || rangeMax <= rangeMin;
+				if (!suspectRange && (autoMin || autoMax) && temp != null && temp.length >= fi.width * fi.height
+						&& fi.width > 0 && fi.height > 0) {
+					int centerIdx = (fi.height / 2) * fi.width + (fi.width / 2);
+					float s0 = temp[0];
+					float sc = temp[centerIdx];
+					float s1 = temp[temp.length - 1];
+					float sampleMin = java.lang.Math.min(s0, java.lang.Math.min(sc, s1));
+					float sampleMax = java.lang.Math.max(s0, java.lang.Math.max(sc, s1));
+					/* If even a few samples fall entirely outside the palette range, it's likely wrong. */
+					if (rangeMin > sampleMax || rangeMax < sampleMin)
+						suspectRange = true;
+				}
+
+				if (suspectRange && (autoMin || autoMax) && temp != null && fi.width > 0 && fi.height > 0) {
+					/* Downsample to keep this cheap; good enough for palette scaling. */
+					mmaDownsample(mma, temp, fi.width, fi.height, 4);
+					if (isFinite(mma.min) && isFinite(mma.max) && mma.max > mma.min) {
+						fi.min = mma.min;
+						fi.min_x = mma.min_x;
+						fi.min_y = mma.min_y;
+						fi.max = mma.max;
+						fi.max_x = mma.max_x;
+						fi.max_y = mma.max_y;
+						if (autoMin)
+							rangeMin = mma.min;
+						if (autoMax)
+							rangeMax = mma.max;
+					}
+				}
+
 
 				infiCam.applyPalette(rangeMin, rangeMax);
 				handler.post(handleFrameRunnable);
@@ -670,7 +743,16 @@ protected void onStart() {
 		DisplayManager displayManager = (DisplayManager) getSystemService(Context.DISPLAY_SERVICE);
 		displayManager.registerDisplayListener(displayListener, handler);
 		IntentFilter batIFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
-		Intent batteryStatus = registerReceiver(batteryRecevier, batIFilter);
+		Intent batteryStatus;
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+		    batteryStatus = registerReceiver(
+		        batteryRecevier,
+		        batIFilter,
+		        Context.RECEIVER_NOT_EXPORTED
+		    );
+		} else {
+		    batteryStatus = registerReceiver(batteryRecevier, batIFilter);
+		}
 		updateBatLevel(batteryStatus);
 
 		/* Beware that we can't call these in onResume as they'll ask permission with dialogs and

app/src/main/java/be/ntmn/inficam/SurfaceMuxer.java

@@ -104,6 +104,7 @@ public static class InputSurface {
 		public float scale_x = 1.0f, scale_y = 1.0f;
 		public float translate_x = 0.0f, translate_y = 0.0f;
 		public float sharpening = 0.0f;
+		private volatile boolean frameAvailable = false;
 
 		public InputSurface(SurfaceMuxer muxer) {
 			this.muxer = muxer;
@@ -136,13 +137,15 @@ private void init() {
 			GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER,
 					GLES20.GL_LINEAR);
 			if (surfaceTexture == null) {
-				surfaceTexture = new SurfaceTexture(textures[0]);
-				surface = new Surface(surfaceTexture);
-			} else surfaceTexture.attachToGLContext(textures[0]);
-			/* After attaching to a new context we must call updateTexImage() or the
-			 *   OnFrameAvailableListener may stop being called for some reason.
-			 */
-			surfaceTexture.updateTexImage();
+			    surfaceTexture = new SurfaceTexture(textures[0]);
+			    surfaceTexture.setOnFrameAvailableListener(
+			        st -> frameAvailable = true
+			    );
+			    surface = new Surface(surfaceTexture);
+			} else {
+			    surfaceTexture.attachToGLContext(textures[0]);
+			    frameAvailable = true; // force first frame latch after reattach
+			}
 			initialized = true;
 		}
 
@@ -174,7 +177,10 @@ public void draw(OutputSurface os, int drawMode, int x, int y, int w, int h) {
 			if (muxer.eglContext == EGL14.EGL_NO_CONTEXT)
 				return;
 			os.makeCurrent(); /* We need the context to be current before updateTexImage(). */
-			surfaceTexture.updateTexImage(); /* Call might be redundant, probably don't care. */
+			if (frameAvailable) {
+			    surfaceTexture.updateTexImage();
+			    frameAvailable = false;
+			}
 			GLES20.glViewport(x, y, w, h);
 			int program = muxer.drawModes[drawMode].program;
 			GLES20.glUseProgram(program);

app/src/main/java/be/ntmn/inficam/USBMonitor.java

@@ -27,16 +27,26 @@ public interface ConnectCallback {
 	private final HashMap<UsbDevice, ConnectCallback> callbacks = new HashMap<>();
 
 	public void start(Context ctx) { /* Recommended use is in onCreate()/onStart(). */
-		this.ctx = ctx;
-		if (!registered) {
-			manager = (UsbManager) ctx.getSystemService(Context.USB_SERVICE);
-			IntentFilter filter = new IntentFilter();
-			filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
-			filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
-			filter.addAction(ACTION_USB_PERMISSION);
-			ctx.registerReceiver(this, filter);
-			registered = true;
-		}
+	    this.ctx = ctx;
+	    if (!registered) {
+	        manager = (UsbManager) ctx.getSystemService(Context.USB_SERVICE);
+	        IntentFilter filter = new IntentFilter();
+	        filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
+	        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
+	        filter.addAction(ACTION_USB_PERMISSION);
+	
+	        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+	            ctx.registerReceiver(
+	                this,
+	                filter,
+	                Context.RECEIVER_NOT_EXPORTED
+	            );
+	        } else {
+	            ctx.registerReceiver(this, filter);
+	        }
+	
+	        registered = true;
+	    }
 	}
 
 	public void stop() { /* Call this in onDestroy()/onStop(), matching start() call. */
@@ -66,6 +76,10 @@ private void _connect(UsbDevice dev, ConnectCallback cb) {
 	public void connect(UsbDevice dev, ConnectCallback cb) {
 		if (!manager.hasPermission(dev)) {
 			Intent intent = new Intent(ACTION_USB_PERMISSION);
+			// Targeting Android 14+ (targetSdk 34) forbids FLAG_MUTABLE PendingIntents with
+			// implicit Intents. UsbManager.requestPermission requires a mutable PendingIntent
+			// so the system can add extras; restricting the Intent to our app satisfies both.
+			intent.setPackage(ctx.getPackageName());
 			int flags = PendingIntent.FLAG_ONE_SHOT;
 			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
 				flags |= PendingIntent.FLAG_MUTABLE;

build.gradle

@@ -1,6 +1,6 @@
 plugins {
-	id 'com.android.application' version '8.8.0' apply false
-	id 'com.android.library' version '8.8.0' apply false
+	id 'com.android.application' version '8.8.2' apply false
+	id 'com.android.library' version '8.8.2' apply false
 }
 
 task clean(type: Delete) {

libinficam/src/main/jni/Application.mk

@@ -1,5 +1,6 @@
 APP_PLATFORM := android-16
 APP_ABI := armeabi-v7a arm64-v8a x86_64 x86
+# APP_OPTIM := debug
 APP_OPTIM := release
 APP_STL := c++_static
 APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

libinficam/src/main/jni/InfiCam/Android.mk

@@ -7,9 +7,15 @@ LOCAL_C_INCLUDES :=$(LOCAL_PATH)/../libusb/libusb $(LOCAL_PATH)/../libuvc_build
 
 LOCAL_CFLAGS := $(LOCAL_C_INCLUDES:%=-I%)
 LOCAL_CFLAGS += -DANDROID_NDK
-LOCAL_CFLAGS += -DLOG_NDEBUG
 LOCAL_CFLAGS += -DACCESS_RAW_DESCRIPTORS
-LOCAL_CFLAGS += -O3 -fstrict-aliasing -fprefetch-loop-arrays
+
+# Debug vs Release
+ifeq ($(APP_OPTIM),debug)
+    LOCAL_CFLAGS += -O0 -g -fno-inline -fno-omit-frame-pointer
+else
+    LOCAL_CFLAGS += -O3 -fstrict-aliasing -fprefetch-loop-arrays
+    LOCAL_CFLAGS += -DLOG_NDEBUG
+endif
 
 LOCAL_LDLIBS := -ldl -llog -landroid
 

libinficam/src/main/jni/InfiCam/InfiCam.cpp

@@ -182,6 +182,10 @@ int InfiCam::connect(int fd) {
 	 */
 	if (pthread_mutex_init(&frame_callback_mutex, NULL))
 		return 1;
+    if (pthread_cond_init(&calibration_cond, NULL)) {
+        pthread_mutex_destroy(&frame_callback_mutex);
+        return 1;
+    }
 	if (dev.connect(fd, p2_pro)) {
 		pthread_mutex_destroy(&frame_callback_mutex);
 		return 2;
@@ -202,6 +206,7 @@ void InfiCam::disconnect() {
 		stream_stop();
 		dev.disconnect();
 		pthread_mutex_destroy(&frame_callback_mutex);
+        pthread_cond_destroy(&calibration_cond);
 		connected = 0;
 	}
 }

libinficam/src/main/jni/InfiCam/InfiCam.h

@@ -25,9 +25,9 @@ class InfiCam {
 	float *frame_temp = NULL;
 	pthread_mutex_t frame_callback_mutex;
     pthread_cond_t calibration_cond;
-	int connected = 0, streaming = 0, table_invalid;
+	int connected = 0, streaming = 0, table_invalid = 1;
     bool raw_sensor = false;
-    bool p2_pro;
+    bool p2_pro = false;
     bool calibrating = false;
     bool calibrated = false;
     bool* dead_pixel_mask = nullptr;

libinficam/src/main/jni/InfiCam/InfiFrame.cpp

@@ -206,7 +206,8 @@ float InfiFrame::temp_single(uint16_t x) {
         float n = sqrtf(((float) (x - table_offset) * cal_d + cal_c) / cal_01 + cal_b);
         float wtot = powf((isfinite(n) ? n : 0.0) - cal_a + zeroc, 4);
         float ttot = powf((wtot - numerator_sub) / denominator, 0.25) - zeroc;
-        return ttot + (distance_adjusted * 0.85 - 1.125) * (ttot - temp_air) / 100.0 + correction;
+		float temp_single = ttot + (distance_adjusted * 0.85 - 1.125) * (ttot - temp_air) / 100.0 + correction;
+        return temp_single;
     }
 }
 
@@ -222,7 +223,8 @@ void InfiFrame::temp(uint16_t *input, float *output) {
 
 void InfiFrame::temp(uint16_t *input, float *output, size_t len) {
 	for (size_t i = 0; i < len; ++i)
-		output[i] = temp(input[i]>>2);
+//		output[i] = temp(input[i] & table_mask);
+        output[i] = temp(input[i]);
 }
 
 void InfiFrame::read_params(uint16_t *frame) {