@ciphore/radiocli 0.2.4 → 0.2.5

package/vendor/node-airtunes2/src/aes_utils.h

@@ -0,0 +1,24 @@
+#ifndef _AES_H
+#define _AES_H
+
+#ifndef uint8
+#define uint8  unsigned char
+#endif
+
+#ifndef uint32
+#define uint32 unsigned long int
+#endif
+
+typedef struct
+{
+    uint32 erk[64];     /* encryption round keys */
+    uint32 drk[64];     /* decryption round keys */
+    int nr;             /* number of rounds */
+}
+aes_context;
+
+int  aes_set_key( aes_context *ctx, uint8 *key, int nbits );
+void aes_encrypt( aes_context *ctx, uint8 input[16], uint8 output[16] );
+void aes_decrypt( aes_context *ctx, uint8 input[16], uint8 output[16] );
+
+#endif /* aes.h */

package/vendor/node-airtunes2/src/base64.c

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 1995-2001 Kungliga Tekniska H�gskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: base64.c,v 1.1.1.1 2005/07/23 13:57:04 shiro Exp $");
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include "base64.h"
+
+static char base64_chars[] = 
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static int 
+pos(char c)
+{
+    char *p;
+    for (p = base64_chars; *p; p++)
+	if (*p == c)
+	    return p - base64_chars;
+    return -1;
+}
+
+int 
+base64_encode(const void *data, int size, char **str)
+{
+    char *s, *p;
+    int i;
+    int c;
+    const unsigned char *q;
+
+    p = s = (char *) malloc(size * 4 / 3 + 4);
+    if (p == NULL)
+	return -1;
+    q = (const unsigned char *) data;
+    i = 0;
+    for (i = 0; i < size;) {
+	c = q[i++];
+	c *= 256;
+	if (i < size)
+	    c += q[i];
+	i++;
+	c *= 256;
+	if (i < size)
+	    c += q[i];
+	i++;
+	p[0] = base64_chars[(c & 0x00fc0000) >> 18];
+	p[1] = base64_chars[(c & 0x0003f000) >> 12];
+	p[2] = base64_chars[(c & 0x00000fc0) >> 6];
+	p[3] = base64_chars[(c & 0x0000003f) >> 0];
+	if (i > size)
+	    p[3] = '=';
+	if (i > size + 1)
+	    p[2] = '=';
+	p += 4;
+    }
+    *p = 0;
+    *str = s;
+    return strlen(s);
+}
+
+#define DECODE_ERROR 0xffffffff
+
+static unsigned int
+token_decode(const char *token)
+{
+    int i;
+    unsigned int val = 0;
+    int marker = 0;
+    if (strlen(token) < 4)
+	return DECODE_ERROR;
+    for (i = 0; i < 4; i++) {
+	val *= 64;
+	if (token[i] == '=')
+	    marker++;
+	else if (marker > 0)
+	    return DECODE_ERROR;
+	else
+	    val += pos(token[i]);
+    }
+    if (marker > 2)
+	return DECODE_ERROR;
+    return (marker << 24) | val;
+}
+
+int
+base64_decode(const char *str, void *data)
+{
+    const char *p;
+    unsigned char *q;
+
+    q = (unsigned char*)data;
+    for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
+	unsigned int val = token_decode(p);
+	unsigned int marker = (val >> 24) & 0xff;
+	if (val == DECODE_ERROR)
+	    return -1;
+	*q++ = (val >> 16) & 0xff;
+	if (marker < 2)
+	    *q++ = (val >> 8) & 0xff;
+	if (marker < 1)
+	    *q++ = val & 0xff;
+    }
+    return q - (unsigned char *) data;
+}

package/vendor/node-airtunes2/src/base64.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1995, 1996, 1997 Kungliga Tekniska H�gskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* $Id: base64.h,v 1.1.1.1 2005/07/23 13:57:04 shiro Exp $ */
+
+#ifndef _BASE64_H_
+#define _BASE64_H_
+
+int base64_encode(const void *data, int size, char **str);
+int base64_decode(const char *str, void *data);
+
+#endif

