Beispiel #1
0
        public bool VerificarCRC(byte[] dados)
        {
            unsafe
            {
                fixed(byte *pSrc = dados)
                {
                    FormatoFonte *parametros = (FormatoFonte *)pSrc;

                    return(parametros->crc == CalcularCRC(dados));
                }
            }
        }
Beispiel #2
0
        private void FromBytesToFormatoFonte(byte[] dados)
        {
            unsafe
            {
                fixed(byte *pSrc = dados)
                {
                    FormatoFonte *formatoFonte = (FormatoFonte *)pSrc;

                    this.Versao = formatoFonte->versao;

                    this.Altura = formatoFonte->altura;

                    this.flags = formatoFonte->flags;

                    for (int i = 0; i < 49; i++)
                    {
                        this.nomeFonte[i] = formatoFonte->nomeFonte[i];
                    }

                    this.crc = formatoFonte->crc;

                    int indiceInfoCaractere = 0;

                    this.caracteres.Clear();

                    //carrega as informações do cabeçalho de caracteres.
                    for (int i = 0; i < 224; i++)
                    {
                        CaractereInfo  c = new CaractereInfo();
                        CaractereInfo *caracteresInfo = ((CaractereInfo *)formatoFonte->caractereInfo);
                        c.codigo         = caracteresInfo[i].codigo;
                        c.enderecoBitmap = caracteresInfo[i].enderecoBitmap;
                        this.caracteres.Add(c);
                    }
                }
            }
            //caracteres.Sort(delegate(CaractereInfo a, CaractereInfo b)
            //                    {
            //                        return a.codigo.CompareTo(b.codigo);
            //                    });
            // Ordenar os caracteres pelo código, pois algumas fontes do Pontos 6 não estão em ordem
            caracteres.Sort((a, b) => a.codigo.CompareTo(b.codigo));

            //carrega as informações sobre os bitmaps.
            this.bitmaps.Clear();
            for (int bitmap = 0; bitmap < 224; bitmap++)
            {
                Bitmap b = new Bitmap();
                b = CarregarBitmap(this.NomeArquivo, caracteres[bitmap].enderecoBitmap, bitmap);
                this.bitmaps.Add(b);
            }
        }
Beispiel #3
0
        private byte[] toByteArray()
        {
            unsafe
            {
                Byte[] resultado = new Byte[sizeof(FormatoFonte)];

                fixed(byte *pSrc = resultado)
                {
                    FormatoFonte *formatoFonte = (FormatoFonte *)pSrc;

                    formatoFonte->versao = this.Versao;

                    for (int i = 0; i < 3; i++)
                    {
                        formatoFonte->reservado[i] = this.reservado[i];
                    }

                    formatoFonte->altura = this.Altura;

                    for (int i = 0; i < 4; i++)
                    {
                        formatoFonte->reservado2[i] = this.reservado2[i];
                    }

                    formatoFonte->flags = this.flags;

                    for (int i = 0; i < 49; i++)
                    {
                        formatoFonte->nomeFonte[i] = this.nomeFonte[i];
                    }

                    formatoFonte->crc = this.crc;

                    for (int caracInfo = 0; caracInfo < 224; caracInfo++)
                    {
                        CaractereInfo *caracteresInfo = ((CaractereInfo *)formatoFonte->caractereInfo);
                        caracteresInfo[caracInfo].codigo         = this.caracteres[caracInfo].codigo;
                        caracteresInfo[caracInfo].enderecoBitmap = this.caracteres[caracInfo].enderecoBitmap;
                    }
                }

                return(resultado);
            }
        }
Beispiel #4
0
        private unsafe UInt16 CalcularCRC(Byte[] dados)
        {
            int         tamanho;
            List <byte> dadosBitmaps = new List <byte>();

            Byte[] dadosCRC = new byte[dados.Length - sizeof(UInt16)];

            fixed(byte *pSrc = dados)
            {
                FormatoFonte *parametros = (FormatoFonte *)pSrc;

                Array.Copy(dados, 0, dadosCRC, 0, (int)&parametros->crc - (int)pSrc);
                Array.Copy(dados, ((int)&parametros->crc - (int)pSrc + sizeof(UInt16)), dadosCRC,
                           (int)&parametros->crc - (int)pSrc,
                           sizeof(FormatoFonte) - ((int)&parametros->crc - (int)pSrc + sizeof(UInt16)));

                for (int i = sizeof(FormatoFonte); i < dados.Length; i++)
                {
                    dadosCRC[i - 2] = dados[i];
                }

                //return CRC16CCITT.Calcular(dadosCRC);
            }

            //foreach (Bitmap bmp in this.bitmaps)
            //{
            //    dadosBitmaps.AddRange(bmp.FromMatrixToArray());
            //}

            //tamanho = dadosCRC.Length;

            //Array.Resize(ref dadosCRC, dadosCRC.Length + dadosBitmaps.Count);

            //byte[] aux = dadosBitmaps.ToArray();
            //Array.Copy(aux, 0, dadosCRC, tamanho, aux.Length);

            return(CRC16CCITT.Calcular(dadosCRC));
        }
Beispiel #5
0
        private void FromBytesToFormatoFonteSimples(byte[] dados)
        {
            unsafe
            {
                fixed(byte *pSrc = dados)
                {
                    FormatoFonte *formatoFonte = (FormatoFonte *)pSrc;

                    this.Versao = formatoFonte->versao;

                    this.Altura = formatoFonte->altura;

                    this.flags = formatoFonte->flags;

                    for (int i = 0; i < 49; i++)
                    {
                        this.nomeFonte[i] = formatoFonte->nomeFonte[i];
                    }

                    this.crc = formatoFonte->crc;
                }
            }
        }