Xwork's Blog

using System.Diagnostics.Eventing.Reader;
using System.Runtime.InteropServices;
using System.Text;
using System.Drawing.Imaging;
using System.Net.Http.Headers;
using System.ComponentModel;

namespace FlacPictureWriter
{
    public partial class Form1 : Form

    {

        ///Picture type:  
        /// $00  Other
        /// $01  32x32 pixels 'file icon' (PNG only)
        /// $02  Other file icon
        /// $03  Cover (front)
        /// $04  Cover (back)
        /// $05  Leaflet page
        /// $06  Media (e.g. lable side of CD)
        /// $07  Lead artist/lead performer/soloist
        /// $08  Artist/performer
        /// $09  Conductor
        /// $0A  Band/Orchestra
        /// $0B  Composer
        /// $0C  Lyricist/text writer
        /// $0D  Recording Location
        /// $0E  During recording
        /// $0F  During performance
        /// $10  Movie/video screen capture
        /// $11  A bright coloured fish
        /// $12  Illustration
        /// $13  Band/artist logotype
        /// $14  Publisher/Studio logotype
        private enum APICType
        {
            /// <summary>
            /// Imagen génerica
            /// </summary>
            APIC_TYPE_Other = 0,
            /// <summary>
            /// ícono (solo PNG)
            /// </summary>
            APIC_TYPE_FileIcon,
            /// <summary>
            /// Otro ícono
            /// </summary>
            APIC_TYPE_OtherFile_Icon,
            /// <summary>
            /// Cubierta frontal del disco
            /// </summary>
            APIC_TYPE_CoverFront,
            /// <summary>
            /// Cubierta trasera del disco
            /// </summary>
            APIC_TYPE_CoverBack,
            /// <summary>
            /// Folleto
            /// </summary>
            APIC_TYPE_LeafletPage,
            /// <summary>
            /// Otra ímagen
            /// </summary>
            APIC_TYPE_Media,
            /// <summary>
            /// Artista principal
            /// </summary>
            APIC_TYPE_LeadArtist,
            /// <summary>
            /// Artista
            /// </summary>
            APIC_TYPE_Artist,
            /// <summary>
            /// Conductor
            /// </summary>
            APIC_TYPE_Conductor,
            /// <summary>
            /// Banda
            /// </summary>
            APIC_TYPE_Band,
            /// <summary>
            /// Compositor
            /// </summary>
            APIC_TYPE_Composer,
            /// <summary>
            /// Letrista
            /// </summary>
            APIC_TYPE_Lyricist,
            /// <summary>
            /// Lugar de la grabacion
            /// </summary>
            APIC_TYPE_RecordingLocation,
            /// <summary>
            /// Captura durante la grabacion
            /// </summary>
            APIC_TYPE_DuringRecording,
            /// <summary>
            /// Captura durante concierto
            /// </summary>
            APIC_TYPE_DuringPerformance,
            /// <summary>
            /// Captura de videclip
            /// </summary>
            APIC_TYPE_VideoScreenCapture,
            /// <summary>
            /// ???
            /// </summary>
            APIC_TYPE_ABrightColouredFish,
            /// <summary>
            /// Ilustracion
            /// </summary>
            APIC_TYPE_Illustration,
            /// <summary>
            /// Logotipo de la banda/artista
            /// </summary>
            APIC_TYPE_ArtistLogotype,
            /// <summary>
            /// Logotipo de la discografica
            /// </summary>
            APIC_TYPE_PublisherLogotype,
            APIC_TYPE_NoValid

        }