package/vendor/node-airtunes2/src/bindings.cc

@@ -0,0 +1,29 @@
+#include <v8.h>
+#include <node.h>
+
+
+using namespace v8;
+using namespace node;
+
+
+namespace nodeairtunes {
+
+void InitCodec(Local<Object>);
+#ifdef __APPLE__
+void InitCoreAudio(Local<Object>);
+#endif
+
+void Initialize(Local<Object> target) {
+
+  Isolate* isolate = v8::Isolate::GetCurrent();
+  HandleScope scope(isolate);
+
+  InitCodec(target);
+#ifdef __APPLE__
+  InitCoreAudio(target);
+#endif
+}
+
+} // nodeairtunes namespace
+
+NODE_MODULE(airtunes, nodeairtunes::Initialize);

package/vendor/node-airtunes2/src/codec.cc

@@ -0,0 +1,170 @@
+#include <node.h>
+#include <node_buffer.h>
+#include <v8.h>
+#include <cstring>
+
+extern "C" {
+#include "aes_utils.h"
+}
+
+#include "base64.h"
+
+
+using namespace v8;
+using namespace node;
+
+const int kBlockSize = 16;
+static int kFramesPerPacket = 352;
+
+// These values should be changed at each iteration
+static uint8_t iv [] = { 0x78, 0xf4, 0x41, 0x2c, 0x8d, 0x17, 0x37, 0x90, 0x2b, 0x15, 0xa6, 0xb3, 0xee, 0x77, 0x0d, 0x67 };
+static uint8_t aes_key [] = { 0x14, 0x49, 0x7d, 0xcc, 0x98, 0xe1, 0x37, 0xa8, 0x55, 0xc1, 0x45, 0x5a, 0x6b, 0xc0, 0xc9, 0x79 };
+
+namespace nodeairtunes {
+
+
+void EncodeALAC(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = Isolate::GetCurrent();
+  Local<Context> ctx = isolate->GetCurrentContext();
+  EscapableHandleScope scope(isolate);
+
+  if(args.Length() < 4) {
+    printf("expected: EncodeALAC(encoder, pcmData, pcmSize, alacData, alacSize)\n");
+    args.GetReturnValue().Set(Null(isolate));
+  }
+
+  // Local<Object> wrapper;
+  // args[0]->ToObject(ctx).ToLocal(&wrapper);
+  // ALACEncoder *encoder = (ALACEncoder*)wrapper->GetAlignedPointerFromInternalField(0);
+
+  Local<Value> pcmBuffer = args[1];
+  Local<Object> pcmObj;
+  pcmBuffer->ToObject(ctx).ToLocal(&pcmObj);
+  unsigned char* pcmData = (unsigned char*)Buffer::Data(pcmObj);
+
+  Local<Value> alacBuffer = args[2];
+  Local<Object> alacObj;
+  alacBuffer->ToObject(ctx).ToLocal(&alacObj);
+  unsigned char* alacData = (unsigned char*)Buffer::Data(alacObj);
+
+  int32_t pcmSize = args[3]->Int32Value(ctx).FromJust();
+
+  // AudioFormatDescription inputFormat, outputFormat;
+  // FillInputAudioFormat(&inputFormat);
+  // FillOutputAudioFormat(&outputFormat);
+
+  int32_t alacSize = pcmSize;
+
+  int bsize = 352;
+  int frames = 352;
+  int *size  = &alacSize;
+	uint8_t *sample = pcmData;
+  uint8_t **out = &alacData;
+
+  #ifndef min
+  #define min(a,b) (((a) < (b)) ? (a) : (b))
+  #endif
+
+  uint8_t *p;
+	uint32_t *in = (uint32_t*) sample;
+	int count;
+
+	frames = min(frames, bsize);
+
+	// *out = (uint8_t*) malloc(bsize * 4 + 8);
+	p = *out;
+
+	*p++ = (1 << 5);
+	*p++ = 0;
+	*p++ = (1 << 4) | (1 << 1) | ((bsize & 0x80000000) >> 31); // b31
+	*p++ = ((bsize & 0x7f800000) << 1) >> 24;	// b30--b23
+	*p++ = ((bsize & 0x007f8000) << 1) >> 16;	// b22--b15
+	*p++ = ((bsize & 0x00007f80) << 1) >> 8;	// b14--b7
+	*p =   ((bsize & 0x0000007f) << 1);       	// b6--b0
+	*p++ |= (*in &  0x00008000) >> 15;			// LB1 b7
+
+	count = frames - 1;
+
+	while (count--) {
+		// LB1 b6--b0 + LB0 b7
+		*p++ = ((*in & 0x00007f80) >> 7);
+		// LB0 b6--b0 + RB1 b7
+		*p++ = ((*in & 0x0000007f) << 1) | ((*in & 0x80000000) >> 31);
+		// RB1 b6--b0 + RB0 b7
+		*p++ = ((*in & 0x7f800000) >> 23);
+		// RB0 b6--b0 + next LB1 b7
+		*p++ = ((*in & 0x007f0000) >> 15) | ((*(in + 1) & 0x00008000) >> 15);
+
+		in++;
+	}
+
+	// last sample
+	// LB1 b6--b0 + LB0 b7
+	*p++ = ((*in & 0x00007f80) >> 7);
+	// LB0 b6--b0 + RB1 b7
+	*p++ = ((*in & 0x0000007f) << 1) | ((*in & 0x80000000) >> 31);
+	// RB1 b6--b0 + RB0 b7
+	*p++ = ((*in & 0x7f800000) >> 23);
+	// RB0 b6--b0 + next LB1 b7
+	*p++ = ((*in & 0x007f0000) >> 15);
+
+	// when readable size is less than bsize, fill 0 at the bottom
+	count = (bsize - frames) * 4;
+	while (count--)	*p++ = 0;
+
+	// frame footer ??
+	*(p-1) |= 1;
+	*p = (7 >> 1) << 6;
+
+	*size = p - *out + 1;
+  //encoder->Encode(inputFormat, outputFormat, pcmData, alacData, &alacSize);
+
+  args.GetReturnValue().Set(Integer::New(isolate, alacSize));
+}
+
+void EncryptAES(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = v8::Isolate::GetCurrent();
+  Local<Context> ctx = isolate->GetCurrentContext();
+  EscapableHandleScope scope(isolate);
+
+  if(args.Length() < 2) {
+    printf("expected: EncryptAES(alacData, alacSize)\n");
+    args.GetReturnValue().Set(Null(isolate));
+  }
+
+  Local<Value> alacBuffer = args[0];
+  Local<Object> alacObj;
+  alacBuffer->ToObject(ctx).ToLocal(&alacObj);
+  unsigned char* alacData = (unsigned char*)Buffer::Data(alacObj);
+  int32_t alacSize = args[1]->Int32Value(isolate->GetCurrentContext()).FromJust();
+
+  // This will encrypt data in-place
+  uint8_t *buf;
+  int i = 0, j;
+  uint8_t nv[kBlockSize];
+
+  aes_context aes_ctx;
+  aes_set_key(&aes_ctx, aes_key, 128);
+  memcpy(nv, iv, kBlockSize);
+
+  while(i + kBlockSize <= alacSize) {
+    buf = alacData + i;
+
+    for(j = 0; j < kBlockSize; j++)
+      buf[j] ^= nv[j];
+
+    aes_encrypt(&aes_ctx, buf, buf);
+    memcpy(nv, buf, kBlockSize);
+
+    i += kBlockSize;
+  }
+
+  args.GetReturnValue().Set(Null(isolate));
+}
+
+void InitCodec(Local<Object> target) {
+  NODE_SET_METHOD(target, "encodeALAC", EncodeALAC);
+  NODE_SET_METHOD(target, "encryptAES", EncryptAES);
+}
+
+} // nodeairtunes namespace