src/Tizen.Multimedia.Camera/Interop/Interop.Camera.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using System.Runtime.InteropServices;
  19 using Tizen.Internals;
  20 using Tizen.Multimedia;
  21
  22 internal static partial class Interop
  23 {
  24     internal static partial class Camera
  25     {
  26         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  27         internal delegate void FaceDetectedCallback(IntPtr faces, int count, IntPtr userData);
  28
  29         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  30         internal delegate void StateChangedCallback(CameraState previous, CameraState current, bool byPolicy, IntPtr userData);
  31
  32         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  33         internal delegate void InterruptedCallback(CameraPolicy policy, CameraState previous, CameraState current, IntPtr userData);
  34
  35         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  36         internal delegate void InterruptStartedCallback(CameraPolicy policy, CameraState state, IntPtr userData);
  37
  38         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  39         internal delegate void FocusStateChangedCallback(CameraFocusState state, IntPtr userData);
  40
  41         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  42         internal delegate void ErrorCallback(CameraErrorCode error, CameraState current, IntPtr userData);
  43
  44         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  45         internal delegate void CapturingCallback(IntPtr image, IntPtr postview, IntPtr thumbnail, IntPtr userData);
  46
  47         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  48         internal delegate void CaptureCompletedCallback(IntPtr userData);
  49
  50         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  51         internal delegate void PreviewCallback(IntPtr frame, IntPtr userData);
  52
  53         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  54         internal delegate void ExtraPreviewCallback(IntPtr frame, int streamId, IntPtr userData);
  55
  56         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  57         internal delegate void MediaPacketPreviewCallback(IntPtr mediaPacketHandle, IntPtr userData);
  58
  59         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  60         internal delegate void HdrCaptureProgressCallback(int percent, IntPtr userData);
  61
  62         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  63         internal delegate void DeviceStateChangedCallback(CameraDevice device, CameraDeviceState state, IntPtr userData);
  64
  65         [DllImport(Libraries.Camera, EntryPoint = "camera_create")]
  66         internal static extern CameraError Create(CameraDevice device, out IntPtr handle);
  67
  68         [DllImport(Libraries.Camera, EntryPoint ="camera_create_network")]
  69         internal static extern CameraError CreateNetworkCamera(CameraDevice device, out IntPtr handle);
  70
  71         [DllImport(Libraries.Camera, EntryPoint = "camera_change_device")]
  72         internal static extern CameraError ChangeDevice(IntPtr handle, CameraDevice device);
  73
  74         [DllImport(Libraries.Camera, EntryPoint = "camera_destroy")]
  75         internal static extern CameraError Destroy(IntPtr handle);
  76
  77         [DllImport(Libraries.Camera, EntryPoint = "camera_get_device_count")]
  78         internal static extern CameraError GetDeviceCount(IntPtr handle, out int count);
  79
  80         [DllImport(Libraries.Camera, EntryPoint = "camera_start_preview")]
  81         internal static extern CameraError StartPreview(IntPtr handle);
  82
  83         [DllImport(Libraries.Camera, EntryPoint = "camera_stop_preview")]
  84         internal static extern CameraError StopPreview(IntPtr handle);
  85
  86         [DllImport(Libraries.Camera, EntryPoint = "camera_get_device_state")]
  87         internal static extern CameraError GetDeviceState(CameraDevice device, out CameraDeviceState state);
  88
  89         [DllImport(Libraries.Camera, EntryPoint = "camera_start_capture")]
  90         internal static extern CameraError StartCapture(IntPtr handle, CapturingCallback captureCallback,
  91                                                 CaptureCompletedCallback completedCallback, IntPtr userData = default);
  92
  93         [DllImport(Libraries.Camera, EntryPoint = "camera_start_continuous_capture")]
  94         internal static extern CameraError StartContinuousCapture(IntPtr handle, int count, int interval,
  95                                                           CapturingCallback captureCallback, CaptureCompletedCallback completedCallback, IntPtr userData = default);
  96
  97         [DllImport(Libraries.Camera, EntryPoint = "camera_stop_continuous_capture")]
  98         internal static extern CameraError StopContinuousCapture(IntPtr handle);
  99
 100         [DllImport(Libraries.Camera, EntryPoint = "camera_get_state")]
 101         internal static extern CameraError GetState(IntPtr handle, out CameraState state);
 102
 103         [DllImport(Libraries.Camera, EntryPoint = "camera_start_focusing")]
 104         internal static extern CameraError StartFocusing(IntPtr handle, bool continuous);
 105
 106         [DllImport(Libraries.Camera, EntryPoint = "camera_cancel_focusing")]
 107         internal static extern CameraError CancelFocusing(IntPtr handle);
 108
 109         [DllImport(Libraries.Camera, EntryPoint = "camera_set_preview_resolution")]
 110         internal static extern CameraError SetPreviewResolution(IntPtr handle, int width, int height);
 111
 112         [DllImport(Libraries.Camera, EntryPoint = "camera_get_preview_resolution")]
 113         internal static extern CameraError GetPreviewResolution(IntPtr handle, out int width, out int height);
 114
 115         [DllImport(Libraries.Camera, EntryPoint = "camera_get_recommended_preview_resolution")]
 116         internal static extern CameraError GetRecommendedPreviewResolution(IntPtr handle, out int width, out int height);
 117
 118         [DllImport(Libraries.Camera, EntryPoint = "camera_start_face_detection")]
 119         internal static extern CameraError StartFaceDetection(IntPtr handle, FaceDetectedCallback callback, IntPtr userData = default);
 120
 121         [DllImport(Libraries.Camera, EntryPoint = "camera_stop_face_detection")]
 122         internal static extern CameraError StopFaceDetection(IntPtr handle);
 123
 124         [DllImport(Libraries.Camera, EntryPoint = "camera_set_display_reuse_hint")]
 125         internal static extern CameraError SetDisplayReuseHint(IntPtr handle, bool hint);
 126
 127         [DllImport(Libraries.Camera, EntryPoint = "camera_get_display_reuse_hint")]
 128         internal static extern CameraError GetDisplayReuseHint(IntPtr handle, out bool hint);
 129
 130         [DllImport(Libraries.Camera, EntryPoint = "camera_set_capture_resolution")]
 131         internal static extern CameraError SetCaptureResolution(IntPtr handle, int width, int height);
 132
 133         [DllImport(Libraries.Camera, EntryPoint = "camera_get_capture_resolution")]
 134         internal static extern CameraError GetCaptureResolution(IntPtr handle, out int width, out int height);
 135
 136         [DllImport(Libraries.Camera, EntryPoint = "camera_set_capture_format")]
 137         internal static extern CameraError SetCaptureFormat(IntPtr handle, CameraPixelFormat format);
 138
 139         [DllImport(Libraries.Camera, EntryPoint = "camera_get_capture_format")]
 140         internal static extern CameraError GetCaptureFormat(IntPtr handle, out CameraPixelFormat format);
 141
 142         [DllImport(Libraries.Camera, EntryPoint = "camera_set_preview_format")]
 143         internal static extern CameraError SetPreviewPixelFormat(IntPtr handle, CameraPixelFormat format);
 144
 145         [DllImport(Libraries.Camera, EntryPoint = "camera_get_preview_format")]
 146         internal static extern CameraError GetPreviewPixelFormat(IntPtr handle, out CameraPixelFormat format);
 147
 148         [DllImport(Libraries.Camera, EntryPoint = "camera_get_facing_direction")]
 149         internal static extern CameraError GetFacingDirection(IntPtr handle, out CameraFacingDirection direction);
 150
 151         [DllImport(Libraries.Camera, EntryPoint = "camera_get_flash_state")]
 152         internal static extern CameraError GetFlashState(CameraDevice device, out CameraFlashState state);
 153
 154         [DllImport(Libraries.Camera, EntryPoint = "camera_set_extra_preview_stream_format")]
 155         internal static extern CameraError SetExtraPreviewStreamFormat(IntPtr handle, int streamId, CameraPixelFormat format,
 156             int width, int height, int fps);
 157
 158         [DllImport(Libraries.Camera, EntryPoint = "camera_get_extra_preview_stream_format")]
 159         internal static extern CameraError GetExtraPreviewStreamFormat(IntPtr handle, int streamId, out CameraPixelFormat format,
 160             out int width, out int height, out int fps);
 161
 162
 163         [DllImport(Libraries.Camera, EntryPoint = "camera_set_preview_cb")]
 164         internal static extern CameraError SetPreviewCallback(IntPtr handle, PreviewCallback callback, IntPtr userData = default);
 165
 166         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_preview_cb")]
 167         internal static extern CameraError UnsetPreviewCallback(IntPtr handle);
 168
 169         [DllImport(Libraries.Camera, EntryPoint = "camera_set_media_packet_preview_cb")]
 170         internal static extern CameraError SetMediaPacketPreviewCallback(IntPtr handle, MediaPacketPreviewCallback callback, IntPtr userData = default);
 171
 172         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_media_packet_preview_cb")]
 173         internal static extern CameraError UnsetMediaPacketPreviewCallback(IntPtr handle);
 174
 175         [DllImport(Libraries.Camera, EntryPoint = "camera_set_extra_preview_cb")]
 176         internal static extern CameraError SetExtraPreviewCallback(IntPtr handle, ExtraPreviewCallback callback, IntPtr userData = default);
 177
 178         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_extra_preview_cb")]
 179         internal static extern CameraError UnsetExtraPreviewCallback(IntPtr handle);
 180
 181         [DllImport(Libraries.Camera, EntryPoint = "camera_set_state_changed_cb")]
 182         internal static extern CameraError SetStateChangedCallback(IntPtr handle, StateChangedCallback callback, IntPtr userData = default);
 183
 184         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_state_changed_cb")]
 185         internal static extern CameraError UnsetStateChangedCallback(IntPtr handle);
 186
 187         [DllImport(Libraries.Camera, EntryPoint = "camera_add_device_state_changed_cb")]
 188         internal static extern CameraError SetDeviceStateChangedCallback(DeviceStateChangedCallback callback, IntPtr userData, out int callbackId);
 189
 190         [DllImport(Libraries.Camera, EntryPoint = "camera_remove_device_state_changed_cb")]
 191         internal static extern CameraError UnsetDeviceStateChangedCallback(int cbId);
 192
 193         [DllImport(Libraries.Camera, EntryPoint = "camera_set_interrupt_started_cb")]
 194         internal static extern CameraError SetInterruptStartedCallback(IntPtr handle, InterruptStartedCallback callback, IntPtr userData = default);
 195
 196         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_interrupt_started_cb")]
 197         internal static extern CameraError UnsetInterruptStartedCallback(IntPtr handle);
 198
 199         [DllImport(Libraries.Camera, EntryPoint = "camera_set_interrupted_cb")]
 200         internal static extern CameraError SetInterruptedCallback(IntPtr handle, InterruptedCallback callback, IntPtr userData = default);
 201
 202         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_interrupted_cb")]
 203         internal static extern CameraError UnsetInterruptedCallback(IntPtr handle);
 204
 205         [DllImport(Libraries.Camera, EntryPoint = "camera_set_focus_changed_cb")]
 206         internal static extern CameraError SetFocusStateChangedCallback(IntPtr handle, FocusStateChangedCallback callback, IntPtr userData = default);
 207
 208         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_focus_changed_cb")]
 209         internal static extern CameraError UnsetFocusChangedCallback(IntPtr handle);
 210
 211         [DllImport(Libraries.Camera, EntryPoint = "camera_set_error_cb")]
 212         internal static extern CameraError SetErrorCallback(IntPtr handle, ErrorCallback callback, IntPtr userData = default);
 213
 214         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_error_cb")]
 215         internal static extern CameraError UnsetErrorCallback(IntPtr handle);
 216
 217         [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_hdr_capture_progress_cb")]
 218         internal static extern CameraError SetHdrCaptureProgressCallback(IntPtr handle, HdrCaptureProgressCallback callback, IntPtr userData = default);
 219
 220         [DllImport(Libraries.Camera, EntryPoint = "camera_attr_unset_hdr_capture_progress_cb")]
 221         internal static extern CameraError UnsetHdrCaptureProgressCallback(IntPtr handle);
 222
 223
 224         [NativeStruct("camera_image_data_s", Include="camera.h", PkgConfig="capi-media-camera")]
 225         [StructLayout(LayoutKind.Sequential)]
 226         internal struct StillImageDataStruct
 227         {
 228             internal IntPtr Data;
 229             internal uint DataLength;
 230             internal int Width;
 231             internal int Height;
 232             internal CameraPixelFormat Format;
 233             internal IntPtr Exif;
 234             internal uint ExifLength;
 235         }
 236
 237         [NativeStruct("camera_detected_face_s", Include="camera.h", PkgConfig="capi-media-camera")]
 238         [StructLayout(LayoutKind.Sequential)]
 239         internal struct DetectedFaceStruct
 240         {
 241             internal int Id;
 242             internal int Score;
 243             internal int X;
 244             internal int Y;
 245             internal int Width;
 246             internal int Height;
 247         }
 248
 249         [StructLayout(LayoutKind.Sequential)]
 250         internal struct SinglePlaneStruct
 251         {
 252             internal IntPtr Data;
 253             internal uint DataLength;
 254         }
 255
 256         [StructLayout(LayoutKind.Sequential)]
 257         internal struct DoublePlaneStruct
 258         {
 259             internal IntPtr Y;
 260             internal IntPtr UV;
 261             internal uint YLength;
 262             internal uint UVLength;
 263         }
 264
 265         [StructLayout(LayoutKind.Sequential)]
 266         internal struct TriplePlaneStruct
 267         {
 268             internal IntPtr Y;
 269             internal IntPtr U;
 270             internal IntPtr V;
 271             internal uint YLength;
 272             internal uint ULength;
 273             internal uint VLength;
 274         }
 275
 276         [StructLayout(LayoutKind.Sequential)]
 277         internal struct EncodedPlaneStruct
 278         {
 279             internal IntPtr Data;
 280             internal uint DataLength;
 281             internal bool IsDeltaFrame;
 282         }
 283
 284         [StructLayout(LayoutKind.Sequential)]
 285         internal struct DepthPlaneStruct
 286         {
 287             internal IntPtr Data;
 288             internal uint DataLength;
 289         }
 290
 291         [StructLayout(LayoutKind.Sequential)]
 292         internal struct RgbPlaneStruct
 293         {
 294             internal IntPtr Data;
 295             internal uint DataLength;
 296         }
 297
 298         [StructLayout(LayoutKind.Explicit)]
 299         internal struct PreviewPlaneStruct
 300         {
 301             [FieldOffsetAttribute(0)]
 302             internal SinglePlaneStruct SinglePlane;
 303             [FieldOffsetAttribute(0)]
 304             internal DoublePlaneStruct DoublePlane;
 305             [FieldOffsetAttribute(0)]
 306             internal TriplePlaneStruct TriplePlane;
 307             [FieldOffsetAttribute(0)]
 308             internal EncodedPlaneStruct EncodedPlane;
 309             [FieldOffsetAttribute(0)]
 310             internal DepthPlaneStruct DepthPlane;
 311             [FieldOffsetAttribute(0)]
 312             internal RgbPlaneStruct RgbPlane;
 313         }
 314
 315         [NativeStruct("camera_preview_data_s", Include="camera.h", PkgConfig="capi-media-camera")]
 316         [StructLayout(LayoutKind.Sequential)]
 317         internal struct CameraPreviewDataStruct
 318         {
 319             internal CameraPixelFormat Format;
 320             internal int Width;
 321             internal int Height;
 322             internal int NumOfPlanes;
 323             internal uint TimeStamp;
 324             internal PreviewPlaneStruct Plane;
 325         }
 326     }
 327
 328     internal static partial class CameraDeviceManager
 329     {
 330         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 331         internal delegate void DeviceConnectionChangedCallback(ref CameraDeviceStruct device, bool status, IntPtr userData);
 332
 333
 334         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_initialize")]
 335         internal static extern CameraError Initialize(out IntPtr handle);
 336
 337         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_deinitialize")]
 338         internal static extern CameraError Deinitialize(IntPtr handle);
 339
 340         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_get_device_list")]
 341         internal static extern CameraError GetDeviceList(IntPtr handle, ref CameraDeviceListStruct deviceList);
 342
 343         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_add_device_connection_changed_cb")]
 344         internal static extern CameraError SetDeviceConnectionChangedCallback(IntPtr handle, DeviceConnectionChangedCallback callback, IntPtr userData, out int id);
 345
 346         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_remove_device_connection_changed_cb")]
 347         internal static extern CameraError UnsetDeviceConnectionChangedCallback(IntPtr handle, int id);
 348
 349
 350         [NativeStruct("camera_device_s", Include="camera_internal.h", PkgConfig="capi-media-camera")]
 351         [StructLayout(LayoutKind.Sequential)]
 352         internal struct CameraDeviceStruct
 353         {
 354             internal CameraDeviceType Type;
 355
 356             internal CameraDevice device;
 357
 358             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
 359             internal string name;
 360
 361             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
 362             internal string id;
 363
 364             internal int extraStreamNum;
 365         }
 366
 367         [NativeStruct("camera_device_list_s", Include="camera_internal.h", PkgConfig="capi-media-camera")]
 368         [StructLayout(LayoutKind.Sequential)]
 369         internal struct CameraDeviceListStruct
 370         {
 371             internal uint count;
 372
 373             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
 374             internal CameraDeviceStruct[] device;
 375         }
 376     }
 377 }