        // 0 : STREAMINFO       0000000
        // 1 : PADDING          0000001
        // 2 : APPLICATION      0000010
        // 3 : SEEKTABLE        0000011
        // 4 : VORBIS_COMMENT   0000100
        // 5 : CUESHEET         0000101
        // 6 : PICTURE          0000110
        // 7-126 : reserved     1111000 - Invalid
        // 127 : invalid, to avoid confusion with a frame sync code
        /// <summary>
        /// Enumeración con los posibles bloques contenidos en un archivo FLAC
        /// </summary>
        private enum BlocksTypes
        {
            /// <summary>
            /// Bloque mandatorio con la información del Stream
            /// </summary>
            Block_Type_StreamInfo = 0,
            /// <summary>
            /// Bloque de Padding
            /// </summary>
            Block_Type_Padding = 1,
            /// <summary>
            /// Bloque con la informacion de la aplicación
            /// </summary>
            Block_Type_Application = 2,
            /// <summary>
            /// Bloque Seektable
            /// </summary>
            Block_Type_SeekTable = 3,
            /// <summary>
            /// Bloque con metadatos
            /// </summary>
            Block_Type_VorbisComment = 4,
            /// <summary>
            /// Bloque con cuesheet
            /// </summary>
            Block_Type_CueSheet = 5,
            /// <summary>
            /// Bloque con imagen
            /// </summary>
            Block_Type_Picture = 6,
            /// <summary>
            /// Bloque no válido
            /// </summary>
            Block_Type_NoValid = 7

        }
        public Form1()
        {
            InitializeComponent();
        }


        List<UInt32> Direcciones;
        bool TieneImagen = false;
        UInt32 ImageSize = 0;
        UInt32 LastBLockPosition = 0;
        UInt32 VorbisCommentPosition = 0;
        UInt32 ImagePosition = 0;

        private byte[] NormalizeToFourBytes(UInt32 Value, bool Reverse = false)
        {
            byte[] buff = BitConverter.GetBytes(Value);

            if (Reverse)
                Array.Reverse(buff);

            return buff;
        }
        /// <summary>
        /// Obtiene el "Mime Type" basado en la extension de un archivo
        /// </summary>
        /// <param name="FilePath">Ruta de la cual se va a extraer la información</param>
        /// <returns></returns>
        private string GetMIMEType(string FilePath)
        {

            FileInfo FI = new(FilePath);
            if (string.Compare(FI.Extension, ".jpg", StringComparison.OrdinalIgnoreCase) == 0)
            {
                return @"image/jpeg";
            }
            else if (string.Compare(FI.Extension, ".png", StringComparison.OrdinalIgnoreCase) == 0)
            {
                return @"image/PNG";
            }
            else
            {
                return "No valido";
            }
        }


        /// <summary>
        /// Crea una imagen a partir de una secuencia de bytes
        /// </summary>
        /// <param name="bytesArr">Matriz de bytes que contiene los datos de la imagen</param>
        /// <returns>Regresa una imagen</returns>
        public Image ByteArrayToImage(byte[] bytesArr)
        {
            using (MemoryStream memstr = new(bytesArr))
            {
                Image img = Image.FromStream(memstr);
                return img;
            }
        }

        //  4   4    n*4    4   n*4    4    4   4    4    !4  !n*4
        //<32>,<32>,<n*8>,<32>,<n*8>,<32>,<32>,<32>,<32>,<32>,<n*8>
        //  1   2     3     4    5     6    7    8    9    10   11
        /// <summary>
        /// Lee todo los datos del bloque PICTURE y extrae la imagen contenida
        /// </summary>
        /// <param name="TheData">Arreglos bytes que contiene todo el bloque PICTURE</param>
        /// <returns>Regresa una imagen</returns>
        private Image ReadPictureData(byte[] TheData)
        {

            uint CurrentPos = 4;//1
            uint CurrentSize = GetBlockSize(TheData, (int)CurrentPos, 4);
            CurrentPos += 4;//2
            string MimeType = Encoding.ASCII.GetString(TheData, (int)CurrentPos, (int)CurrentSize);

            CurrentPos += CurrentSize;//3

            CurrentSize = GetBlockSize(TheData, (int)CurrentPos, 4);
            CurrentPos += (CurrentSize + (4 * 5));//4-9

            CurrentSize = GetBlockSize(TheData, (int)CurrentPos, 4);
            CurrentPos += 4;

            byte[] TempImage = new byte[CurrentSize];
            Array.Copy(TheData, CurrentPos, TempImage, 0, CurrentSize);
            return ByteArrayToImage(TempImage);


        }

