I am writing an application which has a video recording feature. During normal day-light hours with lots of light I am able to get 30fps video to record.
However, when there is less light, the frame rate drops to around 7.5fps (with exactly the same code). My guess would be that android is doing something behind the scenes with the exposure time to ensure that the resulting video has the best image quality.
I, however, would prefer a higher fps to a better quality image. Assuming exposure is the issue, is there any way to control the exposure time to ensure a decent fps (15fps+). There are the functions setExposureCompensation() and setAutoExposureLock() but they seem to do nothing.
Has anyone had this issue before? Is it even exposure that is causing my issue?
Any hits/suggestions would be great.
I am sorry but the accepted answer is totally wrong. In fact I have created an account just to correct this.
Noise information gets discarded depending on the bitrate anyway, I do not understand why someone would think that this would be an extra load on cpu at all.
In fact, video framerate on a mobile device has a lot to do with light exposure. In a low light situation, exposure is increased automatically, which also means the shutter will stay open longer to let more light in. Which will reduce the number of frames you can capture in a second, and add some motion blur on top. With a DSLR camera you could change your aperture for more light, without touching the shutter speeds, but on mobile devices your aperture is fixed.
You could mess with exposure compensation to get more fps, but I do not think super dark video is what you want.
More information;
https://anyline.com/news/low-end-android-devices-exposure-triangle/
There is a simple explanation here. The lower light means there is more noise in the video. With more noise the encoding engine has to put far more effort to get the compression it needs. Unless the encoder has a denoiser the encoding engine has far more noise to deal with than normal conditions.
If you want a more technical answer: More noise means that the motion-estimation engine of the encoder is thrown for a toss. This is the part that consumes maximum CPU cycles. The more the noise, the worse the compression and hence even other parts of the encoder are basically crunching more. More bits are generated which means that the encoding and entropy engines are also crunching more and hence the worse performance.
Generally in high end cameras a lot of noise is removed by the imaging pipeline in the sensor. However don't expect that in a mobile phone sensor. [This is the ISO performance that you see in DSLRs ].
I had this issue with Android 4.2 Galaxy S III. After experimenting with parameters found one call which started to work.
Look on Camera.Parameters, if you print them out, you'll see:
preview-fps-range=15000,30000;
preview-fps-range-values=(8000,8000),(10000,10000),(15000,15000),(15000,30000),(30000,30000);
The range allows the fps to "slow down".
The call setPreviewFpsRange(30000, 30000); enforces the fps to stay around 30.
This is right, you should call setPreviewFpsRange() to get constant fps. The frame rate you see is dropping because of the CCD, when light is low the fps goes down so it can produce better pictures (in still mode).
Also to achieve higher frame rate you should use:
Camera.Parameters parameters=camera.getParameters();
parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
parameters.setRecordingHint(true);
camera.setParameters(parameters);
Related
When setting manual controls in Android by using the Camera2 API, what is the purpose of CaptureRequest.SENSOR_FRAME_DURATION?
I have read several times the documentation but still can’t understand its purpose, and what value to set in relation to the exposure time and ISO.
I understand the CaptureRequest.SENSOR_EXPOSURE_TIME specifies how much light is the sensor letting in; also that the CaptureRequest.SENSOR_SENSITIVITY is the sensor sensitivity to light (ISO), but no idea about SENSOR_FRAME_DURATION and how it relates to the exposure time and sensor sensitivity.
For example, if I set a long exposure time of 1 second or 30 seconds, then what is the value that I should set in SENSOR_FRAME_DURATION? And how does it relate to the other sensor controls?
FRAME_DURATION is the same concept as output frame rate. That is, how often is an image read out from the image sensor? Frame rate is generally reported as frames per second, while FRAME_DURATION is the inverse of that - the duration of a single frame.
Since the camera2 API is all about per-frame control, having the duration as a per-frame property is appropriate.
FRAME_DURATION can't be shorter than EXPOSURE_TIME (since you can't read the image from the sensor until exposure is complete), but the API handles this for you - if you ask for a FRAME_DURATION that's too short compared to EXPOSURE_TIME, it gets automatically increased.
That said, often you may want consistent frame rate (such as 30fps for video recording), so you'd set your FRAME_DURATION to 1/30s = 33333333 ns, and then vary EXPOSURE_TIME for manual exposure control. As long as you keep EXPOSURE_TIME as less than 1/30s, you'll get steady frame rate and still have manual exposure control.
The minimum possible frame duration (and therefore the maximum frame rate) depends on the output resolution(s) and format(s) you've asked for in the camera capture session. Generally, bigger resolutions take longer to read out, putting a limit on minimum frame duration. Cameras that support the BURST_CAPTURE camera capability can handle at least 20fps for 8 MP captures, or better.
At the image sensor level, frame duration is implemented by adding in extra vertical blanking time so that EXPOSURE + VBLANK = FRAME_DURATION. The full picture is also more complicated in that typical CMOS image sensors can be exposing some rows of the image while others are being read out (rolling shutter) so the actual timing diagrams look more complicated. You don't generally have to care when just doing basic manual exposure control, however.
Most of the image sensors in a smart phone are using rolling shutter, which readout pixels line by line, the FRAME_DURATION = FRAME_READ_OUT_TIME + VBLANK.
I'm trying to achieve the optimal settings for decoding barcodes using Android's tricky Camera2 API, using TEMPLATE_STILL_CAPTURE and CONTROL_SCENE_MODE_BARCODE WHILE playing with all the other settings like FPS, AF and AE.
So far however, I have been unable to remove the banding seen when reading barcodes from screens.
What would be the way to remove, or reduce, banding when using the Camera2 API taking pictures of screens?
You should set the anti-banding mode, see CONTROL_AE_ANTIBANDING_MODE
...
.setCaptureRequestOption(
CaptureRequest.CONTROL_AE_ANTIBANDING_MODE,
CameraMetadata.CONTROL_AE_ANTIBANDING_MODE_AUTO
)
.setCaptureRequestOption(
CaptureRequest.CONTROL_MODE,
CameraMetadata.CONTROL_MODE_AUTO
)
.setCaptureRequestOption(
CaptureRequest.CONTROL_SCENE_MODE,
CameraMetadata.CONTROL_SCENE_MODE_BARCODE
)
...
https://developer.android.com/reference/android/hardware/camera2/CaptureRequest#CONTROL_AE_ANTIBANDING_MODE
Depending on the technology used by the screen, the screen itself may be flickering at some rate. Unfortunately, the screen is also likely to be bright, meaning the camera has to reduce its exposure time so it doesn't overexpose.
A shorter exposure time makes it harder to apply anti-banding, since anti-banding normally involves having an exposure time that's a multiple of the flicker period. That is, if the flicker is at 100 hz (10 ms period), you need an exposure time that's a multiple of 10 ms. But if the screen is so bright that the camera needs a 5 ms exposure, then there's no way to cancel out the flicker.
In addition, most camera flicker detectors only handle 50 and 60-hz main power flicker rates. Increasingly they do more, since LED lighting has flicker rates that often unrelated to the power line frequencies, but if the device only handles 50 and 60hz, it probably can't compensate for most displays that flicker.
Besides turning on antibanding mode (which should be on by default anyway), you could try increasing exposure compensation to make the image brighter, which may give the device enough room to set an exposure time for flicker reduction. But beyond that there's not much you can do, unfortunately.
I want to fix the frame rate of camera preview in Android, i.e., 20fps, or 30 fps. However, we find the frame rate is unstable.
In the android document, it is said that the frame rate is fluctuated between the minimum frame rate and the maximum one which are defined in getSupportedPreviewFpsRange.
https://developer.android.com/reference/android/hardware/Camera.Parameters.html#getSupportedPreviewFpsRange%28%29
My questions are:
1) Which factors influence the frame rate? exposure time, white balance, frame resolution, background CPU loading, and etc.?
2) Is there any method to fix the frame rate by customised above factors?
3) In my project, higher frame rate is better. If the frame rate is unstable in the end. Can I increase the minimum frame rate? or fix the minimum frame rate?
4) It seems that the video taking is somewhat different with preview model, Can I fix the frame rate or minimum frame rate of video taking in Android?
Finally, we found that IOS can fix the frame rate using videoMinFrameDuration and
videoMaxFrameDuration.
Thanks.
First of all, please note that the camera API that you ask about was deprecated more than 3 years ago. The new camera2 API provides much more control over all aspects of capture, including frame rate.
Especially, if your goal is smooth video recording. Actually, the MediaRecorder performs its job decently on older devices, but I understand that this knowledge has little practical value if for some reason you cannot use the MediaRecorder.
Usually, the list of supported FPS ranges includes fixed ranges, e.g. 30 fps, intended exactly for video recording. Note that you are expected to choose a compliant (recommended) preview (video) resolution.
Two major factors cause frame rate variations within the declared range: exposure adjustments and focus adjustments. To achieve uniform rate, you should disable autofocus. If your camera supports exposure control, you should lock it, too. Refrain from using exotic "scenes" and "effects". SCENE_MODE_BARCODE and EFFECT_MONO don't seem to cause problems with frame rate. Whitebalance is OK, too.
There exist other factors that cause frame rate fluctuations that are completely under your control.
Make sure that your camera callbacks do not interfere with, and are not delayed by the Main (UI) thread. To achieve that, you must open the camera on a secondary HandlerThread. The new camera2 API makes thread management for camera callbacks easier.
Don't use setPreviewCallback() which automatically allocates pixel buffers for each frame. This is a significant burden for garbage collector, which may lock all threads once in a while for major cleanup. Instead, use setPreviewCallbackWithBuffer() and preallocate just enough pixel buffers to keep it always busy.
Don't perform heavy calculations in the context of your onPreviewFrame() callback. Pass all work to a different thread. Do your best to release the pixel buffer as early as possible.
Even for the old camera API, if the device lists a supported FPS range of (30, 30), then you should be able to select this range and get consistent, fixed video recording.
Unfortunately, some devices disregard your frame rate request once the scene conditions get too dark, and increase exposure times past 1/30s. For many applications, this is the preferable option, but such applications should simply be selecting a wider frame rate range like (15, 30).
I am timing my OpenGL frame rates, with v-sync turned on, and notice my timings aren't the precise frequency as set by the monitor. That is, on my desktop I have a 60Hz refresh, but the FPS is stable at 59.88, whereas on my tablet it's also 60Hz but the FPS can be 61/62 FPS. I'm curious as to what precisely causes these slight deviations.
These are the ideas I've had so far:
Dropped Frames: This is the obvious answer: I'm just missing some frames. This is however not the cause as I can verify I am not dropping frames and the drop in FPS would be higher if this happened. I calculate the time over 120 frames, so if 1 frame was lost the FPS would drop below 59.5 on the desktop.
Inaccurate timings: I use clock_gettime to get my timings. On Linux I know this is accurate enough (as I previously did nanosecond based timings with it, but here we could even live with +/- several hundred microseconds). On Android however I'm not sure of the accuracy of this.
API Oddity: I use glXSwapBuffers on the desktop and eglSwapBuffers on Android. There could be an oddity here, but I don't see how this could so subtley affect the frame rate.
Approximate Hz: This is my biggest guess that the video cards/monitor aren't actually running at 60Hz. This is probably tied to the exact speed of the monitor, and the video card frequency. This seems like something that could be concretely determined, but I don't know which tools can be used to do this. (Update: My current video mode in Linux shows 59.93Hz, so closer, but still not there)
If the answer is indeed #4 this is perhaps not the best exchange site for the question. But in all cases my ultimate goal is to figure out programmatically what the ideal refresh rate actaully is. So I'm hoping somebody can confirm/deny my ideas, and possibly point me in the right direction to getting the information I need.
Is the technology there for the camera of a smartphone to detect a light flashing and to detect it as morse code, at a maximum of 100m?
There's already at least one app in the iPhone App store that does this for some unknown distance. And the camera can detect luminance at a much greater distance, given enough contrast of the exposure between on and off light levels, a slow enough dot rate to not alias against the frame rate (remember about Nyquist sampling), and maybe a tripod to keep the light centered on some small set of pixels. So the answer is probably yes.
I think it's possible in ideal conditions. Clear air and no other "light noise", like in a dark night in the mountain or so. The problem is that users would try to use it in the city, discos etc... where it would obviously fail.
If you can record a video of the light and easily visually decode it upon watching, then there's a fair chance you may be able to do so programmatically with enough work.
The first challenge would be finding the light in the background, especially if its small and/or there's any movement of the camera or source. You might actually be able to leverage some kinds of video compression technology to help filter out the movement.
The second question is if the phone has enough horsepower and your algorithm enough efficiency to decode it in real time. For a slow enough signaling rate, the answer would be yes.
Finally there might be things you could do to make it easier. For example, if you could get the source to flash at exactly half the camera frame rate when it is on instead of being steady on, it might be easier to identify since it would be in every other frame. You can't synchronize that exactly (unless both devices make good use of GPS time), but might get close enough to be of help.
Yes, the technology is definitely there. I written an Android application for my "Advanced Internet Technology" class, which does exactly what you describe.
The application has still problems with bright noise (when other light sources leave or enter the camera view while recording). The approach that I'm using just uses the overall brightness changes to extract the Morse signal.
There are some more or less complicated algorithms in place to correct the auto exposure problem (the image darkens shortly after the light is "turned on") and to detect the thresholds for the Morse signal strength and speed.
Overall performance of the application is good. I tested it during the night in the mountains and as long as the sending signal is strong enough, there is no problem. In the library (with different light-sources around), it was less accurate. I had to be careful not to have additional light-sources at the "edge" of the camera screen. The application required the length of a "short" Morse signal to be 300ms at least.
The better approach would be to "search" the screen for the actual light-source. For my project it turned out to be too much work, but you should get good detection in noisy environment with this.