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_preview_cb")]
 155         internal static extern CameraError SetPreviewCallback(IntPtr handle, PreviewCallback callback, IntPtr userData = default);
 156
 157         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_preview_cb")]
 158         internal static extern CameraError UnsetPreviewCallback(IntPtr handle);
 159
 160         [DllImport(Libraries.Camera, EntryPoint = "camera_set_media_packet_preview_cb")]
 161         internal static extern CameraError SetMediaPacketPreviewCallback(IntPtr handle, MediaPacketPreviewCallback callback, IntPtr userData = default);
 162
 163         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_media_packet_preview_cb")]
 164         internal static extern CameraError UnsetMediaPacketPreviewCallback(IntPtr handle);
 165
 166         [DllImport(Libraries.Camera, EntryPoint = "camera_set_extra_preview_cb")]
 167         internal static extern CameraError SetExtraPreviewCallback(IntPtr handle, ExtraPreviewCallback callback, IntPtr userData = default);
 168
 169         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_extra_preview_cb")]
 170         internal static extern CameraError UnsetExtraPreviewCallback(IntPtr handle);
 171
 172         [DllImport(Libraries.Camera, EntryPoint = "camera_set_state_changed_cb")]
 173         internal static extern CameraError SetStateChangedCallback(IntPtr handle, StateChangedCallback callback, IntPtr userData = default);
 174
 175         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_state_changed_cb")]
 176         internal static extern CameraError UnsetStateChangedCallback(IntPtr handle);
 177
 178         [DllImport(Libraries.Camera, EntryPoint = "camera_add_device_state_changed_cb")]
 179         internal static extern CameraError SetDeviceStateChangedCallback(DeviceStateChangedCallback callback, IntPtr userData, out int callbackId);
 180
 181         [DllImport(Libraries.Camera, EntryPoint = "camera_remove_device_state_changed_cb")]
 182         internal static extern CameraError UnsetDeviceStateChangedCallback(int cbId);
 183
 184         [DllImport(Libraries.Camera, EntryPoint = "camera_set_interrupt_started_cb")]
 185         internal static extern CameraError SetInterruptStartedCallback(IntPtr handle, InterruptStartedCallback callback, IntPtr userData = default);
 186
 187         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_interrupt_started_cb")]
 188         internal static extern CameraError UnsetInterruptStartedCallback(IntPtr handle);
 189
 190         [DllImport(Libraries.Camera, EntryPoint = "camera_set_interrupted_cb")]
 191         internal static extern CameraError SetInterruptedCallback(IntPtr handle, InterruptedCallback callback, IntPtr userData = default);
 192
 193         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_interrupted_cb")]
 194         internal static extern CameraError UnsetInterruptedCallback(IntPtr handle);
 195
 196         [DllImport(Libraries.Camera, EntryPoint = "camera_set_focus_changed_cb")]
 197         internal static extern CameraError SetFocusStateChangedCallback(IntPtr handle, FocusStateChangedCallback callback, IntPtr userData = default);
 198
 199         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_focus_changed_cb")]
 200         internal static extern CameraError UnsetFocusChangedCallback(IntPtr handle);
 201
 202         [DllImport(Libraries.Camera, EntryPoint = "camera_set_error_cb")]
 203         internal static extern CameraError SetErrorCallback(IntPtr handle, ErrorCallback callback, IntPtr userData = default);
 204
 205         [DllImport(Libraries.Camera, EntryPoint = "camera_unset_error_cb")]
 206         internal static extern CameraError UnsetErrorCallback(IntPtr handle);
 207
 208         [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_hdr_capture_progress_cb")]
 209         internal static extern CameraError SetHdrCaptureProgressCallback(IntPtr handle, HdrCaptureProgressCallback callback, IntPtr userData = default);
 210
 211         [DllImport(Libraries.Camera, EntryPoint = "camera_attr_unset_hdr_capture_progress_cb")]
 212         internal static extern CameraError UnsetHdrCaptureProgressCallback(IntPtr handle);
 213
 214         [NativeStruct("camera_image_data_s", Include="camera.h", PkgConfig="capi-media-camera")]
 215         [StructLayout(LayoutKind.Sequential)]
 216         internal struct StillImageDataStruct
 217         {
 218             internal IntPtr Data;
 219             internal uint DataLength;
 220             internal int Width;
 221             internal int Height;
 222             internal CameraPixelFormat Format;
 223             internal IntPtr Exif;
 224             internal uint ExifLength;
 225         }
 226
 227         [NativeStruct("camera_detected_face_s", Include="camera.h", PkgConfig="capi-media-camera")]
 228         [StructLayout(LayoutKind.Sequential)]
 229         internal struct DetectedFaceStruct
 230         {
 231             internal int Id;
 232             internal int Score;
 233             internal int X;
 234             internal int Y;
 235             internal int Width;
 236             internal int Height;
 237         }
 238
 239         [StructLayout(LayoutKind.Sequential)]
 240         internal struct SinglePlaneStruct
 241         {
 242             internal IntPtr Data;
 243             internal uint DataLength;
 244         }
 245
 246         [StructLayout(LayoutKind.Sequential)]
 247         internal struct DoublePlaneStruct
 248         {
 249             internal IntPtr Y;
 250             internal IntPtr UV;
 251             internal uint YLength;
 252             internal uint UVLength;
 253         }
 254
 255         [StructLayout(LayoutKind.Sequential)]
 256         internal struct TriplePlaneStruct
 257         {
 258             internal IntPtr Y;
 259             internal IntPtr U;
 260             internal IntPtr V;
 261             internal uint YLength;
 262             internal uint ULength;
 263             internal uint VLength;
 264         }
 265
 266         [StructLayout(LayoutKind.Sequential)]
 267         internal struct EncodedPlaneStruct
 268         {
 269             internal IntPtr Data;
 270             internal uint DataLength;
 271             internal bool IsDeltaFrame;
 272         }
 273
 274         [StructLayout(LayoutKind.Sequential)]
 275         internal struct DepthPlaneStruct
 276         {
 277             internal IntPtr Data;
 278             internal uint DataLength;
 279         }
 280
 281         [StructLayout(LayoutKind.Sequential)]
 282         internal struct RgbPlaneStruct
 283         {
 284             internal IntPtr Data;
 285             internal uint DataLength;
 286         }
 287
 288         [StructLayout(LayoutKind.Explicit)]
 289         internal struct PreviewPlaneStruct
 290         {
 291             [FieldOffsetAttribute(0)]
 292             internal SinglePlaneStruct SinglePlane;
 293             [FieldOffsetAttribute(0)]
 294             internal DoublePlaneStruct DoublePlane;
 295             [FieldOffsetAttribute(0)]
 296             internal TriplePlaneStruct TriplePlane;
 297             [FieldOffsetAttribute(0)]
 298             internal EncodedPlaneStruct EncodedPlane;
 299             [FieldOffsetAttribute(0)]
 300             internal DepthPlaneStruct DepthPlane;
 301             [FieldOffsetAttribute(0)]
 302             internal RgbPlaneStruct RgbPlane;
 303         }
 304
 305         [NativeStruct("camera_preview_data_s", Include="camera.h", PkgConfig="capi-media-camera")]
 306         [StructLayout(LayoutKind.Sequential)]
 307         internal struct CameraPreviewDataStruct
 308         {
 309             internal CameraPixelFormat Format;
 310             internal int Width;
 311             internal int Height;
 312             internal int NumOfPlanes;
 313             internal uint TimeStamp;
 314             internal PreviewPlaneStruct Plane;
 315         }
 316     }
 317
 318     internal static partial class CameraDeviceManager
 319     {
 320         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 321         internal delegate void DeviceConnectionChangedCallback(ref CameraDeviceStruct device, bool status, IntPtr userData);
 322
 323
 324         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_initialize")]
 325         internal static extern CameraError Initialize(out IntPtr handle);
 326
 327         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_deinitialize")]
 328         internal static extern CameraError Deinitialize(IntPtr handle);
 329
 330         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_get_device_list")]
 331         internal static extern CameraError GetDeviceList(IntPtr handle, ref CameraDeviceListStruct deviceList);
 332
 333         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_add_device_connection_changed_cb")]
 334         internal static extern CameraError SetDeviceConnectionChangedCallback(IntPtr handle, DeviceConnectionChangedCallback callback, IntPtr userData, out int id);
 335
 336         [DllImport(Libraries.Camera, EntryPoint = "camera_device_manager_remove_device_connection_changed_cb")]
 337         internal static extern CameraError UnsetDeviceConnectionChangedCallback(IntPtr handle, int id);
 338
 339
 340         [NativeStruct("camera_device_s", Include="camera_internal.h", PkgConfig="capi-media-camera")]
 341         [StructLayout(LayoutKind.Sequential)]
 342         internal struct CameraDeviceStruct
 343         {
 344             internal CameraDeviceType Type;
 345
 346             internal CameraDevice device;
 347
 348             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
 349             internal char[] name;
 350
 351             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
 352             internal char[] id;
 353         }
 354
 355         [NativeStruct("camera_device_list_s", Include="camera_internal.h", PkgConfig="capi-media-camera")]
 356         [StructLayout(LayoutKind.Sequential)]
 357         internal struct CameraDeviceListStruct
 358         {
 359             internal uint count;
 360
 361             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
 362             internal CameraDeviceStruct[] device;
 363         }
 364     }
 365 }