        /// <summary>
        /// Actualiza la imagen de un archivo FLAC.
        /// </summary>
        /// <param name="ImagePath">Ruta de la imagen JPG</param>
        private byte[] BuildAPICFrame(string ImagePath, int PictureType, string MimeType, UInt32 ImageSize)
        {

            List<byte> Data = new List<byte>();
            byte[] Buff = new byte[ImageSize];

            using (FileStream FS = new FileStream(ImagePath, FileMode.Open))
            {
                using (BinaryReader BR = new(FS))
                {
                    Buff = BR.ReadBytes((int)ImageSize);
                }
            }

            //Tipo de Imagen APIC
            Data.AddRange(NormalizeToFourBytes((UInt32)PictureType, true));
            //Tamaño del tipo de contenido
            Data.AddRange(NormalizeToFourBytes((UInt32)MimeType.Length, true));
            //Tipo de contenido
            Data.AddRange(Encoding.ASCII.GetBytes(MimeType));
            //Descripcion del tipo de contenido
            Data.AddRange(NormalizeToFourBytes((UInt32)MimeType.Length, true));
            //Tamaño de la descripcion del contenido
            Data.AddRange(Encoding.ASCII.GetBytes(MimeType));
            //Ancho de la imagen
            Data.AddRange(NormalizeToFourBytes(0, true));
            //Alto de la imagen
            Data.AddRange(NormalizeToFourBytes(0, true));
            //Profundidad del color
            Data.AddRange(NormalizeToFourBytes(0, true));
            //Indice de la paleta de colores
            Data.AddRange(NormalizeToFourBytes(0, true));
            //Tamaño de la imagen en bytes
            Data.AddRange(NormalizeToFourBytes(ImageSize, true));
            //Datos de la Imagen
            Data.AddRange(Buff);



            return Data.ToArray();
        }
        /// <summary>
        /// Construye el bloque de imagen 
        /// </summary>
        /// <param name="APICData"></param>
        /// <returns></returns>
        private byte[] BuildPictureBlock(byte[] APICData)
        {
            byte[] Buff = new byte[APICData.Length + 4];
            byte[] PICSize = new byte[4];

            PICSize = NormalizeToFourBytes((UInt32)APICData.Length, true);
            PICSize.CopyTo(Buff, 0);


            //siempre pondremos la imagen al final de los metadatos
            //Establecemos el marcador de ultimo bloque y el tipo de bloque en 6 (Block_Type_Picture)
            //Quedando 10000110b o 134
            Buff[0] = 134;
            APICData.CopyTo(Buff, 4);

            return Buff;
        }


