Ajuda... (((b1 & 0xFF) | (b2 & 0xFF) << 8) & 0xFFFF); [Resolvido]

5 de setembro de 2009 2 respostas

Haskell 5 de setembro de 2009

Olá pessoal, será que alguém consegue me explicar o que este método está fazendo, que tipo de calculo está sendo realizado. :?:

int readInt16() {
        short shorty = 0;
        int b1 = AudioData[readpos++];
        int b2 = AudioData[readpos++];

        shorty = (short) (((b1 & 0xFF) | (b2 & 0xFF) << 8) & 0xFFFF);
        return (int) shorty;
    }

Este AudioData é um array de int. Ele armazena o conteúdo de um arquivo de áudio .wav da minha aplicação… Tem milhares de posições (+50.000).

Eu sei que ele trabalha pegando 2 posições do vetor, faz um cálculo sobre eles, e retorna um único valor. E seu plotar estes novos valores extraídos deste array, eu obtenho um gráfico da onda sonora.
Ele faz exatamente o que eu preciso, ou seja, extrair a onda sonora deste arquivo de áudio.

Porém, eu encontrei este método pronto na internet… Ele funciona como o esperado, mas eu gostaria de saber que tipo de operação está sendo realizada na LINHA 6.

Muito obrigado

2 Respostas

ViniGodoy 5 de set. de 2009

Para entender esse método, você tem que entender o que os operadores de bit-a-bit fazem.
& - Efetua a operação "and" em cada bit dos dois valores fornecidos
| - Efetua a operação "or" em cada bit dos dois valores fornecidos
N << Y - Desloca o número N, Y bits para esquerda

shorty = (short) (((b1 & 0xFF) | (b2 & 0xFF) &lt;&lt; 8) & 0xFFFF);

b1 & 0xFF = Pega o valor do último byte de b1. Por exemplo, vamos supor que b1 tivesse o valor:
11101101 11101101
Com a máscara 0xFF:
00000000 11111111
Teríamos como resultado:

11101101 11101101  & 
00000000 11111111  
-----------------
00000000 11101101 (último byte de b1)

(b2 & 0xFF) << 8 = Paga o valor do último byte de B2, e desloca 8 bits para esquerda
Ou seja, se ao final da operação com o & o valor do último byte de b2 for 11001111, o << 8 vai transforma-lo em: 11001111 00000000

O | combina os bytes b1 e b2, para formar um short. Assim:

00000000 11101101 | (b1 & 0xFF) 
11001111 00000000   ((b2 & 0xFF) &lt;&lt; 8) 
-----------------
110011111 1101101 (b2 b1 - combinados)

Não entendi para que serve o último &. Ele faria o mesmo que no caso de b1 e b2, mas combinar o que já tem 2 bits dessa forma acabará com um número rigorosamente igual:

110011111 1101101 & 
11111111 11111111
-----------------
110011111 1101101

Isso só teria sentido se a variável short estivesse sendo convertida para int.
Assim o primeiro dígito iria deixar de ser entendido como bit de sinal.

Provavelmente essa última comparação poderá ser removida.

Haskell 5 de set. de 2009

Meu amigo… Muito obrigado.

Era uma explicação nesse estilo que eu esperava.

Valeu mesmo, agora deu pra entender certinho o que está acontecendo.

Abraço

Criado 5 de setembro de 2009

Ultima resposta 5 de set. de 2009

Respostas 2

Participantes 2

2 Respostas

Topicos relacionados