@ciphore/radiocli 0.2.3 → 0.2.5

package/vendor/node-airtunes2/lib/http.js

@@ -0,0 +1,189 @@
+const net = require('net')
+
+// ...
+
+const HttpMessage = (parseStartLine, writeStartLine) => {
+  const instance = {}
+
+  instance.parse = (buffer) => {
+    const messageObject = {}
+
+    // ...
+
+    let bodyIndex = buffer.indexOf('\r\n\r\n')
+    let headerString = buffer.slice(0, bodyIndex).toString()
+    let body = buffer.slice(bodyIndex + 4)
+
+    headerString.replace(/\r\n/g, '\n')
+
+    const lines = headerString.split('\n')
+
+    bodyIndex += 2
+
+    // ...
+
+    let line = lines.shift()
+    parseStartLine(line, messageObject)
+
+    // ...
+
+    messageObject.headers = {}
+
+    line = lines.shift()
+    while (line) {
+      const headerName = line.substr(0, line.indexOf(':'))
+      const headerValue = line.substr(line.indexOf(':') + 1)
+
+      messageObject.headers[headerName] = headerValue.trim()
+
+      line = lines.shift()
+    }
+
+    // ...
+
+    if (messageObject.headers['Content-Length'] && messageObject.headers['Content-Length'] != 0) {
+      messageObject.body = body
+    }
+
+    return messageObject
+  }
+
+  instance.write = (messageObject) => {
+    let messageString = writeStartLine(messageObject)
+    messageString += '\r\n'
+
+    if (messageObject.body) {
+      messageObject.headers['Content-Length'] = Buffer.byteLength(messageObject.body)
+    }
+
+    for (const header in messageObject.headers) {
+      messageString += `${header}: ${messageObject.headers[header]}\r\n`
+    }
+
+    messageString += '\r\n'
+
+    const buffer = Buffer.from(messageString)
+
+    if (!messageObject.body) {
+      return buffer
+    }
+
+    return Buffer.concat([buffer, messageObject.body], buffer.length + messageObject.body.length)
+  }
+
+  return instance
+}
+
+const HttpRequest
+  = () => HttpMessage(
+    () => {}, // currently not parsing requests.
+    messageObject => `${messageObject.method} ${messageObject.path} HTTP/1.1`,
+  )
+
+const HttpResponse
+  = () => HttpMessage(
+    (line, messageObject) => messageObject.statusCode = parseInt(line.split(' ')[1]),
+    () => {}, // currently not writing responses.
+  )
+
+// ...
+
+class HttpClient {
+  constructor() {
+    this.resolveQueue = []
+    this.pendingResponse = null
+  }
+
+  // ....
+
+  parseResponse(data) {
+    const res = HttpResponse().parse(data)
+    if (res.headers['Content-Length'] > 0) {
+      const remaining = res.headers['Content-Length'] - res.body.byteLength
+      if (remaining > 0) {
+        // not all data for this response's corresponding request was read. Create a pending response object
+        // to use for further reads.
+        this.pendingResponse = {
+          res,
+          remaining,
+        }
+      }
+    }
+
+    if (!this.pendingResponse) {
+      const rr = this.resolveQueue.shift()
+      res.statusCode === 200
+        ? rr.resolve(res)
+        : rr.resolve(null)
+    }
+  }
+
+  // ...
+
+  connect(host, port = 80) {
+    this.host = host
+
+    return new Promise((resolve) => {
+      this.socket = net.connect(
+        {
+          host,
+          port,
+        },
+        resolve,
+      )
+
+      this.socket.on('data', (data) => {
+        if (!this.pendingResponse) {
+          // there is no response pending, parse the data.
+          this.parseResponse(data)
+        }
+        else {
+          // incoming data for the pending response.
+          this.pendingResponse.res.body = Buffer.concat(
+            [this.pendingResponse.res.body, data],
+            data.byteLength + this.pendingResponse.res.body.byteLength,
+          )
+
+          this.pendingResponse.remaining -= data.byteLength
+          if (this.pendingResponse.remaining === 0) {
+            // all remaining data for the pending response has been read; resolve the promise for the
+            // corresponding request.
+            const rr = this.resolveQueue.shift()
+            this.pendingResponse.res.statusCode === 200
+              ? rr.resolve(this.pendingResponse.res)
+              : rr.reject(new Error(`HTTP status: ${this.pendingResponse.res.statusCode}`))
+
+            this.pendingResponse = null
+          }
+        }
+      })
+    })
+  }
+
+  request(method, path, headers, body) {
+    headers = headers || {}
+    // headers['Host'] = `${this.host}:${this.socket.remotePort}`;
+
+    const data = HttpRequest().write({
+      method,
+      path,
+      headers,
+      body,
+    })
+
+    // ...
+
+    return new Promise((resolve, reject) => {
+      this.resolveQueue.push({ resolve, reject })
+      this.socket.write(data)
+    })
+  }
+
+  close() {
+    this.socket.end()
+  }
+}
+
+// ...
+
+module.exports = () => new HttpClient()