        private List<UInt32> GetOffsets(string FileName)
        {
            byte[] DataBuff;
            List<UInt32> offsets = new List<UInt32>();
            bool LastFrame = false;


            using (FileStream FS = new(FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                offsets.Add((UInt32)FS.Position);
                using (BinaryReader BR = new(FS, Encoding.ASCII))
                {
                    DataBuff = BR.ReadBytes(4);
                    if (string.Equals(Encoding.ASCII.GetString(DataBuff), "fLaC", StringComparison.Ordinal))
                    {
                        UInt32 CurrentBlockSize;
                        UInt32 CurrentPosition = (UInt32)FS.Position;
                        BlocksTypes CurrentBlockType = NumberToBlockType(GetBlockType(DataBuff[0]));


                        while (!LastFrame)
                        {
                            //primer bloque siempre ser� Block_Type_StreamInfo


                            offsets.Add((UInt32)FS.Position);
                            DataBuff = BR.ReadBytes(4);
                            LastFrame = IsLastFrame(DataBuff[0]);
                            CurrentBlockType = NumberToBlockType(GetBlockType(DataBuff[0]));
                            CurrentBlockSize = GetBlockSize(DataBuff);
                            FS.Seek(FS.Position + CurrentBlockSize, SeekOrigin.Begin);


                            if (CurrentBlockType == BlocksTypes.Block_Type_VorbisComment)
                            {
                                VorbisCommentPosition = offsets[offsets.Count - 1];
                            }


                            if (CurrentBlockType == BlocksTypes.Block_Type_Picture)
                            {
                                TieneImagen = true;
                                ImagePosition = offsets[offsets.Count - 1];
                            }


                            if (LastFrame)
                                LastBLockPosition = offsets[offsets.Count - 1];
                        }
                    }
                    else
                    {
                        MessageBox.Show("Archivo Flac no v�lido");
                    }


                }
            }


            return offsets;
        }


        /// <summary>
        /// Construye el encabezado de un bloque de informacion
        /// </summary>
        /// <param name="Number">Valor que indica la longitud del bloque en bytes</param>
        /// <param name="BlockType">Valor que indica el tipo de bloque de acuerdo a <c>BlockTypes</c></param>
        /// <param name="IsLastFrame">Indica si es el ultimo bloque de informacion</param>
        /// <returns>Regresa un arreglo de cuatro bytes que representan el encabezado del bloque</returns>
        private byte[] BuildHeader(uint Number, BlocksTypes BlockType, bool IsLastFrame)
        {
            byte[] HeaderBuff = new byte[4];

            HeaderBuff = BitConverter.GetBytes(Number);



            HeaderBuff[3] = (byte)BlockType;
            if (IsLastFrame)
            {
                HeaderBuff[3] |= 128;
            }

            Array.Reverse(HeaderBuff);

            return HeaderBuff;
        }
        /// <summary>
        /// Convierte un número en su valor equivalente al tipo de bloque
        /// </summary>
        /// <param name="Data">
        /// Entero sin signo con la representacion del bloque</param>
        /// <returns>Regresa un valor de la enumeración <typeparamref name="BlockTypes"/>BlockTypes</returns>
        private BlocksTypes NumberToBlockType(uint Data)
        {
            switch (Data)
            {
                case 0:
                    return BlocksTypes.Block_Type_StreamInfo;
                case 1:
                    return BlocksTypes.Block_Type_Padding;
                case 2:
                    return BlocksTypes.Block_Type_Application;
                case 3:
                    return BlocksTypes.Block_Type_SeekTable;
                case 4:
                    return BlocksTypes.Block_Type_VorbisComment;
                case 5:
                    return BlocksTypes.Block_Type_CueSheet;
                case 6:
                    return BlocksTypes.Block_Type_Picture;
                default:
                    return BlocksTypes.Block_Type_NoValid;
            }
        }

        /// <summary>
        /// Lee el bloque con la informacion estructurada
        /// </summary>
        /// <param name="TheData">Arreglo de bytes del cual se extraera la información</param>
        /// <returns>Regresa un arreglo del tipo string con todos los campos que se encontraron</returns>
        private string[] ReadVorbisData(byte[] TheData)
        {

            uint NumberOfFields = 0;
            uint CurrentField = 1;
            uint CurrentPosition = 0;
            //Vendor
            uint CurrentSize = BitConverter.ToUInt32(TheData, (int)CurrentPosition);
            CurrentPosition += 4;
            byte[] CurrentChunk = new byte[CurrentSize];
            Array.Copy(TheData, CurrentPosition, CurrentChunk, 0, CurrentSize);
            string Currenttext = Encoding.UTF8.GetString(CurrentChunk);

            CurrentPosition += CurrentSize;
            NumberOfFields = BitConverter.ToUInt32(TheData, (int)CurrentPosition);
            CurrentPosition += 4;

            string[] Fields = new string[NumberOfFields];
            //CommentField
            while (CurrentField <= NumberOfFields)
            {
                CurrentSize = BitConverter.ToUInt32(TheData, (int)CurrentPosition);
                CurrentPosition += 4;
                byte[] CurrenUserCommentList = new byte[CurrentSize];
                Array.Copy(TheData, CurrentPosition, CurrenUserCommentList, 0, CurrentSize);
                Currenttext = Encoding.UTF8.GetString(CurrenUserCommentList);
                CurrentPosition += CurrentSize;
                Fields[CurrentField - 1] = Currenttext;
                CurrentField += 1;
            }

            return Fields;
        }

        /// <summary>
        /// Obtiene el valor del bloque desde un byte
        /// </summary>
        /// <param name="Data">byte del cual se va a obtener la información</param>
        /// <returns>Regresa un valor que es equivalente al tipo de bloque</returns>
        private uint GetBlockType(byte Data)
        {
            Data <<= 3;
            Data >>= 3;

            return Data;
        }

        /// <summary>
        /// Obtiene si el bloque es el último de la serie
        /// </summary>
        /// <param name="Data">byte del cual se obtendra la información</param>
        /// <returns>true si el bloque es el último, false en caso contrario</returns>
        private bool IsLastFrame(byte Data)
        {
            Data >>= 7;

            if (Data == 1)
                return true;
            else
                return false;
        }

        /// <summary>
        /// Obtiene el tamaño de un bloque
        /// </summary>
        /// <param name="Data">Arreglo de bytes que contiene el tamaño del bloque</param>
        /// <returns>Regresa el tamaño del bloque actual</returns>
        private uint GetBlockSize(byte[] Data)
        {

            byte[] CurrentData = Data;
            //Ponemos el primer byte en 0 porque se usa para identificar el bloque
            //a la hora de convertir a UInt32 se esperan 4 bytes, pero este siempre será 0 u otro valor no relevante
            //para el tamaño del bloque
            CurrentData[0] = 0;
            Array.Reverse(CurrentData);

            return BitConverter.ToUInt32(CurrentData, 0);
        }

        /// <summary>
        /// Obtiene el tamaño de un bloque
        /// </summary>
        /// <param name="Data">Arreglo de bytes que contiene el tamaño del bloque</param>
        /// <param name="StartIndex">Indica la posicion en donde se empezará a leer</param>
        /// <param name="Size">Indica el tamaño en bytes que se van a leer</param>
        /// <returns>Regresa el tamaño del bloque actual</returns>

        private uint GetBlockSize(byte[] Data, int StartIndex, int Size)
        {
            byte[] CurrentData = new byte[4];
            Array.Copy(Data, StartIndex, CurrentData, 0, Size);
            Array.Reverse(CurrentData);

            return BitConverter.ToUInt32(CurrentData, 0);
        }

        /// <summary>
        /// Obtiene una imagen desde un archivo
        /// </summary>
        private void GetImageFromFile()
        {

            using OpenFileDialog OpDiag = new()
            {
                Filter = "Imagenes|*.jpg;*.png|Archivos JPG|*.jpg|Imagenes PNG|*.png",
                Multiselect = false
            };

            if (OpDiag.ShowDialog() == DialogResult.OK)
            {
                TxtInputPic.Text = OpDiag.FileName;
                PicInput.ImageLocation = TxtInputPic.Text;
                PicInput.SizeMode = PictureBoxSizeMode.StretchImage;
                FileInfo FileSize = new FileInfo(TxtInputPic.Text);
                ImageSize = (UInt32)FileSize.Length;
                LblPicInfo.Text = "Tamaño de la imagen en bytes " + ImageSize.ToString() + " bytes";
            }
        }

        /// <summary>
        /// Obtiene un bloque de datos de un archivo a partir de una posicion definida
        /// </summary>
        /// <param name="FileName">Archivo del cual se va a extraer el bloque</param>
        /// <param name="StartPosition">Posicion des la cual se va a obtener el bloque relativo al inicio del archivo</param>
        /// <returns>Regresa un arreglo de bytes con el bloque completo</returns>
        private byte[] GetBlockData(string FileName, int StartPosition)
        {
            byte[] DataBuff;
            using (FileStream FS = new(FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (BinaryReader BR = new(FS, Encoding.ASCII))
                {
                    UInt32 CurrentBlockSize;
                    UInt32 CurrentPosition = (UInt32)FS.Position;


                    FS.Seek(StartPosition, SeekOrigin.Begin);
                    DataBuff = BR.ReadBytes(4);

                    CurrentBlockSize = GetBlockSize(DataBuff);
                    FS.Seek(StartPosition, SeekOrigin.Begin);

                    return (BR.ReadBytes((int)(CurrentBlockSize + 4)));
                }
            }
        }

        /// <summary>
        /// Obtiene los datos de un bloque
        /// </summary>
        /// <param name="FileName">Nombre del archivo del cual se obtendra</param>
        /// <param name="TypeOfBlock">Tipo de bloque que se va a buscar</param>
        private void GetBlock(string FileName, BlocksTypes TypeOfBlock, int StartPosition)
        {
            byte[] DataBuff;
            using (FileStream FS = new(FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (BinaryReader BR = new(FS, Encoding.ASCII))
                {
                    UInt32 CurrentBlockSize;
                    UInt32 CurrentPosition = (UInt32)FS.Position;
                    BlocksTypes CurrentBlockType = BlocksTypes.Block_Type_NoValid;


                    FS.Seek(StartPosition, SeekOrigin.Begin);
                    DataBuff = BR.ReadBytes(4);


                    CurrentBlockType = NumberToBlockType(GetBlockType(DataBuff[0]));


                    if (CurrentBlockType == TypeOfBlock)
                    {
                        if (TypeOfBlock == BlocksTypes.Block_Type_VorbisComment)
                        {
                            string[] Fields;
                            CurrentBlockSize = GetBlockSize(DataBuff);
                            Fields = ReadVorbisData(BR.ReadBytes((int)CurrentBlockSize));
                            TxtInfo.Clear();


                            for (int i = 0; i < Fields.Length; i++)
                            {
                                TxtInfo.Text += Fields[i] + " | ";
                            }
                        }
                        else if (TypeOfBlock == BlocksTypes.Block_Type_Picture)
                        {


                            CurrentBlockSize = GetBlockSize(DataBuff);
                            PicFlac.Image = ReadPictureData(BR.ReadBytes((int)CurrentBlockSize));
                        }
                    }
                    else
                    {
                        return;
                    }
                }
            }
        }


        private void BtnOpen_Click(object sender, EventArgs e)
        {
            TieneImagen = false;
            VorbisCommentPosition = 0;
            ImagePosition = 0;

            OpenFileDialog OpDiag = new()
            {
                Filter = "Archivos Flac|*.flac|Todos los arvhivos|*.*",
                Multiselect = false
            };

            if (OpDiag.ShowDialog() == DialogResult.OK)
            {
                txtInputFlac.Text = OpDiag.FileName;
                PicFlac.SizeMode = PictureBoxSizeMode.StretchImage;
                Direcciones = GetOffsets(txtInputFlac.Text);

                GetBlock(txtInputFlac.Text, BlocksTypes.Block_Type_VorbisComment, (int)VorbisCommentPosition);

                if (TieneImagen)
                    GetBlock(txtInputFlac.Text, BlocksTypes.Block_Type_Picture, (int)ImagePosition);
            }
        }

        private void BtnOpenPic_Click(object sender, EventArgs e)
        {
            ImageSize = 0;
            GetImageFromFile();
        }

        private void BtnUpdateImage_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtInputFlac.Text))
            {
                MessageBox.Show("No hay arhivo de entrada", "Flac Image Writer", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }else if (string.IsNullOrEmpty(TxtInputPic.Text))
            {
                MessageBox.Show("No hay imagen de entrada", "Flac Image Writer", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            string SaveFile;
            bool HasImage = false;
            List<UInt32> Direcciones = GetOffsets(txtInputFlac.Text);
            int CurrentSize = (int)Direcciones[Direcciones.Count - 1];
            int bufferSize = 1024 * 1024;

            using (SaveFileDialog SavDiag = new SaveFileDialog())
            {
                SavDiag.Filter = "Archivos FLAC|*.flac";
                SavDiag.AddExtension = true;
                SavDiag.OverwritePrompt = true;
                if (SavDiag.ShowDialog() == DialogResult.OK)
                    SaveFile = SavDiag.FileName;
                else
                    return;
            }

            using (FileStream FSWrite = new FileStream(SaveFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
            {
                using (BinaryWriter BW = new(FSWrite))
                {

                    BW.Write(Encoding.ASCII.GetBytes("fLaC"));

                    for (int x = 1; x < Direcciones.Count; x++)
                    {
                        byte[] FileBuff = GetBlockData(txtInputFlac.Text, (int)Direcciones[x]);

                        BlocksTypes CurrentBlockType = BlocksTypes.Block_Type_NoValid;
                        CurrentBlockType = NumberToBlockType(GetBlockType(FileBuff[0]));

                        if (CurrentBlockType == BlocksTypes.Block_Type_Picture)
                            HasImage = true;


                        if (x == Direcciones.Count - 1)
                        {
                            if (!HasImage)
                            {
                                CurrentSize += FileBuff.Length;
                                BW.Write(BuildHeader((uint)(FileBuff.Length - 4), CurrentBlockType, false));
                            }
                            else
                            {
                                CurrentSize += FileBuff.Length;
                                BW.Write(BuildHeader((uint)(FileBuff.Length - 4), CurrentBlockType, true));
                            }

                        }
                        else
                        {

                            BW.Write(BuildHeader((uint)(FileBuff.Length - 4), CurrentBlockType, false));
                        }

                        BW.Write(FileBuff, 4, FileBuff.Length - 4);

                    }

                    if (HasImage == false)
                        BW.Write(BuildPictureBlock(BuildAPICFrame(TxtInputPic.Text, CboPictureType.SelectedIndex, GetMIMEType(TxtInputPic.Text), ImageSize)));



                    FileStream fs = new FileStream(txtInputFlac.Text, FileMode.Open, FileAccess.ReadWrite);

                    fs.Position = CurrentSize;
                    int bytesRead = -1;
                    byte[] bytes = new byte[bufferSize];

                    while ((bytesRead = fs.Read(bytes, 0, bufferSize)) > 0)
                    {
                        BW.Write(bytes, 0, bytesRead);
                    }

                    fs.Close();

                }
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            CboPictureType.SelectedIndex = 3;
        }

        private void PicFlac_DoubleClick(object sender, EventArgs e)
        {
            try
            {


                if (TieneImagen)
                {
                    using (SaveFileDialog SavDiag = new SaveFileDialog())
                    {
                        SavDiag.Filter = "Arhivo Jpeg|*.jpg";

                        if (SavDiag.ShowDialog() == DialogResult.OK)
                            PicFlac.Image.Save(SavDiag.FileName);
                    }
                    //PicFlac.Image.Save
                }
            }
            catch
            {
                MessageBox.Show("Error al guardar la imagen","Error",MessageBoxButtons.OK,MessageBoxIcon.Error);
            }
            
        }


        private void button1_Click(object sender, EventArgs e)
        {
        }
    }
}

uint8_t BuildTheDaysOfAlarms(uint8_t TheDay1, uint8_t TheDay2)
{
  return TheDay1|TheDay2;
} 

Entonces los días que queremos usar en la alarma quedarían cómo:

• 00000001 or 00100000 or 01000000 = 01010001.
• que es igual en decimal a: 1 or 16 or 64 = 81.

• Lunes a viernes = 00111110 = 62.
• Sábado = 01000000 = 64
• 62 and 64 = 0.
• El día no está en el rango.

• Lunes, miércoles y viernes = 00101010 = 42.
  
• Miércoles = 00001000 = 8
• 42 and 8 = 8
• El día está en el rango.
  

Type MiCancion = Record
	Cancion,Artista,Album : string;
	Year : Integer;
	BeatPerMinute : single
end;

        KillerQueen.Cancion := 'Killer Queen.flac';
	KillerQueen.Artista := 'Queen';
	KillerQueen.Album := 'Sheer Heart Attack';
	KillerQueen.Year := 1974;
	KillerQueen.BeatPerMinute := 117.27;

	writeln(KillerQueen.Cancion);
	writeln(KillerQueen.Artista);
	writeln(KillerQueen.Album);
	writeln(KillerQueen.Year);
	writeln(KillerQueen.BeatPerMinute);

with Epitaph do
	begin
		Cancion := 'Epitaph.flac';	
		Artista := 'King Crimson';
		Album := 'In the court of the crimson king';
		Year := 1969;
		BeatPerMinute := 100.37;
	end;

program Registros(output);

uses crt, sysutils;

Type MiCancion = Record
	Cancion,Artista,Album : string;
	Year : Integer;
	BeatPerMinute : single
end;

var

KillerQueen, Epitaph : MiCancion;

begin
	KillerQueen.Cancion := 'Killer Queen.flac';
	KillerQueen.Artista := 'Queen';
	KillerQueen.Album := 'Sheer Heart Attack';
	KillerQueen.Year := 1974;
	KillerQueen.BeatPerMinute := 117.27;

	writeln(KillerQueen.Cancion);
	writeln(KillerQueen.Artista);
	writeln(KillerQueen.Album);
	writeln(KillerQueen.Year);
	writeln(KillerQueen.BeatPerMinute);

	with Epitaph do
	begin
		Cancion := 'Epitaph.flac';	
		Artista := 'King Crimson';
		Album := 'In the court of the crimson king';
		Year := 1969;
		BeatPerMinute := 100.37;
	end;
    
	writeln(Epitaph.Cancion);
	writeln(Epitaph.Artista);
	writeln(Epitaph.Album);
	writeln(Epitaph.Year);
	writeln(Epitaph.BeatPerMinute);
	
	readln();

end.

• Nombre del campo.
• = (símbolo de igual o símbolo ASCII 0x3D).
• Descripción del campo.

• Los nombres de cada campo no deben de contener símbolos que escapen del estándar ASCII de caracteres imprimibles, es decir: de 0x20 a 0x7D (excluyendo el símbolo de igual "=" o 0x3D) y de 0x41 a 0x5A.
• Se pueden usar los siguientes nombres de campo:
• TITLE
• VERSION
• ALBUM
• TRACKNUMBER
• ARTIST
• PERFORMER
• COPYRIGHT
• LICENSE
• ORGANIZATION
• DESCRIPTION
• GENRE
• DATE
• LOCATION
• CONTACT
• ISRC
• Aunque los campos anteriores son sugeridos, podemos usar los propios (sin abusar de ello) y por ejemplo, un campo llamado BEATPERMINUTE, es totalmente válido.

• <32> El tipo de imagen de acuerdo a la descripción de la etiqueta ID3 "APIC".
• <32> El tamaño de la descripción del tipo de archivo o MIME type.
• <n*8> Cadena de texto con la descripción del tipo de archivo.
• <32> El tamaño de la descripción de la imagen.
• <n*8> La descripción de la imagen en UTF8
• <32> El ancho de la imagen en píxeles
• <32> El alto de la imagen en pixeles.
• <32> La profundidad del color de la imagen en bits por pixel.
• <32> Para las imágenes con índice de color, el número de colores usados, para el resto 0.
• <32> El tamaño de los datos de la imagen.
• <n*8> Los datos de la imagen.

• STREAM
• METADATA_BLOCK
• METADATA_BLOCK_HEADER (Encabezado)
• <1>   Indicador de último bloque
• <7>   Descriptor del tipo de bloque
• <24> Tamaño del bloque en bytes (BYTES!!!)

• 0: STREAMINFO
• Contiene información acerca de todo el archivo, este bloque es mandatorio y siempre será e primero de la secuencia después de la secuencia 0x66, 0x4c, 0x61, 0x43 (o de manera simple después de  "fLaC" ).
• 1: PADDING
• Este tipo de bloque sirve cómo reserva y el contenido no representará nada, normalmente se llena con 0x00. Cuando se crea el archivo sin los metadatos completos, en lugar des escribir un archivo nuevo con los bloques nuevos, simplemente se reemplaza este bloque conservando el archivo original y agilizando la escritura del mismo.
• 2: APPLICATION
• Nombre de la aplicación que se uso para codificar el archivo, puede ser cualquiera que el usuario elija, aunque se recomienda el registro de la aplicación para obtener un ID único para cada quien.
• 3: SEEKTABLE
• Sirve cómo marcador para desplazarse en el archivo a la hora de la reproducción, aunque se puede omitir, se recomienda incluirlo para agilizar la lectura.
• 4: VORBIS_COMMENT
• Este bloque contiene la información relevante a los creadores del contenido multimedia y la descripción del mismo, se usa la especificación de "Vorbis comment"
• 5: CUESHEET
• Contiene información que se puede usar en un CD
• 6: PICTURE
• Imagen representativa del archivo, similar a la imagen embebida en un archivo MP3.
• 7-126: Reservado
• Reservado por ahora, por lo que se podría decir que si un bloque tiene descriptor en este rango, no es valido. Se planea su uso futuro.
• 127: No válido
• Bloque no valido, ya que la misma secuencia se usa cómo marcador para sincronización.

• <16> Tamaño mínimo del bloque.
• <16> Tamaño máximo del bloque.
• <24> Tamaño mínimo del "FRAME" en bytes.
• <24> Tamaño máximo del "FRAME" en bytes.
• <20> Frecuencia de sampleo.
• <3> Número de canales.
• <36> Total de muestras por segundo.
• <128> MD5 del audio.