Esempio n. 1
0
        /// <summary>
        /// Carrega um array de bytes como vídeo.
        /// </summary>
        /// <param name="tipo">tipo do arquivo em string.</param>
        /// <param name="lLista">Lista a receber o arquivo de vídeo.</param>
        /// <param name="indice">índice de começo do vídeo.</param>
        /// <param name="dadosVideo">conjunto de bytes do vídeo.</param>
        private void CarregaVideos(String tipo,
                                   List <Video> Videos,
                                   int indice,
                                   Byte[] dadosVideo)
        {
            //todo: tentar substituir as strings e utilizar tipovideo.

            //caso o vídeo seja apenas vídeo e não PLS então será apenas UM arquivo de vídeo.
            switch (tipo)
            {
            case "V01":
            {
                // Instancia o video a partir do formato
                VideoV01 video = new VideoV01();
                // Carrega através do ARRAY
                video.LoadFromBytes(dadosVideo);
                // Adiciona o video
                Videos.Add(video);
            }
            break;

            case "V02":
            {
                // Instancia o video a partir do formato
                VideoV02 video = new VideoV02();
                // Carrega através do ARRAY
                video.LoadFromBytes(dadosVideo);
                // Adiciona o video
                Videos.Add(video);
            }
            break;

            case "V03":
            {
            }
            break;

            case "V04":
            {
            }
            break;

            case "PLS":
            {
                //Instancia o PLS.
                Arquivo_PLS please = new Arquivo_PLS();

                please.LoadFromBytes(dadosVideo);

                foreach (Video video in please.listaVideos)
                {
                    Videos.Add(video);
                }
            }
            break;
            }
        }
        private void FromBytesToFormatoPainelCfg(byte[] dados)
        {
            unsafe
            {
                fixed(byte *pSrc = dados)
                {
                    FormatoPainelCfg *config = (FormatoPainelCfg *)pSrc;

                    this.versao = config->versao;

                    this.alternanciaSelecionada = config->alternanciaSelecionada;

                    this.altura  = config->altura;
                    this.largura = config->largura;

                    for (int i = 0; i < 50; i++)
                    {
                        this.fontePath = this.fontePath + (char)config->fontePath[i];
                    }

                    this.crc = config->crc;

                    this.mensagemSelecionada = config->mensagem_selecionada;
                    //adicionado na versao 2 do painel CFG
                    this.mensagemSecSelecionada = config->mensagem_Secselecionada;


                    //adição dos parametrosfixos no painel.cfg
                    this.somenteHora     = config->somenteHora;
                    this.dataHora        = config->dataHora;
                    this.horaSaida       = config->horaSaida;
                    this.temperatura     = config->temperatura;
                    this.tarifa          = config->tarifa;
                    this.horaTemperatura = config->horaTemperatura;
                    this.velocidade      = config->velocidade;
                    this.dataHoraTemp    = config->dataHoraTemp;
                    this.BrilhoMax       = config->BrilhoMax;
                    this.BrilhoMin       = config->BrilhoMin;


                    this.videosMensagensEspeciais.Clear();
                    int indice = (int)(sizeof(FormatoPainelCfg) - 4);

                    for (int i = 0; i < 16; i++)
                    {
                        int indiceInicial = indice;
                        // Pegar o tamanho do Arquivo
                        uint   tamanhoArquivo = BitConverter.ToUInt32(dados, indice);
                        byte[] dadosVideo     = new byte[tamanhoArquivo];
                        // Atualiza o indice com o tamanho do arquivo
                        indice += sizeof(uint);
                        // Pular a versão
                        indice++;

                        Array.Copy(dados, indiceInicial, dadosVideo, 0, tamanhoArquivo);

                        // Pegar o formato do Arquivo Ex.: V02
                        if (Encoding.ASCII.GetString(dados, indice, 3).ToUpper().Equals("V01"))
                        {
                            // Instancia o video a partir do formato
                            VideoV01 video = new VideoV01();
                            // Carrega através do ARRAY
                            video.LoadFromBytes(dadosVideo);
                            // Adiciona o video
                            videosMensagensEspeciais.Add(video);
                            indice += dadosVideo.Length;
                        }
                        else if (Encoding.ASCII.GetString(dados, indice, 3).ToUpper().Equals("V02"))
                        {
                            // Instancia o video a partir do formato
                            VideoV02 video = new VideoV02();
                            // Carrega através do ARRAY
                            video.LoadFromBytes(dadosVideo);
                            // Adiciona o video
                            videosMensagensEspeciais.Add(video);
                            indice += dadosVideo.Length;
                        }

                        //barata, adicionei isso aqui. o índice tava cagado.
                        indice = indice - sizeof(uint);
                        indice = indice - 1;
                    }
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Traduz os bytes de dados arrayados para o formato novo.
        /// </summary>
        /// <param name="dados">Arquivo já lido do disco.</param>
        private void FromBytesToFormatoMPT(byte[] dados)
        {
            unsafe
            {
                fixed(byte *pSrc = dados)
                {
                    FormatoMensagemPaths *mensagemPaths = (FormatoMensagemPaths *)pSrc;

                    this.versao     = mensagemPaths->versao;
                    this.reservado  = mensagemPaths->reservado;
                    this.idMensagem = mensagemPaths->idMensagem;
                    for (int i = 0; i < 58; i++)
                    {
                        this.reservado2[i] = mensagemPaths->reservado2[i];
                    }
                    this.crc = mensagemPaths->crc;
                    //a princípio, vamos pular esses 64 bytes.
                    //this.pathVideo = ArrayLDX2.ByteArrayToString(mensagemPaths->pathVideo, 64);

                    //limpa a lista de videos
                    this.Videos.Clear();

                    //indice para leitura dos dados no arquivo.
                    int indice = sizeof(FormatoMensagemPaths) - 64;

                    //efetua a leitura do tamanho do vídeo.(próximos 4 bytes após o FormatoMensagemPaths)
                    uint TamanhoArquivo = BitConverter.ToUInt32(dados, indice);

                    //indice do inicio do arquivo a ser lido
                    int indiceInicial = indice;

                    //pula o tamanho. (já no conteúdo de vídeo.)
                    indice = indice + sizeof(uint);
                    //pula a versão.
                    indice = indice + 1;

                    //aloca o suficiente pra ler o vídeo.
                    byte[] dadosVideo = new byte[TamanhoArquivo];

                    //copia os dados do arquivo de vídeo com o tamanho e versão.
                    Array.Copy(dados, indiceInicial, dadosVideo, 0, TamanhoArquivo);

                    //verifica o tipo do vídeo(v01 ou v02) ou se é Arquivo PLS..Equals("V01")
                    String tipo = Encoding.ASCII.GetString(dados, indice, 3).ToUpper();

                    //todo: tentar substituir as strings e utilizar tipovideo.

                    //caso o vídeo seja apenas vídeo e não PLS então será apenas UM arquivo de vídeo.
                    switch (tipo)
                    {
                    case "V01":
                    {
                        // Instancia o video a partir do formato
                        VideoV01 video = new VideoV01();
                        // Carrega através do ARRAY
                        video.LoadFromBytes(dadosVideo);
                        // Adiciona o video
                        Videos.Add(video);
                    }
                    break;

                    case "V02":
                    {
                        // Instancia o video a partir do formato
                        VideoV02 video = new VideoV02();
                        // Carrega através do ARRAY
                        video.LoadFromBytes(dadosVideo);
                        // Adiciona o video
                        Videos.Add(video);
                    }
                    break;

                    case "V03":
                    {
                    }
                    break;

                    case "V04":
                    {
                    }
                    break;

                    case "PLS":
                    {
                        //Instancia o PLS.
                        Arquivo_PLS please = new Arquivo_PLS();

                        please.LoadFromBytes(dadosVideo);

                        foreach (Video video in please.listaVideos)
                        {
                            Videos.Add(video);
                        }
                    }
                    break;
                    }

                    indice += dadosVideo.Length;
                }
            }
        }