package/vendor/node-airtunes2/lib/index.d.ts

@@ -0,0 +1,141 @@
+// Path: node_modules/airtunes2/lib/index.d.ts
+declare module 'airtunes2' {
+  export = AirTunes.Client;
+}
+
+declare namespace AirTunes {
+
+  /**
+   * AirTunes Casting Device
+   */
+  class CastDevice {
+    name: string
+    host: string
+    port: number
+    addresses: string | string[]
+    txt: string[]
+    airplay2: boolean
+  }
+
+  /**
+   * AirTunes Controller
+   */
+  class Controller {
+    key: string
+    setPasscode(passcode: string): void
+    setVolume(volume: number, cb?: Function): void
+    stop(cb?: Function): void
+    on(event: 'status', cb: (status: string) => void): void
+  }
+
+  /**
+   * AirTunes Device
+   * @param port The port of the device as reported by Zeroconf (default: 5000)
+   * @param volume The initial volume, which must be between 0 and 100. (default: 50)
+   * @param password The password for the device, if required. Bonjour indicates if the device demands a password.
+   */
+  interface AirPlayDevice {
+    port: number
+    volume: number
+    password?: string
+    txt: string
+    airplay2: boolean
+    debug: boolean
+    forceAlac: boolean
+  }
+
+  interface CircularBuffer {
+    write(data: Buffer): void
+  }
+
+  /**
+   * AirTunes Server
+   */
+  class Client {
+    constructor();
+
+    /**
+     * Add a airtunes device
+     * @param host The IP address of the device reported by Zeroconf (ipv4)
+     * @param options The options for the device (port, volume, password)
+     * @param mode The mode of the device (0 = local, 1 = remote, 2 = dual)
+     * @param txt The txt record of the device
+     */
+    add(host: string, options: AirPlayDevice, mode?: number, txt?: string): Controller;
+
+    /**
+     * Stop all devices
+     */
+    stopAll(cb: Function): void
+
+    /**
+     * Stop a device
+     */
+    stop(deviceKey: string, cb?: Function): void
+
+    /**
+     * End the circular buffer
+     */
+    end(): void
+
+    /**
+     * Set the volume of a device
+     * @param deviceKey The key of the device
+     * @param volume The volume to set (0-100)
+     * @param cb The callback function
+     */
+    setVolume(deviceKey: string, volume: string, cb?: Function): void
+
+    /**
+     * Set the current playback position of a device
+     * @param deviceKey The key of the device
+     * @param progress The progress to set (0-1)
+     * @param duration The duration of the track
+     * @param callback The callback function
+     */
+    setProgress(deviceKey: string, progress: number, duration: number, callback?: Function): void
+
+    /**
+     * Set the playback state of a device
+     * @param deviceKey The key of the device
+     * @param name The name of the track
+     * @param artist The artist of the track
+     * @param album The album of the track
+     * @param callback The callback function
+     */
+    setTrackInfo(deviceKey: string, name: string, artist: string, album: string, callback?: Function): void
+
+    /**
+     * Reset the AirTunes client
+     */
+    reset(): void
+
+    /**
+     * Set the artwork of a device
+     * @param deviceKey The key of the device
+     * @param art The artwork to set
+     * @param contentType The content type of the artwork
+     * @param callback The callback function
+     */
+    setArtwork(deviceKey: string, art: string | Buffer, contentType: string, callback?: Function): void
+
+
+    /**
+     * Set the passcode of a device
+     * @param deviceKey The key of the device
+     * @param passcode The passcode to set
+     */
+    setPasscode(deviceKey: string, passcode: string): void
+
+
+    // Untyped methods
+    addCoreAudio(options: Object): void
+    write(data: string): void
+
+    // Untyped properties
+    circularBuffer: CircularBuffer
+    devices: unknown
+    writable: boolean
+  }
+
+}

