src/Tizen.Multimedia.Vision/Interop/Interop.MediaVision.Common.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.Multimedia.Vision;
  20
  21 /// <summary>
  22 /// Interop APIs.
  23 /// </summary>
  24 internal static partial class Interop
  25 {
  26     internal static Tizen.Multimedia.Point ToApiStruct(this MediaVision.Point pt)
  27     {
  28         return new Tizen.Multimedia.Point(pt.x, pt.y);
  29     }
  30
  31     internal static MediaVision.Point ToMarshalable(this Tizen.Multimedia.Point pt)
  32     {
  33         return new MediaVision.Point() { x = pt.X, y = pt.Y };
  34     }
  35
  36     internal static MediaVision.Point[] ToMarshalable(Tizen.Multimedia.Point[] pts)
  37     {
  38         var result = new MediaVision.Point[pts.Length];
  39         for (int i = 0; i < pts.Length; ++i)
  40         {
  41             result[i] = pts[i].ToMarshalable();
  42         }
  43         return result;
  44     }
  45
  46
  47     internal static Quadrangle ToApiStruct(this MediaVision.Quadrangle quadrangle)
  48     {
  49         Tizen.Multimedia.Point[] points = new Tizen.Multimedia.Point[4];
  50         for (int i = 0; i < 4; ++i)
  51         {
  52             points[i] = quadrangle.points[i].ToApiStruct();
  53         }
  54         return new Quadrangle(points);
  55     }
  56
  57     internal static MediaVision.Quadrangle ToMarshalable(this Quadrangle quadrangle)
  58     {
  59         MediaVision.Point[] points = new MediaVision.Point[4];
  60         for (int i = 0; i < 4; ++i)
  61         {
  62             points[i] = quadrangle.Points[i].ToMarshalable();
  63         }
  64         return new MediaVision.Quadrangle() { points = points };
  65     }
  66
  67     internal static Tizen.Multimedia.Rectangle ToApiStruct(this MediaVision.Rectangle rectangle)
  68     {
  69         return new Tizen.Multimedia.Rectangle(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
  70     }
  71
  72     internal static MediaVision.Rectangle ToMarshalable(this Tizen.Multimedia.Rectangle rectangle)
  73     {
  74         return new MediaVision.Rectangle()
  75         {
  76             x = rectangle.X,
  77             y = rectangle.Y,
  78             width = rectangle.Width,
  79             height = rectangle.Height
  80         };
  81     }
  82
  83     internal static Tizen.Multimedia.Rectangle[] ToApiStruct(this MediaVision.Rectangle[] rects)
  84     {
  85         var result = new Tizen.Multimedia.Rectangle[rects.Length];
  86
  87         for (int i = 0; i < rects.Length; i++)
  88         {
  89             result[i] = rects[i].ToApiStruct();
  90         }
  91         return result;
  92     }
  93
  94     internal static MediaVision.Rectangle[] ToMarShalable(this Tizen.Multimedia.Rectangle[] rects)
  95     {
  96         var result = new MediaVision.Rectangle[rects.Length];
  97
  98         for (int i = 0; i < rects.Length; i++)
  99         {
 100             result[i] = rects[i].ToMarshalable();
 101         }
 102         return result;
 103     }
 104
 105     /// <summary>
 106     /// Interop for Media Vision APIs.
 107     /// </summary>
 108     internal static partial class MediaVision
 109     {
 110         [StructLayout(LayoutKind.Sequential)]
 111         internal struct Point
 112         {
 113             internal int x;
 114             internal int y;
 115         }
 116
 117         [StructLayout(LayoutKind.Sequential)]
 118         internal struct Rectangle
 119         {
 120             internal int x;
 121             internal int y;
 122             internal int width;
 123             internal int height;
 124         }
 125
 126         [StructLayout(LayoutKind.Sequential)]
 127         internal struct Quadrangle
 128         {
 129             [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
 130             internal Point[] points;
 131         }
 132
 133         /// <summary>
 134         /// Interop for Media Vision Source APIs.
 135         /// </summary>
 136         internal static partial class MediaSource
 137         {
 138             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_create_source")]
 139             internal static extern MediaVisionError Create(out IntPtr source);
 140
 141             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_destroy_source")]
 142             internal static extern int Destroy(IntPtr /* mv_source_h */ source);
 143
 144             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_fill_by_media_packet")]
 145             internal static extern MediaVisionError FillMediaPacket(IntPtr source, IntPtr mediaPacket);
 146
 147             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_fill_by_buffer")]
 148             internal static extern MediaVisionError FillBuffer(IntPtr source, byte[] buffer,
 149                 int bufferSize, uint imageWidth, uint imageHeight, VisionColorSpace colorspace);
 150
 151             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_clear")]
 152             internal static extern int Clear(IntPtr /* mv_source_h */ source);
 153
 154             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_get_buffer")]
 155             internal static extern MediaVisionError GetBuffer(IntPtr source, out IntPtr buffer, out int bufferSize);
 156
 157             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_get_height")]
 158             internal static extern int GetHeight(IntPtr source, out uint imageHeight);
 159
 160             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_get_width")]
 161             internal static extern int GetWidth(IntPtr source, out uint imageWidth);
 162
 163             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_source_get_colorspace")]
 164             internal static extern int GetColorspace(IntPtr /* mv_source_h */ source, out VisionColorSpace colorspace);
 165         }
 166
 167         /// <summary>
 168         /// Interop for Engine Configuration APIs.
 169         /// </summary>
 170         internal static partial class EngineConfig
 171         {
 172             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_create_engine_config")]
 173             internal static extern MediaVisionError Create(out IntPtr handle);
 174
 175             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_destroy_engine_config")]
 176             internal static extern int Destroy(IntPtr handle);
 177
 178             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_set_double_attribute")]
 179             internal static extern MediaVisionError SetDouble(IntPtr handle, string name, double value);
 180
 181             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_set_int_attribute")]
 182             internal static extern MediaVisionError SetInt(IntPtr handle, string name, int value);
 183
 184             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_set_bool_attribute")]
 185             internal static extern MediaVisionError SetBool(IntPtr handle, string name, bool value);
 186
 187             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_set_string_attribute")]
 188             internal static extern MediaVisionError SetString(IntPtr handle, string name, string value);
 189
 190             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_set_array_string_attribute")]
 191             internal static extern MediaVisionError SetStringArray(IntPtr handle, string name,
 192                 [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] string[] value, int size);
 193
 194             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_get_double_attribute")]
 195             internal static extern MediaVisionError GetDouble(IntPtr handle, string name, out double value);
 196
 197             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_get_int_attribute")]
 198             internal static extern MediaVisionError GetInt(IntPtr handle, string name, out int value);
 199
 200             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_get_bool_attribute")]
 201             internal static extern MediaVisionError GetBool(IntPtr handle, string name, out bool value);
 202
 203             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_get_string_attribute")]
 204             internal static extern MediaVisionError GetString(IntPtr handle, string name, out IntPtr value);
 205
 206             [DllImport(Libraries.MediaVisionCommon, EntryPoint = "mv_engine_config_get_array_string_attribute")]
 207             internal static extern MediaVisionError GetStringArray(IntPtr handle, string name,
 208                 out IntPtr value, out int size);
 209         }
 210     }
 211 }