EncodeToUtf8()

static unsafe OperationStatus System.Buffers.Text.Base64.EncodeToUtf8 ( ReadOnlySpan< byte > bytes, Span< byte > utf8, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true )

inlinestatic

Definition at line 413 of file Base64.cs.

    {
        if (bytes.IsEmpty)
        {
            bytesConsumed = 0;
            bytesWritten = 0;
            return OperationStatus.Done;
        }
        fixed (byte* ptr = &MemoryMarshal.GetReference(bytes))
        {
            fixed (byte* ptr2 = &MemoryMarshal.GetReference(utf8))
            {
                int length = bytes.Length;
                int length2 = utf8.Length;
                int num = ((length > 1610612733 || length2 < GetMaxEncodedToUtf8Length(length)) ? ((length2 >> 2) * 3) : length);
                byte* srcBytes = ptr;
                byte* destBytes = ptr2;
                byte* ptr3 = ptr + (uint)length;
                byte* ptr4 = ptr + (uint)num;
                if (num >= 16)
                {
                    byte* ptr5 = ptr4 - 32;
                    if (Avx2.IsSupported && ptr5 >= srcBytes)
                    {
                        Avx2Encode(ref srcBytes, ref destBytes, ptr5, num, length2, ptr, ptr2);
                        if (srcBytes == ptr3)
                        {
                            goto IL_0175;
                        }
                    }
                    ptr5 = ptr4 - 16;
                    if (Ssse3.IsSupported && ptr5 >= srcBytes)
                    {
                        Ssse3Encode(ref srcBytes, ref destBytes, ptr5, num, length2, ptr, ptr2);
                        if (srcBytes == ptr3)
                        {
                            goto IL_0175;
                        }
                    }
                }
                ref byte reference = ref MemoryMarshal.GetReference(EncodingMap);
                uint num2 = 0u;
                ptr4 -= 2;
                while (srcBytes < ptr4)
                {
                    num2 = Encode(srcBytes, ref reference);
                    Internal.Runtime.CompilerServices.Unsafe.WriteUnaligned(destBytes, num2);
                    srcBytes += 3;
                    destBytes += 4;
                }
                if (ptr4 + 2 == ptr3)
                {
                    if (!isFinalBlock)
                    {
                        if (srcBytes != ptr3)
                        {
                            bytesConsumed = (int)(srcBytes - ptr);
                            bytesWritten = (int)(destBytes - ptr2);
                            return OperationStatus.NeedMoreData;
                        }
                    }
                    else if (srcBytes + 1 == ptr3)
                    {
                        num2 = EncodeAndPadTwo(srcBytes, ref reference);
                        Internal.Runtime.CompilerServices.Unsafe.WriteUnaligned(destBytes, num2);
                        srcBytes++;
                        destBytes += 4;
                    }
                    else if (srcBytes + 2 == ptr3)
                    {
                        num2 = EncodeAndPadOne(srcBytes, ref reference);
                        Internal.Runtime.CompilerServices.Unsafe.WriteUnaligned(destBytes, num2);
                        srcBytes += 2;
                        destBytes += 4;
                    }
                    goto IL_0175;
                }
                bytesConsumed = (int)(srcBytes - ptr);
                bytesWritten = (int)(destBytes - ptr2);
                return OperationStatus.DestinationTooSmall;
                IL_0175:
                bytesConsumed = (int)(srcBytes - ptr);
                bytesWritten = (int)(destBytes - ptr2);
                return OperationStatus.Done;
            }
        }
    }

References System.Buffers.Text.Base64.Avx2Encode(), System.bytes, System.Buffers.Text.Base64.Encode(), System.Buffers.Text.Base64.EncodeAndPadOne(), System.Buffers.Text.Base64.EncodeAndPadTwo(), System.Buffers.Text.Base64.EncodingMap, System.Buffers.Text.Base64.GetMaxEncodedToUtf8Length(), System.Runtime.Intrinsics.X86.Avx2.IsSupported, System.Runtime.Intrinsics.X86.Ssse3.IsSupported, System.length, System.Span< T >.Length, System.length2, and System.Buffers.Text.Base64.Ssse3Encode().

Referenced by System.Text.Json.Utf8JsonWriter.Base64EncodeAndWrite(), System.Security.Cryptography.ToBase64Transform.TransformBlock(), and System.Security.Cryptography.ToBase64Transform.TransformFinalBlock().