package/vendor/node-airtunes2/lib/index.js

@@ -0,0 +1,127 @@
+const Stream = require('stream')
+const util = require('util')
+const Devices = require('./devices')
+const config = require('./config')
+const CircularBuffer = require('./circular_buffer')
+const AudioOut = require('./audio_out')
+// const mdns = require("mdns-js");
+// var net = require('net');
+function AirTunes() {
+  var self = this
+
+  Stream.call(this)
+
+  var audioOut = new AudioOut()
+  this.devices = new Devices(audioOut)
+
+  this.devices.init()
+  this.devices.on('status', function (key, status, desc) {
+    self.emit('device', key, status, desc)
+  })
+
+  this.circularBuffer = new CircularBuffer(config.packets_in_buffer, config.packet_size)
+
+  this.circularBuffer.on('status', function (status) {
+    self.emit('buffer', status)
+  })
+
+  audioOut.init(this.devices, this.circularBuffer)
+
+  this.circularBuffer.on('drain', function () {
+    self.emit('drain')
+  })
+
+  this.circularBuffer.on('error', function (err) {
+    self.emit('error', err)
+  })
+
+  this.writable = true
+
+  // let x = mdns.tcp("dacp");
+  // let txt_record = {
+  //     Ver: "131075",
+  //     DbId: "63B5E5C0C201542E",
+  //     txtvers: "1",
+  //     OSsi: "0x1F5"
+  //   };
+
+  // this.remoteBroadcast= mdns.createAdvertisement(x, 5648, {
+  //     name: "iTunes_Ctrl_04F8191D99BEC6E9",
+  //     txt: txt_record,
+  // });
+  // this.remoteBroadcast.start();
+
+  // this.remoteserver = net.createServer(function(sock) {
+  //   // We have a connection - a socket object is assigned to the connection automatically
+  //   // Add a 'data' event handler to this instance of socket
+  //   sock.on('data', function(data) {
+  //     console.log('DATA FROM' + sock.remoteAddress + ': ' + data);
+  //     // Write the data back to the socket, the client will receive it as data from the server
+  //     sock.write("HTTP/1.1 204 No Content" + "\r\n" +
+  //     "DAAP-Server: iTunes/10.6 (Mac OS X)" + "\r\n" +
+  //     "Content-Type: application/x-dmap-tagged" + "\r\n" +
+  //     "Content-Length: 0\r\n\r\n"
+  //     );
+  //   });
+
+  //   // Add a 'close' event handler to this instance of socket
+  //  sock.on('close', function(data) {
+  //    console.log('CLOSED: ' + sock.remoteAddress +' '+ sock.remotePort);
+  //  });
+
+  // }).listen(5648);
+}
+
+util.inherits(AirTunes, Stream)
+
+AirTunes.prototype.add = function (host, options, mode = 0, txt = '') {
+  return this.devices.add('airtunes', host, options, mode, txt)
+}
+
+AirTunes.prototype.addCoreAudio = function (options) {
+  return this.devices.add('coreaudio', null, options)
+}
+
+AirTunes.prototype.stopAll = function (cb) {
+  this.devices.stopAll(cb)
+}
+
+AirTunes.prototype.stop = function (deviceKey) {
+  this.devices.stop(deviceKey)
+}
+
+AirTunes.prototype.setVolume = function (deviceKey, volume, callback) {
+  this.devices.setVolume(deviceKey, volume, callback)
+}
+
+AirTunes.prototype.setProgress = function (deviceKey, progress, duration, callback) {
+  this.devices.setProgress(deviceKey, progress, duration, callback)
+}
+
+AirTunes.prototype.setTrackInfo = function (deviceKey, name, artist, album, callback) {
+  this.devices.setTrackInfo(deviceKey, name, artist, album, callback)
+}
+
+AirTunes.prototype.reset = function () {
+  this.circularBuffer.reset()
+}
+
+AirTunes.prototype.setArtwork = function (deviceKey, art, contentType, callback) {
+  this.devices.setArtwork(deviceKey, art, contentType, callback)
+}
+
+AirTunes.prototype.write = function (data) {
+  return this.circularBuffer.write(data)
+}
+
+AirTunes.prototype.setPasscode = function (deviceKey, passcode) {
+  this.devices.setPasscode(deviceKey, passcode)
+}
+
+AirTunes.prototype.end = function () {
+  this.circularBuffer.end()
+  // this.remoteBroadcast.stop();
+  // this.remoteserver.close();
+}
+
+module.exports = AirTunes

