subprojects/gstreamer-sharp/sources/generated/Gst/BufferPool.cs

   1 // This file was generated by the Gtk# code generator.
   2 // Any changes made will be lost if regenerated.
   3
   4 namespace Gst {
   5
   6         using System;
   7         using System.Collections;
   8         using System.Collections.Generic;
   9         using System.Runtime.InteropServices;
  10
  11 #region Autogenerated code
  12         public partial class BufferPool : Gst.Object {
  13
  14                 public BufferPool (IntPtr raw) : base(raw) {}
  15
  16                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  17                 static extern IntPtr gst_buffer_pool_new();
  18
  19                 public BufferPool () : base (IntPtr.Zero)
  20                 {
  21                         if (GetType () != typeof (BufferPool)) {
  22                                 CreateNativeObject (new string [0], new GLib.Value[0]);
  23                                 return;
  24                         }
  25                         Raw = gst_buffer_pool_new();
  26                 }
  27
  28                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  29                 static extern void gst_buffer_pool_set_flushing(IntPtr raw, bool flushing);
  30
  31                 public bool Flushing {
  32                         get {
  33                                 unsafe {
  34                                         bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("flushing"));
  35                                         return (*raw_ptr);
  36                                 }
  37                         }
  38                         set  {
  39                                 gst_buffer_pool_set_flushing(Handle, value);
  40                         }
  41                 }
  42
  43                 static GetOptionsNativeDelegate GetOptions_cb_delegate;
  44                 static GetOptionsNativeDelegate GetOptionsVMCallback {
  45                         get {
  46                                 if (GetOptions_cb_delegate == null)
  47                                         GetOptions_cb_delegate = new GetOptionsNativeDelegate (GetOptions_cb);
  48                                 return GetOptions_cb_delegate;
  49                         }
  50                 }
  51
  52                 static void OverrideGetOptions (GLib.GType gtype)
  53                 {
  54                         OverrideGetOptions (gtype, GetOptionsVMCallback);
  55                 }
  56
  57                 static void OverrideGetOptions (GLib.GType gtype, GetOptionsNativeDelegate callback)
  58                 {
  59                         unsafe {
  60                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_options"));
  61                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  62                         }
  63                 }
  64
  65                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  66                 delegate IntPtr GetOptionsNativeDelegate (IntPtr inst);
  67
  68                 static IntPtr GetOptions_cb (IntPtr inst)
  69                 {
  70                         try {
  71                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
  72                                 string[] __result;
  73                                 __result = __obj.OnGetOptions ();
  74                                 return GLib.Marshaller.StringArrayToNullTermStrvPointer (__result);
  75                         } catch (Exception e) {
  76                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
  77                                 // NOTREACHED: above call does not return.
  78                                 throw e;
  79                         }
  80                 }
  81
  82                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideGetOptions")]
  83                 protected virtual string[] OnGetOptions ()
  84                 {
  85                         return InternalGetOptions ();
  86                 }
  87
  88                 private string[] InternalGetOptions ()
  89                 {
  90                         GetOptionsNativeDelegate unmanaged = null;
  91                         unsafe {
  92                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_options"));
  93                                 unmanaged = (GetOptionsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetOptionsNativeDelegate));
  94                         }
  95                         if (unmanaged == null) return null;
  96
  97                         IntPtr __result = unmanaged (this.Handle);
  98                         return GLib.Marshaller.NullTermPtrToStringArray (__result, false);
  99                 }
 100
 101                 static SetConfigNativeDelegate SetConfig_cb_delegate;
 102                 static SetConfigNativeDelegate SetConfigVMCallback {
 103                         get {
 104                                 if (SetConfig_cb_delegate == null)
 105                                         SetConfig_cb_delegate = new SetConfigNativeDelegate (SetConfig_cb);
 106                                 return SetConfig_cb_delegate;
 107                         }
 108                 }
 109
 110                 static void OverrideSetConfig (GLib.GType gtype)
 111                 {
 112                         OverrideSetConfig (gtype, SetConfigVMCallback);
 113                 }
 114
 115                 static void OverrideSetConfig (GLib.GType gtype, SetConfigNativeDelegate callback)
 116                 {
 117                         unsafe {
 118                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_config"));
 119                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 120                         }
 121                 }
 122
 123                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 124                 delegate bool SetConfigNativeDelegate (IntPtr inst, IntPtr config);
 125
 126                 static bool SetConfig_cb (IntPtr inst, IntPtr config)
 127                 {
 128                         try {
 129                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 130                                 bool __result;
 131                                 __result = __obj.OnSetConfig (config == IntPtr.Zero ? null : (Gst.Structure) GLib.Opaque.GetOpaque (config, typeof (Gst.Structure), true));
 132                                 return __result;
 133                         } catch (Exception e) {
 134                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 135                                 // NOTREACHED: above call does not return.
 136                                 throw e;
 137                         }
 138                 }
 139
 140                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideSetConfig")]
 141                 protected virtual bool OnSetConfig (Gst.Structure config)
 142                 {
 143                         return InternalSetConfig (config);
 144                 }
 145
 146                 private bool InternalSetConfig (Gst.Structure config)
 147                 {
 148                         SetConfigNativeDelegate unmanaged = null;
 149                         unsafe {
 150                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_config"));
 151                                 unmanaged = (SetConfigNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetConfigNativeDelegate));
 152                         }
 153                         if (unmanaged == null) return false;
 154
 155                         config.Owned = false;
 156                         bool __result = unmanaged (this.Handle, config == null ? IntPtr.Zero : config.Handle);
 157                         return __result;
 158                 }
 159
 160                 static StartNativeDelegate Start_cb_delegate;
 161                 static StartNativeDelegate StartVMCallback {
 162                         get {
 163                                 if (Start_cb_delegate == null)
 164                                         Start_cb_delegate = new StartNativeDelegate (Start_cb);
 165                                 return Start_cb_delegate;
 166                         }
 167                 }
 168
 169                 static void OverrideStart (GLib.GType gtype)
 170                 {
 171                         OverrideStart (gtype, StartVMCallback);
 172                 }
 173
 174                 static void OverrideStart (GLib.GType gtype, StartNativeDelegate callback)
 175                 {
 176                         unsafe {
 177                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("start"));
 178                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 179                         }
 180                 }
 181
 182                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 183                 delegate bool StartNativeDelegate (IntPtr inst);
 184
 185                 static bool Start_cb (IntPtr inst)
 186                 {
 187                         try {
 188                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 189                                 bool __result;
 190                                 __result = __obj.OnStart ();
 191                                 return __result;
 192                         } catch (Exception e) {
 193                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 194                                 // NOTREACHED: above call does not return.
 195                                 throw e;
 196                         }
 197                 }
 198
 199                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideStart")]
 200                 protected virtual bool OnStart ()
 201                 {
 202                         return InternalStart ();
 203                 }
 204
 205                 private bool InternalStart ()
 206                 {
 207                         StartNativeDelegate unmanaged = null;
 208                         unsafe {
 209                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("start"));
 210                                 unmanaged = (StartNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StartNativeDelegate));
 211                         }
 212                         if (unmanaged == null) return false;
 213
 214                         bool __result = unmanaged (this.Handle);
 215                         return __result;
 216                 }
 217
 218                 static StopNativeDelegate Stop_cb_delegate;
 219                 static StopNativeDelegate StopVMCallback {
 220                         get {
 221                                 if (Stop_cb_delegate == null)
 222                                         Stop_cb_delegate = new StopNativeDelegate (Stop_cb);
 223                                 return Stop_cb_delegate;
 224                         }
 225                 }
 226
 227                 static void OverrideStop (GLib.GType gtype)
 228                 {
 229                         OverrideStop (gtype, StopVMCallback);
 230                 }
 231
 232                 static void OverrideStop (GLib.GType gtype, StopNativeDelegate callback)
 233                 {
 234                         unsafe {
 235                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("stop"));
 236                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 237                         }
 238                 }
 239
 240                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 241                 delegate bool StopNativeDelegate (IntPtr inst);
 242
 243                 static bool Stop_cb (IntPtr inst)
 244                 {
 245                         try {
 246                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 247                                 bool __result;
 248                                 __result = __obj.OnStop ();
 249                                 return __result;
 250                         } catch (Exception e) {
 251                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 252                                 // NOTREACHED: above call does not return.
 253                                 throw e;
 254                         }
 255                 }
 256
 257                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideStop")]
 258                 protected virtual bool OnStop ()
 259                 {
 260                         return InternalStop ();
 261                 }
 262
 263                 private bool InternalStop ()
 264                 {
 265                         StopNativeDelegate unmanaged = null;
 266                         unsafe {
 267                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("stop"));
 268                                 unmanaged = (StopNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StopNativeDelegate));
 269                         }
 270                         if (unmanaged == null) return false;
 271
 272                         bool __result = unmanaged (this.Handle);
 273                         return __result;
 274                 }
 275
 276                 static AcquireBufferNativeDelegate AcquireBuffer_cb_delegate;
 277                 static AcquireBufferNativeDelegate AcquireBufferVMCallback {
 278                         get {
 279                                 if (AcquireBuffer_cb_delegate == null)
 280                                         AcquireBuffer_cb_delegate = new AcquireBufferNativeDelegate (AcquireBuffer_cb);
 281                                 return AcquireBuffer_cb_delegate;
 282                         }
 283                 }
 284
 285                 static void OverrideAcquireBuffer (GLib.GType gtype)
 286                 {
 287                         OverrideAcquireBuffer (gtype, AcquireBufferVMCallback);
 288                 }
 289
 290                 static void OverrideAcquireBuffer (GLib.GType gtype, AcquireBufferNativeDelegate callback)
 291                 {
 292                         unsafe {
 293                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("acquire_buffer"));
 294                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 295                         }
 296                 }
 297
 298                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 299                 delegate int AcquireBufferNativeDelegate (IntPtr inst, out IntPtr buffer, IntPtr parms);
 300
 301                 static int AcquireBuffer_cb (IntPtr inst, out IntPtr buffer, IntPtr parms)
 302                 {
 303                         try {
 304                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 305                                 Gst.FlowReturn __result;
 306                                 Gst.Buffer mybuffer;
 307                                 __result = __obj.OnAcquireBuffer (out mybuffer, Gst.BufferPoolAcquireParams.New (parms));
 308                                 buffer = mybuffer == null ? IntPtr.Zero : mybuffer.Handle;
 309                                 return (int) __result;
 310                         } catch (Exception e) {
 311                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 312                                 // NOTREACHED: above call does not return.
 313                                 throw e;
 314                         }
 315                 }
 316
 317                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideAcquireBuffer")]
 318                 protected virtual Gst.FlowReturn OnAcquireBuffer (out Gst.Buffer buffer, Gst.BufferPoolAcquireParams parms)
 319                 {
 320                         return InternalAcquireBuffer (out buffer, parms);
 321                 }
 322
 323                 private Gst.FlowReturn InternalAcquireBuffer (out Gst.Buffer buffer, Gst.BufferPoolAcquireParams parms)
 324                 {
 325                         AcquireBufferNativeDelegate unmanaged = null;
 326                         unsafe {
 327                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("acquire_buffer"));
 328                                 unmanaged = (AcquireBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AcquireBufferNativeDelegate));
 329                         }
 330                         if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
 331
 332                         IntPtr native_buffer;
 333                         IntPtr native_parms = GLib.Marshaller.StructureToPtrAlloc (parms);
 334                         int __result = unmanaged (this.Handle, out native_buffer, native_parms);
 335                         buffer = native_buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_buffer, typeof (Gst.Buffer), true);
 336                         Marshal.FreeHGlobal (native_parms);
 337                         return (Gst.FlowReturn) __result;
 338                 }
 339
 340                 static AllocBufferNativeDelegate AllocBuffer_cb_delegate;
 341                 static AllocBufferNativeDelegate AllocBufferVMCallback {
 342                         get {
 343                                 if (AllocBuffer_cb_delegate == null)
 344                                         AllocBuffer_cb_delegate = new AllocBufferNativeDelegate (AllocBuffer_cb);
 345                                 return AllocBuffer_cb_delegate;
 346                         }
 347                 }
 348
 349                 static void OverrideAllocBuffer (GLib.GType gtype)
 350                 {
 351                         OverrideAllocBuffer (gtype, AllocBufferVMCallback);
 352                 }
 353
 354                 static void OverrideAllocBuffer (GLib.GType gtype, AllocBufferNativeDelegate callback)
 355                 {
 356                         unsafe {
 357                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("alloc_buffer"));
 358                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 359                         }
 360                 }
 361
 362                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 363                 delegate int AllocBufferNativeDelegate (IntPtr inst, IntPtr buffer, IntPtr parms);
 364
 365                 static int AllocBuffer_cb (IntPtr inst, IntPtr buffer, IntPtr parms)
 366                 {
 367                         try {
 368                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 369                                 Gst.FlowReturn __result;
 370                                 __result = __obj.OnAllocBuffer (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false), Gst.BufferPoolAcquireParams.New (parms));
 371                                 return (int) __result;
 372                         } catch (Exception e) {
 373                                 GLib.ExceptionManager.RaiseUnhandledException (e, true);
 374                                 // NOTREACHED: above call does not return.
 375                                 throw e;
 376                         }
 377                 }
 378
 379                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideAllocBuffer")]
 380                 protected virtual Gst.FlowReturn OnAllocBuffer (Gst.Buffer buffer, Gst.BufferPoolAcquireParams parms)
 381                 {
 382                         return InternalAllocBuffer (buffer, parms);
 383                 }
 384
 385                 private Gst.FlowReturn InternalAllocBuffer (Gst.Buffer buffer, Gst.BufferPoolAcquireParams parms)
 386                 {
 387                         AllocBufferNativeDelegate unmanaged = null;
 388                         unsafe {
 389                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("alloc_buffer"));
 390                                 unmanaged = (AllocBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AllocBufferNativeDelegate));
 391                         }
 392                         if (unmanaged == null) return (Gst.FlowReturn) 0;
 393
 394                         IntPtr native_parms = GLib.Marshaller.StructureToPtrAlloc (parms);
 395                         int __result = unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle, native_parms);
 396                         Marshal.FreeHGlobal (native_parms);
 397                         return (Gst.FlowReturn) __result;
 398                 }
 399
 400                 static ResetBufferNativeDelegate ResetBuffer_cb_delegate;
 401                 static ResetBufferNativeDelegate ResetBufferVMCallback {
 402                         get {
 403                                 if (ResetBuffer_cb_delegate == null)
 404                                         ResetBuffer_cb_delegate = new ResetBufferNativeDelegate (ResetBuffer_cb);
 405                                 return ResetBuffer_cb_delegate;
 406                         }
 407                 }
 408
 409                 static void OverrideResetBuffer (GLib.GType gtype)
 410                 {
 411                         OverrideResetBuffer (gtype, ResetBufferVMCallback);
 412                 }
 413
 414                 static void OverrideResetBuffer (GLib.GType gtype, ResetBufferNativeDelegate callback)
 415                 {
 416                         unsafe {
 417                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("reset_buffer"));
 418                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 419                         }
 420                 }
 421
 422                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 423                 delegate void ResetBufferNativeDelegate (IntPtr inst, IntPtr buffer);
 424
 425                 static void ResetBuffer_cb (IntPtr inst, IntPtr buffer)
 426                 {
 427                         try {
 428                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 429                                 __obj.OnResetBuffer (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false));
 430                         } catch (Exception e) {
 431                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 432                         }
 433                 }
 434
 435                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideResetBuffer")]
 436                 protected virtual void OnResetBuffer (Gst.Buffer buffer)
 437                 {
 438                         InternalResetBuffer (buffer);
 439                 }
 440
 441                 private void InternalResetBuffer (Gst.Buffer buffer)
 442                 {
 443                         ResetBufferNativeDelegate unmanaged = null;
 444                         unsafe {
 445                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("reset_buffer"));
 446                                 unmanaged = (ResetBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ResetBufferNativeDelegate));
 447                         }
 448                         if (unmanaged == null) return;
 449
 450                         unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
 451                 }
 452
 453                 static ReleaseBufferNativeDelegate ReleaseBuffer_cb_delegate;
 454                 static ReleaseBufferNativeDelegate ReleaseBufferVMCallback {
 455                         get {
 456                                 if (ReleaseBuffer_cb_delegate == null)
 457                                         ReleaseBuffer_cb_delegate = new ReleaseBufferNativeDelegate (ReleaseBuffer_cb);
 458                                 return ReleaseBuffer_cb_delegate;
 459                         }
 460                 }
 461
 462                 static void OverrideReleaseBuffer (GLib.GType gtype)
 463                 {
 464                         OverrideReleaseBuffer (gtype, ReleaseBufferVMCallback);
 465                 }
 466
 467                 static void OverrideReleaseBuffer (GLib.GType gtype, ReleaseBufferNativeDelegate callback)
 468                 {
 469                         unsafe {
 470                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("release_buffer"));
 471                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 472                         }
 473                 }
 474
 475                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 476                 delegate void ReleaseBufferNativeDelegate (IntPtr inst, IntPtr buffer);
 477
 478                 static void ReleaseBuffer_cb (IntPtr inst, IntPtr buffer)
 479                 {
 480                         try {
 481                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 482                                 __obj.OnReleaseBuffer (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), true));
 483                         } catch (Exception e) {
 484                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 485                         }
 486                 }
 487
 488                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideReleaseBuffer")]
 489                 protected virtual void OnReleaseBuffer (Gst.Buffer buffer)
 490                 {
 491                         InternalReleaseBuffer (buffer);
 492                 }
 493
 494                 private void InternalReleaseBuffer (Gst.Buffer buffer)
 495                 {
 496                         ReleaseBufferNativeDelegate unmanaged = null;
 497                         unsafe {
 498                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("release_buffer"));
 499                                 unmanaged = (ReleaseBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ReleaseBufferNativeDelegate));
 500                         }
 501                         if (unmanaged == null) return;
 502
 503                         buffer.Owned = false;
 504                         unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
 505                 }
 506
 507                 static FreeBufferNativeDelegate FreeBuffer_cb_delegate;
 508                 static FreeBufferNativeDelegate FreeBufferVMCallback {
 509                         get {
 510                                 if (FreeBuffer_cb_delegate == null)
 511                                         FreeBuffer_cb_delegate = new FreeBufferNativeDelegate (FreeBuffer_cb);
 512                                 return FreeBuffer_cb_delegate;
 513                         }
 514                 }
 515
 516                 static void OverrideFreeBuffer (GLib.GType gtype)
 517                 {
 518                         OverrideFreeBuffer (gtype, FreeBufferVMCallback);
 519                 }
 520
 521                 static void OverrideFreeBuffer (GLib.GType gtype, FreeBufferNativeDelegate callback)
 522                 {
 523                         unsafe {
 524                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("free_buffer"));
 525                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 526                         }
 527                 }
 528
 529                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 530                 delegate void FreeBufferNativeDelegate (IntPtr inst, IntPtr buffer);
 531
 532                 static void FreeBuffer_cb (IntPtr inst, IntPtr buffer)
 533                 {
 534                         try {
 535                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 536                                 __obj.OnFreeBuffer (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false));
 537                         } catch (Exception e) {
 538                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 539                         }
 540                 }
 541
 542                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideFreeBuffer")]
 543                 protected virtual void OnFreeBuffer (Gst.Buffer buffer)
 544                 {
 545                         InternalFreeBuffer (buffer);
 546                 }
 547
 548                 private void InternalFreeBuffer (Gst.Buffer buffer)
 549                 {
 550                         FreeBufferNativeDelegate unmanaged = null;
 551                         unsafe {
 552                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("free_buffer"));
 553                                 unmanaged = (FreeBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FreeBufferNativeDelegate));
 554                         }
 555                         if (unmanaged == null) return;
 556
 557                         unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
 558                 }
 559
 560                 static FlushStartNativeDelegate FlushStart_cb_delegate;
 561                 static FlushStartNativeDelegate FlushStartVMCallback {
 562                         get {
 563                                 if (FlushStart_cb_delegate == null)
 564                                         FlushStart_cb_delegate = new FlushStartNativeDelegate (FlushStart_cb);
 565                                 return FlushStart_cb_delegate;
 566                         }
 567                 }
 568
 569                 static void OverrideFlushStart (GLib.GType gtype)
 570                 {
 571                         OverrideFlushStart (gtype, FlushStartVMCallback);
 572                 }
 573
 574                 static void OverrideFlushStart (GLib.GType gtype, FlushStartNativeDelegate callback)
 575                 {
 576                         unsafe {
 577                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("flush_start"));
 578                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 579                         }
 580                 }
 581
 582                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 583                 delegate void FlushStartNativeDelegate (IntPtr inst);
 584
 585                 static void FlushStart_cb (IntPtr inst)
 586                 {
 587                         try {
 588                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 589                                 __obj.OnFlushStart ();
 590                         } catch (Exception e) {
 591                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 592                         }
 593                 }
 594
 595                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideFlushStart")]
 596                 protected virtual void OnFlushStart ()
 597                 {
 598                         InternalFlushStart ();
 599                 }
 600
 601                 private void InternalFlushStart ()
 602                 {
 603                         FlushStartNativeDelegate unmanaged = null;
 604                         unsafe {
 605                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("flush_start"));
 606                                 unmanaged = (FlushStartNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FlushStartNativeDelegate));
 607                         }
 608                         if (unmanaged == null) return;
 609
 610                         unmanaged (this.Handle);
 611                 }
 612
 613                 static FlushStopNativeDelegate FlushStop_cb_delegate;
 614                 static FlushStopNativeDelegate FlushStopVMCallback {
 615                         get {
 616                                 if (FlushStop_cb_delegate == null)
 617                                         FlushStop_cb_delegate = new FlushStopNativeDelegate (FlushStop_cb);
 618                                 return FlushStop_cb_delegate;
 619                         }
 620                 }
 621
 622                 static void OverrideFlushStop (GLib.GType gtype)
 623                 {
 624                         OverrideFlushStop (gtype, FlushStopVMCallback);
 625                 }
 626
 627                 static void OverrideFlushStop (GLib.GType gtype, FlushStopNativeDelegate callback)
 628                 {
 629                         unsafe {
 630                                 IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("flush_stop"));
 631                                 *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
 632                         }
 633                 }
 634
 635                 [UnmanagedFunctionPointer (CallingConvention.Cdecl)]
 636                 delegate void FlushStopNativeDelegate (IntPtr inst);
 637
 638                 static void FlushStop_cb (IntPtr inst)
 639                 {
 640                         try {
 641                                 BufferPool __obj = GLib.Object.GetObject (inst, false) as BufferPool;
 642                                 __obj.OnFlushStop ();
 643                         } catch (Exception e) {
 644                                 GLib.ExceptionManager.RaiseUnhandledException (e, false);
 645                         }
 646                 }
 647
 648                 [GLib.DefaultSignalHandler(Type=typeof(Gst.BufferPool), ConnectionMethod="OverrideFlushStop")]
 649                 protected virtual void OnFlushStop ()
 650                 {
 651                         InternalFlushStop ();
 652                 }
 653
 654                 private void InternalFlushStop ()
 655                 {
 656                         FlushStopNativeDelegate unmanaged = null;
 657                         unsafe {
 658                                 IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("flush_stop"));
 659                                 unmanaged = (FlushStopNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FlushStopNativeDelegate));
 660                         }
 661                         if (unmanaged == null) return;
 662
 663                         unmanaged (this.Handle);
 664                 }
 665
 666
 667                 // Internal representation of the wrapped structure ABI.
 668                 static GLib.AbiStruct _class_abi = null;
 669                 static public new GLib.AbiStruct class_abi {
 670                         get {
 671                                 if (_class_abi == null)
 672                                         _class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{
 673                                                 new GLib.AbiField("get_options"
 674                                                         , Gst.Object.class_abi.Fields
 675                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // get_options
 676                                                         , null
 677                                                         , "set_config"
 678                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 679                                                         , 0
 680                                                         ),
 681                                                 new GLib.AbiField("set_config"
 682                                                         , -1
 683                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // set_config
 684                                                         , "get_options"
 685                                                         , "start"
 686                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 687                                                         , 0
 688                                                         ),
 689                                                 new GLib.AbiField("start"
 690                                                         , -1
 691                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // start
 692                                                         , "set_config"
 693                                                         , "stop"
 694                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 695                                                         , 0
 696                                                         ),
 697                                                 new GLib.AbiField("stop"
 698                                                         , -1
 699                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // stop
 700                                                         , "start"
 701                                                         , "acquire_buffer"
 702                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 703                                                         , 0
 704                                                         ),
 705                                                 new GLib.AbiField("acquire_buffer"
 706                                                         , -1
 707                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // acquire_buffer
 708                                                         , "stop"
 709                                                         , "alloc_buffer"
 710                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 711                                                         , 0
 712                                                         ),
 713                                                 new GLib.AbiField("alloc_buffer"
 714                                                         , -1
 715                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // alloc_buffer
 716                                                         , "acquire_buffer"
 717                                                         , "reset_buffer"
 718                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 719                                                         , 0
 720                                                         ),
 721                                                 new GLib.AbiField("reset_buffer"
 722                                                         , -1
 723                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // reset_buffer
 724                                                         , "alloc_buffer"
 725                                                         , "release_buffer"
 726                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 727                                                         , 0
 728                                                         ),
 729                                                 new GLib.AbiField("release_buffer"
 730                                                         , -1
 731                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // release_buffer
 732                                                         , "reset_buffer"
 733                                                         , "free_buffer"
 734                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 735                                                         , 0
 736                                                         ),
 737                                                 new GLib.AbiField("free_buffer"
 738                                                         , -1
 739                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // free_buffer
 740                                                         , "release_buffer"
 741                                                         , "flush_start"
 742                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 743                                                         , 0
 744                                                         ),
 745                                                 new GLib.AbiField("flush_start"
 746                                                         , -1
 747                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // flush_start
 748                                                         , "free_buffer"
 749                                                         , "flush_stop"
 750                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 751                                                         , 0
 752                                                         ),
 753                                                 new GLib.AbiField("flush_stop"
 754                                                         , -1
 755                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // flush_stop
 756                                                         , "flush_start"
 757                                                         , "_gst_reserved"
 758                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 759                                                         , 0
 760                                                         ),
 761                                                 new GLib.AbiField("_gst_reserved"
 762                                                         , -1
 763                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) * 2 // _gst_reserved
 764                                                         , "flush_stop"
 765                                                         , null
 766                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 767                                                         , 0
 768                                                         ),
 769                                         });
 770
 771                                 return _class_abi;
 772                         }
 773                 }
 774
 775
 776                 // End of the ABI representation.
 777
 778                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 779                 static extern IntPtr gst_buffer_pool_get_type();
 780
 781                 public static new GLib.GType GType {
 782                         get {
 783                                 IntPtr raw_ret = gst_buffer_pool_get_type();
 784                                 GLib.GType ret = new GLib.GType(raw_ret);
 785                                 return ret;
 786                         }
 787                 }
 788
 789                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 790                 static extern void gst_buffer_pool_config_add_option(IntPtr config, IntPtr option);
 791
 792                 public static void ConfigAddOption(Gst.Structure config, string option) {
 793                         IntPtr native_option = GLib.Marshaller.StringToPtrGStrdup (option);
 794                         gst_buffer_pool_config_add_option(config == null ? IntPtr.Zero : config.Handle, native_option);
 795                         GLib.Marshaller.Free (native_option);
 796                 }
 797
 798                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 799                 static extern bool gst_buffer_pool_config_get_allocator(IntPtr config, out IntPtr allocator, IntPtr parms);
 800
 801                 public static bool ConfigGetAllocator(Gst.Structure config, out Gst.Allocator allocator, out Gst.AllocationParams parms) {
 802                         IntPtr native_allocator;
 803                         IntPtr native_parms = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (Gst.AllocationParams)));
 804                         bool raw_ret = gst_buffer_pool_config_get_allocator(config == null ? IntPtr.Zero : config.Handle, out native_allocator, native_parms);
 805                         bool ret = raw_ret;
 806                         allocator = GLib.Object.GetObject(native_allocator) as Gst.Allocator;
 807                         parms = Gst.AllocationParams.New (native_parms);
 808                         Marshal.FreeHGlobal (native_parms);
 809                         return ret;
 810                 }
 811
 812                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 813                 static extern IntPtr gst_buffer_pool_config_get_option(IntPtr config, uint index);
 814
 815                 public static string ConfigGetOption(Gst.Structure config, uint index) {
 816                         IntPtr raw_ret = gst_buffer_pool_config_get_option(config == null ? IntPtr.Zero : config.Handle, index);
 817                         string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
 818                         return ret;
 819                 }
 820
 821                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 822                 static extern bool gst_buffer_pool_config_get_params(IntPtr config, out IntPtr caps, out uint size, out uint min_buffers, out uint max_buffers);
 823
 824                 public static bool ConfigGetParams(Gst.Structure config, out Gst.Caps caps, out uint size, out uint min_buffers, out uint max_buffers) {
 825                         IntPtr native_caps;
 826                         bool raw_ret = gst_buffer_pool_config_get_params(config == null ? IntPtr.Zero : config.Handle, out native_caps, out size, out min_buffers, out max_buffers);
 827                         bool ret = raw_ret;
 828                         caps = native_caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (native_caps, typeof (Gst.Caps), false);
 829                         return ret;
 830                 }
 831
 832                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 833                 static extern bool gst_buffer_pool_config_has_option(IntPtr config, IntPtr option);
 834
 835                 public static bool ConfigHasOption(Gst.Structure config, string option) {
 836                         IntPtr native_option = GLib.Marshaller.StringToPtrGStrdup (option);
 837                         bool raw_ret = gst_buffer_pool_config_has_option(config == null ? IntPtr.Zero : config.Handle, native_option);
 838                         bool ret = raw_ret;
 839                         GLib.Marshaller.Free (native_option);
 840                         return ret;
 841                 }
 842
 843                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 844                 static extern uint gst_buffer_pool_config_n_options(IntPtr config);
 845
 846                 public static uint ConfigNOptions(Gst.Structure config) {
 847                         uint raw_ret = gst_buffer_pool_config_n_options(config == null ? IntPtr.Zero : config.Handle);
 848                         uint ret = raw_ret;
 849                         return ret;
 850                 }
 851
 852                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 853                 static extern void gst_buffer_pool_config_set_allocator(IntPtr config, IntPtr allocator, IntPtr parms);
 854
 855                 public static void ConfigSetAllocator(Gst.Structure config, Gst.Allocator allocator, Gst.AllocationParams parms) {
 856                         IntPtr native_parms = GLib.Marshaller.StructureToPtrAlloc (parms);
 857                         gst_buffer_pool_config_set_allocator(config == null ? IntPtr.Zero : config.Handle, allocator == null ? IntPtr.Zero : allocator.Handle, native_parms);
 858                         Marshal.FreeHGlobal (native_parms);
 859                 }
 860
 861                 public static void ConfigSetAllocator(Gst.Structure config) {
 862                         ConfigSetAllocator (config, null, Gst.AllocationParams.Zero);
 863                 }
 864
 865                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 866                 static extern void gst_buffer_pool_config_set_params(IntPtr config, IntPtr caps, uint size, uint min_buffers, uint max_buffers);
 867
 868                 public static void ConfigSetParams(Gst.Structure config, Gst.Caps caps, uint size, uint min_buffers, uint max_buffers) {
 869                         gst_buffer_pool_config_set_params(config == null ? IntPtr.Zero : config.Handle, caps == null ? IntPtr.Zero : caps.Handle, size, min_buffers, max_buffers);
 870                 }
 871
 872                 public static void ConfigSetParams(Gst.Structure config, uint size, uint min_buffers, uint max_buffers) {
 873                         ConfigSetParams (config, null, size, min_buffers, max_buffers);
 874                 }
 875
 876                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 877                 static extern bool gst_buffer_pool_config_validate_params(IntPtr config, IntPtr caps, uint size, uint min_buffers, uint max_buffers);
 878
 879                 public static bool ConfigValidateParams(Gst.Structure config, Gst.Caps caps, uint size, uint min_buffers, uint max_buffers) {
 880                         bool raw_ret = gst_buffer_pool_config_validate_params(config == null ? IntPtr.Zero : config.Handle, caps == null ? IntPtr.Zero : caps.Handle, size, min_buffers, max_buffers);
 881                         bool ret = raw_ret;
 882                         return ret;
 883                 }
 884
 885                 public static bool ConfigValidateParams(Gst.Structure config, uint size, uint min_buffers, uint max_buffers) {
 886                         return ConfigValidateParams (config, null, size, min_buffers, max_buffers);
 887                 }
 888
 889                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 890                 static extern int gst_buffer_pool_acquire_buffer(IntPtr raw, out IntPtr buffer, IntPtr parms);
 891
 892                 public Gst.FlowReturn AcquireBuffer(out Gst.Buffer buffer, Gst.BufferPoolAcquireParams parms) {
 893                         IntPtr native_buffer;
 894                         IntPtr native_parms = GLib.Marshaller.StructureToPtrAlloc (parms);
 895                         int raw_ret = gst_buffer_pool_acquire_buffer(Handle, out native_buffer, native_parms);
 896                         Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
 897                         buffer = native_buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_buffer, typeof (Gst.Buffer), true);
 898                         Marshal.FreeHGlobal (native_parms);
 899                         return ret;
 900                 }
 901
 902                 public Gst.FlowReturn AcquireBuffer(out Gst.Buffer buffer) {
 903                         return AcquireBuffer (out buffer, Gst.BufferPoolAcquireParams.Zero);
 904                 }
 905
 906                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 907                 static extern IntPtr gst_buffer_pool_get_config(IntPtr raw);
 908
 909                 public Gst.Structure Config {
 910                         get {
 911                                 IntPtr raw_ret = gst_buffer_pool_get_config(Handle);
 912                                 Gst.Structure ret = raw_ret == IntPtr.Zero ? null : (Gst.Structure) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Structure), true);
 913                                 return ret;
 914                         }
 915                 }
 916
 917                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 918                 static extern IntPtr gst_buffer_pool_get_options(IntPtr raw);
 919
 920                 public string[] Options {
 921                         get {
 922                                 IntPtr raw_ret = gst_buffer_pool_get_options(Handle);
 923                                 string[] ret = GLib.Marshaller.NullTermPtrToStringArray (raw_ret, false);
 924                                 return ret;
 925                         }
 926                 }
 927
 928                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 929                 static extern bool gst_buffer_pool_has_option(IntPtr raw, IntPtr option);
 930
 931                 public bool HasOption(string option) {
 932                         IntPtr native_option = GLib.Marshaller.StringToPtrGStrdup (option);
 933                         bool raw_ret = gst_buffer_pool_has_option(Handle, native_option);
 934                         bool ret = raw_ret;
 935                         GLib.Marshaller.Free (native_option);
 936                         return ret;
 937                 }
 938
 939                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 940                 static extern bool gst_buffer_pool_is_active(IntPtr raw);
 941
 942                 public bool IsActive {
 943                         get {
 944                                 bool raw_ret = gst_buffer_pool_is_active(Handle);
 945                                 bool ret = raw_ret;
 946                                 return ret;
 947                         }
 948                 }
 949
 950                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 951                 static extern void gst_buffer_pool_release_buffer(IntPtr raw, IntPtr buffer);
 952
 953                 public void ReleaseBuffer(Gst.Buffer buffer) {
 954                         buffer.Owned = false;
 955                         gst_buffer_pool_release_buffer(Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
 956                 }
 957
 958                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 959                 static extern bool gst_buffer_pool_set_active(IntPtr raw, bool active);
 960
 961                 public bool SetActive(bool active) {
 962                         bool raw_ret = gst_buffer_pool_set_active(Handle, active);
 963                         bool ret = raw_ret;
 964                         return ret;
 965                 }
 966
 967                 [DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
 968                 static extern bool gst_buffer_pool_set_config(IntPtr raw, IntPtr config);
 969
 970                 public bool SetConfig(Gst.Structure config) {
 971                         config.Owned = false;
 972                         bool raw_ret = gst_buffer_pool_set_config(Handle, config == null ? IntPtr.Zero : config.Handle);
 973                         bool ret = raw_ret;
 974                         return ret;
 975                 }
 976
 977
 978                 // Internal representation of the wrapped structure ABI.
 979                 static GLib.AbiStruct _abi_info = null;
 980                 static public new GLib.AbiStruct abi_info {
 981                         get {
 982                                 if (_abi_info == null)
 983                                         _abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{
 984                                                 new GLib.AbiField("flushing"
 985                                                         , Gst.Object.abi_info.Fields
 986                                                         , (uint) Marshal.SizeOf(typeof(bool)) // flushing
 987                                                         , null
 988                                                         , "priv"
 989                                                         , (long) Marshal.OffsetOf(typeof(GstBufferPool_flushingAlign), "flushing")
 990                                                         , 0
 991                                                         ),
 992                                                 new GLib.AbiField("priv"
 993                                                         , -1
 994                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
 995                                                         , "flushing"
 996                                                         , "_gst_reserved"
 997                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
 998                                                         , 0
 999                                                         ),
1000                                                 new GLib.AbiField("_gst_reserved"
1001                                                         , -1
1002                                                         , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
1003                                                         , "priv"
1004                                                         , null
1005                                                         , (uint) Marshal.SizeOf(typeof(IntPtr))
1006                                                         , 0
1007                                                         ),
1008                                         });
1009
1010                                 return _abi_info;
1011                         }
1012                 }
1013
1014                 [StructLayout(LayoutKind.Sequential)]
1015                 public struct GstBufferPool_flushingAlign
1016                 {
1017                         sbyte f1;
1018                         private bool flushing;
1019                 }
1020
1021
1022                 // End of the ABI representation.
1023
1024 #endregion
1025         }
1026 }