Developer/tysdk-intergration
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1db5db6a7723fcc4e52221715f18fa333fadefd0
tysdk-intergration/sdk-intergration/LocalPackages/LeviathanVideo/Plugins/Core/Arrays.g.cs
JSD\13999 1db5db6a77 video plugins
2026-03-24 11:43:22 +08:00

629 lines
25 KiB
C#
Raw Blame History

/*----------------------------------------------------------------
// Copyright (C) 2025 Beijing All rights reserved.
//
// Author: huachangmiao
// Create Date: 2025/04/11
// Module Describe:
//----------------------------------------------------------------*/
using System;
namespace LeviathanVideo.Abstractions
{
public unsafe struct AVRational2 : IFixedArray<AVRational>
{
public static readonly int ArrayLength = 2;
public int Length => 2;
AVRational _0; AVRational _1;
public AVRational this[uint i]
{
get { if (i >= 2) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 2) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { *(p0 + i) = value; } }
}
public AVRational[] ToArray()
{
fixed (AVRational* p0 = &_0) { var a = new AVRational[2]; for (uint i = 0; i < 2; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVRational[] array)
{
fixed (AVRational* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 2) return; } }
}
public static implicit operator AVRational[](AVRational2 @struct) => @struct.ToArray();
}
public unsafe struct short2 : IFixedArray<short>
{
public static readonly int ArrayLength = 2;
public int Length => 2;
fixed short _[2];
public short this[uint i]
{
get => _[i];
set => _[i] = value;
}
public short[] ToArray()
{
var a = new short[2]; for (uint i = 0; i < 2; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(short[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 2) return; }
}
public static implicit operator short[](short2 @struct) => @struct.ToArray();
}
public unsafe struct void_ptr2 : IFixedArray
{
public static readonly int ArrayLength = 2;
public int Length => 2;
void* _0; void* _1;
public void* this[uint i]
{
get { if (i >= 2) throw new ArgumentOutOfRangeException(); fixed (void** p0 = &_0) { return *(p0 + i); } }
set { if (i >= 2) throw new ArgumentOutOfRangeException(); fixed (void** p0 = &_0) { *(p0 + i) = value; } }
}
public void*[] ToArray()
{
fixed (void** p0 = &_0) { var a = new void*[2]; for (uint i = 0; i < 2; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(void*[] array)
{
fixed (void** p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 2) return; } }
}
public static implicit operator void*[](void_ptr2 @struct) => @struct.ToArray();
}
public unsafe struct AVHDRPlusColorTransformParams3 : IFixedArray<AVHDRPlusColorTransformParams>
{
public static readonly int ArrayLength = 3;
public int Length => 3;
AVHDRPlusColorTransformParams _0; AVHDRPlusColorTransformParams _1; AVHDRPlusColorTransformParams _2;
public AVHDRPlusColorTransformParams this[uint i]
{
get { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (AVHDRPlusColorTransformParams* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (AVHDRPlusColorTransformParams* p0 = &_0) { *(p0 + i) = value; } }
}
public AVHDRPlusColorTransformParams[] ToArray()
{
fixed (AVHDRPlusColorTransformParams* p0 = &_0) { var a = new AVHDRPlusColorTransformParams[3]; for (uint i = 0; i < 3; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVHDRPlusColorTransformParams[] array)
{
fixed (AVHDRPlusColorTransformParams* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 3) return; } }
}
public static implicit operator AVHDRPlusColorTransformParams[](AVHDRPlusColorTransformParams3 @struct) => @struct.ToArray();
}
public unsafe struct AVRational3 : IFixedArray<AVRational>
{
public static readonly int ArrayLength = 3;
public int Length => 3;
AVRational _0; AVRational _1; AVRational _2;
public AVRational this[uint i]
{
get { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { *(p0 + i) = value; } }
}
public AVRational[] ToArray()
{
fixed (AVRational* p0 = &_0) { var a = new AVRational[3]; for (uint i = 0; i < 3; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVRational[] array)
{
fixed (AVRational* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 3) return; } }
}
public static implicit operator AVRational[](AVRational3 @struct) => @struct.ToArray();
}
public unsafe struct AVRational3x2 : IFixedArray<AVRational2>
{
public static readonly int ArrayLength = 3;
public int Length => 3;
AVRational2 _0; AVRational2 _1; AVRational2 _2;
public AVRational2 this[uint i]
{
get { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (AVRational2* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (AVRational2* p0 = &_0) { *(p0 + i) = value; } }
}
public AVRational2[] ToArray()
{
fixed (AVRational2* p0 = &_0) { var a = new AVRational2[3]; for (uint i = 0; i < 3; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVRational2[] array)
{
fixed (AVRational2* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 3) return; } }
}
public static implicit operator AVRational2[](AVRational3x2 @struct) => @struct.ToArray();
}
public unsafe struct byte_ptr3 : IFixedArray
{
public static readonly int ArrayLength = 3;
public int Length => 3;
byte* _0; byte* _1; byte* _2;
public byte* this[uint i]
{
get { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (byte** p0 = &_0) { return *(p0 + i); } }
set { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (byte** p0 = &_0) { *(p0 + i) = value; } }
}
public byte*[] ToArray()
{
fixed (byte** p0 = &_0) { var a = new byte*[3]; for (uint i = 0; i < 3; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(byte*[] array)
{
fixed (byte** p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 3) return; } }
}
public static implicit operator byte*[](byte_ptr3 @struct) => @struct.ToArray();
}
public unsafe struct int3 : IFixedArray<int>
{
public static readonly int ArrayLength = 3;
public int Length => 3;
fixed int _[3];
public int this[uint i]
{
get => _[i];
set => _[i] = value;
}
public int[] ToArray()
{
var a = new int[3]; for (uint i = 0; i < 3; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(int[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 3) return; }
}
public static implicit operator int[](int3 @struct) => @struct.ToArray();
}
public unsafe struct short3x2 : IFixedArray<short2>
{
public static readonly int ArrayLength = 3;
public int Length => 3;
short2 _0; short2 _1; short2 _2;
public short2 this[uint i]
{
get { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (short2* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 3) throw new ArgumentOutOfRangeException(); fixed (short2* p0 = &_0) { *(p0 + i) = value; } }
}
public short2[] ToArray()
{
fixed (short2* p0 = &_0) { var a = new short2[3]; for (uint i = 0; i < 3; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(short2[] array)
{
fixed (short2* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 3) return; } }
}
public static implicit operator short2[](short3x2 @struct) => @struct.ToArray();
}
public unsafe struct AVComponentDescriptor4 : IFixedArray<AVComponentDescriptor>
{
public static readonly int ArrayLength = 4;
public int Length => 4;
AVComponentDescriptor _0; AVComponentDescriptor _1; AVComponentDescriptor _2; AVComponentDescriptor _3;
public AVComponentDescriptor this[uint i]
{
get { if (i >= 4) throw new ArgumentOutOfRangeException(); fixed (AVComponentDescriptor* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 4) throw new ArgumentOutOfRangeException(); fixed (AVComponentDescriptor* p0 = &_0) { *(p0 + i) = value; } }
}
public AVComponentDescriptor[] ToArray()
{
fixed (AVComponentDescriptor* p0 = &_0) { var a = new AVComponentDescriptor[4]; for (uint i = 0; i < 4; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVComponentDescriptor[] array)
{
fixed (AVComponentDescriptor* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 4) return; } }
}
public static implicit operator AVComponentDescriptor[](AVComponentDescriptor4 @struct) => @struct.ToArray();
}
public unsafe struct byte_ptr4 : IFixedArray
{
public static readonly int ArrayLength = 4;
public int Length => 4;
byte* _0; byte* _1; byte* _2; byte* _3;
public byte* this[uint i]
{
get { if (i >= 4) throw new ArgumentOutOfRangeException(); fixed (byte** p0 = &_0) { return *(p0 + i); } }
set { if (i >= 4) throw new ArgumentOutOfRangeException(); fixed (byte** p0 = &_0) { *(p0 + i) = value; } }
}
public byte*[] ToArray()
{
fixed (byte** p0 = &_0) { var a = new byte*[4]; for (uint i = 0; i < 4; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(byte*[] array)
{
fixed (byte** p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 4) return; } }
}
public static implicit operator byte*[](byte_ptr4 @struct) => @struct.ToArray();
}
public unsafe struct byte4 : IFixedArray<byte>
{
public static readonly int ArrayLength = 4;
public int Length => 4;
fixed byte _[4];
public byte this[uint i]
{
get => _[i];
set => _[i] = value;
}
public byte[] ToArray()
{
var a = new byte[4]; for (uint i = 0; i < 4; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(byte[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 4) return; }
}
public static implicit operator byte[](byte4 @struct) => @struct.ToArray();
}
public unsafe struct int4 : IFixedArray<int>
{
public static readonly int ArrayLength = 4;
public int Length => 4;
fixed int _[4];
public int this[uint i]
{
get => _[i];
set => _[i] = value;
}
public int[] ToArray()
{
var a = new int[4]; for (uint i = 0; i < 4; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(int[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 4) return; }
}
public static implicit operator int[](int4 @struct) => @struct.ToArray();
}
public unsafe struct long4 : IFixedArray<long>
{
public static readonly int ArrayLength = 4;
public int Length => 4;
fixed long _[4];
public long this[uint i]
{
get => _[i];
set => _[i] = value;
}
public long[] ToArray()
{
var a = new long[4]; for (uint i = 0; i < 4; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(long[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 4) return; }
}
public static implicit operator long[](long4 @struct) => @struct.ToArray();
}
public unsafe struct uint4 : IFixedArray<uint>
{
public static readonly int ArrayLength = 4;
public int Length => 4;
fixed uint _[4];
public uint this[uint i]
{
get => _[i];
set => _[i] = value;
}
public uint[] ToArray()
{
var a = new uint[4]; for (uint i = 0; i < 4; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(uint[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 4) return; }
}
public static implicit operator uint[](uint4 @struct) => @struct.ToArray();
}
public unsafe struct ulong4 : IFixedArray<ulong>
{
public static readonly int ArrayLength = 4;
public int Length => 4;
fixed ulong _[4];
public ulong this[uint i]
{
get => _[i];
set => _[i] = value;
}
public ulong[] ToArray()
{
var a = new ulong[4]; for (uint i = 0; i < 4; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(ulong[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 4) return; }
}
public static implicit operator ulong[](ulong4 @struct) => @struct.ToArray();
}
public unsafe struct int7 : IFixedArray<int>
{
public static readonly int ArrayLength = 7;
public int Length => 7;
fixed int _[7];
public int this[uint i]
{
get => _[i];
set => _[i] = value;
}
public int[] ToArray()
{
var a = new int[7]; for (uint i = 0; i < 7; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(int[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 7) return; }
}
public static implicit operator int[](int7 @struct) => @struct.ToArray();
}
public unsafe struct AVBufferRef_ptr8 : IFixedArray
{
public static readonly int ArrayLength = 8;
public int Length => 8;
AVBufferRef* _0; AVBufferRef* _1; AVBufferRef* _2; AVBufferRef* _3; AVBufferRef* _4; AVBufferRef* _5; AVBufferRef* _6; AVBufferRef* _7;
public AVBufferRef* this[uint i]
{
get { if (i >= 8) throw new ArgumentOutOfRangeException(); fixed (AVBufferRef** p0 = &_0) { return *(p0 + i); } }
set { if (i >= 8) throw new ArgumentOutOfRangeException(); fixed (AVBufferRef** p0 = &_0) { *(p0 + i) = value; } }
}
public AVBufferRef*[] ToArray()
{
fixed (AVBufferRef** p0 = &_0) { var a = new AVBufferRef*[8]; for (uint i = 0; i < 8; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVBufferRef*[] array)
{
fixed (AVBufferRef** p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 8) return; } }
}
public static implicit operator AVBufferRef*[](AVBufferRef_ptr8 @struct) => @struct.ToArray();
}
public unsafe struct byte_ptr8 : IFixedArray
{
public static readonly int ArrayLength = 8;
public int Length => 8;
byte* _0; byte* _1; byte* _2; byte* _3; byte* _4; byte* _5; byte* _6; byte* _7;
public byte* this[uint i]
{
get { if (i >= 8) throw new ArgumentOutOfRangeException(); fixed (byte** p0 = &_0) { return *(p0 + i); } }
set { if (i >= 8) throw new ArgumentOutOfRangeException(); fixed (byte** p0 = &_0) { *(p0 + i) = value; } }
}
public byte*[] ToArray()
{
fixed (byte** p0 = &_0) { var a = new byte*[8]; for (uint i = 0; i < 8; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(byte*[] array)
{
fixed (byte** p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 8) return; } }
}
public static implicit operator byte*[](byte_ptr8 @struct) => @struct.ToArray();
}
public unsafe struct byte8 : IFixedArray<byte>
{
public static readonly int ArrayLength = 8;
public int Length => 8;
fixed byte _[8];
public byte this[uint i]
{
get => _[i];
set => _[i] = value;
}
public byte[] ToArray()
{
var a = new byte[8]; for (uint i = 0; i < 8; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(byte[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 8) return; }
}
public static implicit operator byte[](byte8 @struct) => @struct.ToArray();
}
public unsafe struct int8 : IFixedArray<int>
{
public static readonly int ArrayLength = 8;
public int Length => 8;
fixed int _[8];
public int this[uint i]
{
get => _[i];
set => _[i] = value;
}
public int[] ToArray()
{
var a = new int[8]; for (uint i = 0; i < 8; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(int[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 8) return; }
}
public static implicit operator int[](int8 @struct) => @struct.ToArray();
}
public unsafe struct ulong8 : IFixedArray<ulong>
{
public static readonly int ArrayLength = 8;
public int Length => 8;
fixed ulong _[8];
public ulong this[uint i]
{
get => _[i];
set => _[i] = value;
}
public ulong[] ToArray()
{
var a = new ulong[8]; for (uint i = 0; i < 8; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(ulong[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 8) return; }
}
public static implicit operator ulong[](ulong8 @struct) => @struct.ToArray();
}
public unsafe struct int9 : IFixedArray<int>
{
public static readonly int ArrayLength = 9;
public int Length => 9;
fixed int _[9];
public int this[uint i]
{
get => _[i];
set => _[i] = value;
}
public int[] ToArray()
{
var a = new int[9]; for (uint i = 0; i < 9; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(int[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 9) return; }
}
public static implicit operator int[](int9 @struct) => @struct.ToArray();
}
public unsafe struct AVHDRPlusPercentile15 : IFixedArray<AVHDRPlusPercentile>
{
public static readonly int ArrayLength = 15;
public int Length => 15;
AVHDRPlusPercentile _0; AVHDRPlusPercentile _1; AVHDRPlusPercentile _2; AVHDRPlusPercentile _3; AVHDRPlusPercentile _4; AVHDRPlusPercentile _5; AVHDRPlusPercentile _6; AVHDRPlusPercentile _7; AVHDRPlusPercentile _8; AVHDRPlusPercentile _9; AVHDRPlusPercentile _10; AVHDRPlusPercentile _11; AVHDRPlusPercentile _12; AVHDRPlusPercentile _13; AVHDRPlusPercentile _14;
public AVHDRPlusPercentile this[uint i]
{
get { if (i >= 15) throw new ArgumentOutOfRangeException(); fixed (AVHDRPlusPercentile* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 15) throw new ArgumentOutOfRangeException(); fixed (AVHDRPlusPercentile* p0 = &_0) { *(p0 + i) = value; } }
}
public AVHDRPlusPercentile[] ToArray()
{
fixed (AVHDRPlusPercentile* p0 = &_0) { var a = new AVHDRPlusPercentile[15]; for (uint i = 0; i < 15; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVHDRPlusPercentile[] array)
{
fixed (AVHDRPlusPercentile* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 15) return; } }
}
public static implicit operator AVHDRPlusPercentile[](AVHDRPlusPercentile15 @struct) => @struct.ToArray();
}
public unsafe struct AVRational15 : IFixedArray<AVRational>
{
public static readonly int ArrayLength = 15;
public int Length => 15;
AVRational _0; AVRational _1; AVRational _2; AVRational _3; AVRational _4; AVRational _5; AVRational _6; AVRational _7; AVRational _8; AVRational _9; AVRational _10; AVRational _11; AVRational _12; AVRational _13; AVRational _14;
public AVRational this[uint i]
{
get { if (i >= 15) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 15) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { *(p0 + i) = value; } }
}
public AVRational[] ToArray()
{
fixed (AVRational* p0 = &_0) { var a = new AVRational[15]; for (uint i = 0; i < 15; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVRational[] array)
{
fixed (AVRational* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 15) return; } }
}
public static implicit operator AVRational[](AVRational15 @struct) => @struct.ToArray();
}
public unsafe struct byte16 : IFixedArray<byte>
{
public static readonly int ArrayLength = 16;
public int Length => 16;
fixed byte _[16];
public byte this[uint i]
{
get => _[i];
set => _[i] = value;
}
public byte[] ToArray()
{
var a = new byte[16]; for (uint i = 0; i < 16; i++) a[i] = _[i]; return a;
}
public void UpdateFrom(byte[] array)
{
uint i = 0; foreach (var value in array) { _[i++] = value; if (i >= 16) return; }
}
public static implicit operator byte[](byte16 @struct) => @struct.ToArray();
}
public unsafe struct AVRational25 : IFixedArray<AVRational>
{
public static readonly int ArrayLength = 25;
public int Length => 25;
AVRational _0; AVRational _1; AVRational _2; AVRational _3; AVRational _4; AVRational _5; AVRational _6; AVRational _7; AVRational _8; AVRational _9; AVRational _10; AVRational _11; AVRational _12; AVRational _13; AVRational _14; AVRational _15; AVRational _16; AVRational _17; AVRational _18; AVRational _19; AVRational _20; AVRational _21; AVRational _22; AVRational _23; AVRational _24;
public AVRational this[uint i]
{
get { if (i >= 25) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 25) throw new ArgumentOutOfRangeException(); fixed (AVRational* p0 = &_0) { *(p0 + i) = value; } }
}
public AVRational[] ToArray()
{
fixed (AVRational* p0 = &_0) { var a = new AVRational[25]; for (uint i = 0; i < 25; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVRational[] array)
{
fixed (AVRational* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 25) return; } }
}
public static implicit operator AVRational[](AVRational25 @struct) => @struct.ToArray();
}
public unsafe struct AVRational25x25 : IFixedArray<AVRational25>
{
public static readonly int ArrayLength = 25;
public int Length => 25;
AVRational25 _0; AVRational25 _1; AVRational25 _2; AVRational25 _3; AVRational25 _4; AVRational25 _5; AVRational25 _6; AVRational25 _7; AVRational25 _8; AVRational25 _9; AVRational25 _10; AVRational25 _11; AVRational25 _12; AVRational25 _13; AVRational25 _14; AVRational25 _15; AVRational25 _16; AVRational25 _17; AVRational25 _18; AVRational25 _19; AVRational25 _20; AVRational25 _21; AVRational25 _22; AVRational25 _23; AVRational25 _24;
public AVRational25 this[uint i]
{
get { if (i >= 25) throw new ArgumentOutOfRangeException(); fixed (AVRational25* p0 = &_0) { return *(p0 + i); } }
set { if (i >= 25) throw new ArgumentOutOfRangeException(); fixed (AVRational25* p0 = &_0) { *(p0 + i) = value; } }
}
public AVRational25[] ToArray()
{
fixed (AVRational25* p0 = &_0) { var a = new AVRational25[25]; for (uint i = 0; i < 25; i++) a[i] = *(p0 + i); return a; }
}
public void UpdateFrom(AVRational25[] array)
{
fixed (AVRational25* p0 = &_0) { uint i = 0; foreach (var value in array) { *(p0 + i++) = value; if (i >= 25) return; } }
}
public static implicit operator AVRational25[](AVRational25x25 @struct) => @struct.ToArray();
}
}
Reference in New Issue View Git Blame Copy Permalink