package/vendor/node-airtunes2/lib/ntp.js

@@ -0,0 +1,37 @@
+const config = require('./config')
+
+function NTP() {
+  this.timeRef = new Date().getTime() - config.ntp_epoch * 1000
+}
+
+NTP.prototype.timestamp = function () {
+  const time = new Date().getTime() - this.timeRef
+  const sec = Math.floor(time / 1000)
+
+  const msec = time - sec * 1000
+  const ntp_msec = Math.floor(msec * 4294967.296)
+
+  const ts = new Buffer(8)
+
+  ts.writeUInt32BE(sec, 0)
+  ts.writeUInt32BE(ntp_msec, 4)
+
+  return ts
+}
+
+NTP.prototype.getTime = function (time) {
+  var time = new Date().getTime() - this.timeRef
+  var sec = Math.floor(time / 1000)
+
+  var msec = time - sec * 1000
+  var ntp_msec = Math.floor(msec * 4294967.296)
+
+  var ts = new Buffer(8)
+
+  ts.writeUInt32BE(sec, 0)
+  ts.writeUInt32BE(ntp_msec, 4)
+  console.log(time, sec)
+  return ntp_msec
+}
+
+module.exports = new NTP()

package/vendor/node-airtunes2/lib/num_util.js

@@ -0,0 +1,21 @@
+const crypto = require('crypto')
+
+exports.randomHex = function (n) {
+  return crypto.randomBytes(n).toString('hex')
+}
+
+exports.randomBase64 = function (n) {
+  return crypto.randomBytes(n).toString('base64').replace('=', '')
+}
+
+exports.randomInt = function (n) {
+  return Math.floor(Math.random() * Math.pow(10, n))
+}
+
+exports.low16 = function (i) {
+  return Math.abs(i) % 65536
+}
+
+exports.low32 = function (i) {
+  return Math.abs(i) % 4294967296
+}

package/vendor/node-airtunes2/lib/packet_pool.js

@@ -0,0 +1,43 @@
+const config = require('./config')
+
+function PacketPool() {
+  this.pool = []
+}
+
+PacketPool.prototype.getPacket = function () {
+  let packet = this.pool.shift()
+
+  if (!packet) {
+    packet = new Packet(this)
+  }
+  else
+    packet.retain()
+
+  return packet
+}
+
+PacketPool.prototype.release = function (packet) {
+  this.pool.push(packet)
+}
+
+function Packet(pool) {
+  this.pool = pool
+  this.ref = 1
+  this.seq = null
+  this.pcm = new Buffer(config.packet_size)
+}
+
+Packet.prototype.retain = function () {
+  this.ref++
+}
+
+Packet.prototype.release = function () {
+  this.ref--
+
+  if (this.ref === 0) {
+    this.seq = null
+    this.pool.release(this)
+  }
+}
+
+module.exports = PacketPool