internal static unsafe void SetFramerateRange(this IPort port, MMAL_RATIONAL_T fpsLow, MMAL_RATIONAL_T fpsHigh)
{
var str = new MMAL_PARAMETER_FPS_RANGE_T(
new MMAL_PARAMETER_HEADER_T(
MMALParametersCamera.MMAL_PARAMETER_FPS_RANGE,
Marshal.SizeOf <MMAL_PARAMETER_FPS_RANGE_T>()), fpsLow, fpsHigh);
MMALCheck(MMALPort.mmal_port_parameter_set(port.Ptr, &str.Hdr), "Unable to set framerate range for port.");
}
/// <summary>
/// Provides a facility to get data from the port using the native helper functions.
/// </summary>
/// <param name="port">The port to get the parameter from.</param>
/// <param name="key">The unique key for the parameter.</param>
/// <returns>Dynamic parameter based on key parameter.</returns>
public static unsafe dynamic GetParameter(this IPort port, int key)
{
var t = MMALParameterHelpers.ParameterHelper.Where(c => c.ParamValue == key).FirstOrDefault();
if (t == null)
{
throw new PiCameraError($"Could not find parameter {key}");
}
MMALLog.Logger.LogDebug($"Getting parameter {t.ParamName}");
try
{
switch (t.ParamType.Name)
{
case "MMAL_PARAMETER_BOOLEAN_T":
int boolVal = 0;
MMALCheck(MMALUtil.mmal_port_parameter_get_boolean(port.Ptr, (uint)key, ref boolVal), "Unable to get boolean value");
return(boolVal == 1);
case "MMAL_PARAMETER_UINT64_T":
ulong ulongVal = 0UL;
MMALCheck(MMALUtil.mmal_port_parameter_get_uint64(port.Ptr, (uint)key, ref ulongVal), "Unable to get ulong value");
return(ulongVal);
case "MMAL_PARAMETER_INT64_T":
long longVal = 0U;
MMALCheck(MMALUtil.mmal_port_parameter_get_int64(port.Ptr, (uint)key, ref longVal), "Unable to get long value");
return(longVal);
case "MMAL_PARAMETER_UINT32_T":
uint uintVal = 0U;
MMALCheck(MMALUtil.mmal_port_parameter_get_uint32(port.Ptr, (uint)key, ref uintVal), "Unable to get uint value");
return(uintVal);
case "MMAL_PARAMETER_INT32_T":
int intVal = 0;
MMALCheck(MMALUtil.mmal_port_parameter_get_int32(port.Ptr, (uint)key, ref intVal), "Unable to get int value");
return(intVal);
case "MMAL_PARAMETER_RATIONAL_T":
MMAL_RATIONAL_T ratVal = default(MMAL_RATIONAL_T);
MMALCheck(MMALUtil.mmal_port_parameter_get_rational(port.Ptr, (uint)key, ref ratVal), "Unable to get rational value");
return((double)ratVal.Num / ratVal.Den);
default:
throw new NotSupportedException();
}
}
catch
{
MMALLog.Logger.LogWarning($"Unable to get port parameter {t.ParamName}");
throw;
}
}
internal static void SetBrightness(this MMALCameraComponent camera, double brightness)
{
MMALLog.Logger.LogDebug($"Setting brightness: {brightness}");
var value = new MMAL_RATIONAL_T((int)brightness, 100);
if (brightness >= 0 && brightness <= 100)
{
camera.Control.SetParameter(MMAL_PARAMETER_BRIGHTNESS, value);
}
else
{
throw new Exception("Invalid brightness value");
}
}
internal static void SetContrast(this MMALCameraComponent camera, double contrast)
{
MMALLog.Logger.LogDebug($"Setting contrast: {contrast}");
var value = new MMAL_RATIONAL_T((int)contrast, 100);
if (contrast >= -100 && contrast <= 100)
{
camera.Control.SetParameter(MMAL_PARAMETER_CONTRAST, value);
}
else
{
throw new Exception("Invalid contrast value");
}
}
internal static void SetSharpness(this MMALCameraComponent camera, double sharpness)
{
MMALLog.Logger.LogDebug($"Setting sharpness: {sharpness}");
var value = new MMAL_RATIONAL_T((int)sharpness, 100);
if (sharpness >= -100 && sharpness <= 100)
{
camera.Control.SetParameter(MMAL_PARAMETER_SHARPNESS, value);
}
else
{
throw new Exception("Invalid sharpness value");
}
}
internal static void SetSaturation(this MMALCameraComponent camera, double saturation)
{
MMALLog.Logger.LogDebug($"Setting saturation: {saturation}");
var value = new MMAL_RATIONAL_T((int)saturation, 100);
if (saturation >= -100 && saturation <= 100)
{
camera.Control.SetParameter(MMAL_PARAMETER_SATURATION, value);
}
else
{
throw new Exception("Invalid saturation value");
}
}
private void ConfigureVideoProfile(int outputPort)
{
var rational = new MMAL_RATIONAL_T(MMALCameraConfig.Framerate);
var macroblocks = (MMALCameraConfig.Resolution.Width >> 4) * (MMALCameraConfig.Resolution.Height >> 4);
var macroblocksPSec = macroblocks * (rational.Num / rational.Den);
List <VideoLevel> videoLevels = GetNormalLevelLimits();
var level = videoLevels.Where(c => c.Level == MMALCameraConfig.VideoLevel).First();
if (macroblocks > level.MacroblocksLimit)
{
throw new PiCameraError("Resolution exceeds macroblock limit for selected profile and level.");
}
if (macroblocksPSec > level.MacroblocksPerSecLimit)
{
throw new PiCameraError("Resolution exceeds macroblocks/s limit for selected profile and level.");
}
MMAL_PARAMETER_VIDEO_PROFILE_S p = new MMAL_PARAMETER_VIDEO_PROFILE_S(MMALCameraConfig.VideoProfile, MMALCameraConfig.VideoLevel);
MMAL_PARAMETER_VIDEO_PROFILE_S[] arr = new MMAL_PARAMETER_VIDEO_PROFILE_S[1] {
p
};
MMAL_PARAMETER_VIDEO_PROFILE_T param = new MMAL_PARAMETER_VIDEO_PROFILE_T(new MMAL_PARAMETER_HEADER_T(MMALParametersVideo.MMAL_PARAMETER_PROFILE, Marshal.SizeOf <MMAL_PARAMETER_VIDEO_PROFILE_T>()), arr);
IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(param));
Marshal.StructureToPtr(param, ptr, false);
try
{
MMALCheck(
MMALPort.mmal_port_parameter_set(this.Outputs[outputPort].Ptr, (MMAL_PARAMETER_HEADER_T *)ptr),
"Unable to set video profile.");
}
finally
{
Marshal.FreeHGlobal(ptr);
}
}
public MMALVideoEncoder(ICaptureHandler handler, MMAL_RATIONAL_T framerate, DateTime?timeout = null, Split split = null) : base(MMALParameters.MMAL_COMPONENT_DEFAULT_VIDEO_ENCODER, handler)
{
this.Framerate = framerate.Num / framerate.Den;
this.Split = split;
this.Timeout = timeout;
}
