Add multiple TPU/CPU models
Change-Id: I4182961367e090b507f7e04850d12901a303bcf6
diff --git a/Makefile b/Makefile
index bd21562..9729a88 100644
--- a/Makefile
+++ b/Makefile
@@ -12,6 +12,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
MAKEFILE_DIR := $(realpath $(dir $(lastword $(MAKEFILE_LIST))))
+TEST_DATA_URL := https://github.com/google-coral/edgetpu/raw/master/test_data
.PHONY: wasm download zip server dfu-util
@@ -48,11 +49,15 @@
"$(MAKEFILE_DIR)/bazel-bin/tflite/interpreter-wasm/interpreter.worker.js" \
"$(MAKEFILE_DIR)/site"
-download:
- cd $(MAKEFILE_DIR)/site && \
- rm -f *.tflite* && \
- wget https://github.com/google-coral/test_data/raw/master/mobilenet_v1_1.0_224_quant.tflite \
- https://github.com/google-coral/test_data/raw/master/mobilenet_v1_1.0_224_quant_edgetpu.tflite
+%.tflite:
+ cd $(dir $@) && wget "$(TEST_DATA_URL)/$(notdir $@)"
+
+download: site/mobilenet_v1_1.0_224_quant.tflite \
+ site/mobilenet_v1_1.0_224_quant_edgetpu.tflite \
+ site/ssd_mobilenet_v2_coco_quant_postprocess.tflite \
+ site/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite \
+ site/ssd_mobilenet_v2_face_quant_postprocess.tflite \
+ site/ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite
dfu-util:
git clone git://git.code.sf.net/p/dfu-util/dfu-util || true
diff --git a/README.md b/README.md
index a7bd081..558a81a 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,8 @@
# WebCoral
-emscripten_toolchain is copied from
+Firmware upload is done via webdfu
+
+emscripten_toolchain for Bazel is taken from
https://github.com/emscripten-core/emsdk/tree/master/bazel/emscripten_toolchain
+
+libusb.cc -- universal shim, inspired by
diff --git a/site/index.html b/site/index.html
index fba98ca..e8aa5a2 100644
--- a/site/index.html
+++ b/site/index.html
@@ -5,23 +5,64 @@
<title>Coral USB Accelerator Demo</title>
<script src="dfu.js"></script>
<script src="dfuse.js"></script>
- <script src="imagenet_labels.js"></script>
+ <script src="labels.js"></script>
<script src="tflite.js"></script>
<script src="interpreter.js"></script>
</head>
<body>
<h1>Coral USB Accelerator Demo</h1>
<button id="button-firmware">1. Flash Device Firmware</button> <span id="firmware-status"></span><br/><br/>
- <button id="button-init">2. Initialize Device</button><input type="checkbox" id="cpu-model">CPU</input><br/><br/>
+ <button id="button-init">2. Initialize Device</button>
+ <select id="model">
+ <option value="mobilenet_cpu">MobileNet V1 (CPU)</option>
+ <option value="mobilenet_tpu">MobileNet V1 (TPU)</option>
+ <option value="ssd_mobilenet_coco_cpu">SSD MobileNet V2 - Coco (CPU)</option>
+ <option value="ssd_mobilenet_coco_tpu">SSD MobileNet V2 - Coco (TPU)</option>
+ <option value="ssd_mobilenet_face_cpu">SSD MobileNet V2 - Face (CPU)</option>
+ <option value="ssd_mobilenet_face_tpu">SSD MobileNet V2 - Face (TPU)</option>
+ </select><br/><br/>
<button id="button-image" onclick="document.getElementById('file').click();" disabled>3. Choose Image File</button><br/><br/>
<input type="file" id="file" style="display:none;"/><br/>
- <canvas id="canvas"></canvas>
<h2 id="result"></h2>
+ <canvas id="canvas"></canvas>
<br/><br/>
<!--button id="test">Inference Test</button><br/><br/-->
<script>
+ const models = {
+ 'mobilenet_cpu': {
+ 'url': '/mobilenet_v1_1.0_224_quant.tflite',
+ 'type': 'classification',
+ 'labels': imagenet_labels,
+ },
+ 'mobilenet_tpu': {
+ 'url': '/mobilenet_v1_1.0_224_quant_edgetpu.tflite',
+ 'type': 'classification',
+ 'labels': imagenet_labels,
+ },
+ 'ssd_mobilenet_coco_cpu': {
+ 'url': '/ssd_mobilenet_v2_coco_quant_postprocess.tflite',
+ 'type': 'detection',
+ 'labels': coco_labels,
+ },
+ 'ssd_mobilenet_coco_tpu': {
+ 'url': '/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite',
+ 'type': 'detection',
+ 'labels': coco_labels,
+ },
+ 'ssd_mobilenet_face_cpu': {
+ 'url': '/ssd_mobilenet_v2_face_quant_postprocess.tflite',
+ 'type': 'detection',
+ 'labels': ['face'],
+ },
+ 'ssd_mobilenet_face_tpu': {
+ 'url': '/ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite',
+ 'type': 'detection',
+ 'labels': ['face'],
+ },
+ };
+
async function loadLocalImage(file) {
return new Promise(resolve => {
var reader = new FileReader();
@@ -145,49 +186,80 @@
}
let interpreter;
+ let model;
document.querySelector("#button-init").addEventListener('click', async () => {
- let modelName = '/mobilenet_v1_1.0_224_quant_edgetpu.tflite';
- if (document.getElementById("cpu-model").checked)
- modelName = '/mobilenet_v1_1.0_224_quant.tflite';
-
- let model = new Uint8Array(await loadFile(modelName));
- let modelBufferSize = model.length * model.BYTES_PER_ELEMENT;
- let modelBuffer = Module._malloc(modelBufferSize);
- Module.HEAPU8.set(model, modelBuffer);
-
+ model = models[document.getElementById('model').value];
+ console.log(model);
interpreter = new tflite.Interpreter();
- if (await interpreter.create(modelBuffer, modelBufferSize)) {
+ if (await interpreter.createFromBuffer(await loadFile(model.url))) {
document.getElementById("button-firmware").disabled = true;
document.getElementById("button-init").disabled = true;
- document.getElementById("cpu-model").disabled = true;
+ document.getElementById("model").disabled = true;
document.getElementById("button-image").disabled = false;
}
});
document.querySelector("#file").addEventListener('change', async () => {
- var input = document.getElementById("file");
- var file = input.files[0];
+ const input = document.getElementById("file");
+ const file = input.files[0];
if (!file) return;
- [_depth, height, width, _channels] = interpreter.inputShape();
+ [_, height, width, _] = interpreter.inputShape(0);
+ console.log('SHAPE:', width, 'x', height);
- let img = await loadLocalImage(file);
- var c = document.getElementById("canvas");
+ const img = await loadLocalImage(file);
+ const c = document.getElementById("canvas");
c.width = width;
c.height = height;
- var ctx = c.getContext('2d');
- ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, width, height);
+ const ctx = c.getContext('2d');
+ const color = 'red';
+ ctx.strokeStyle = color;
+ ctx.fillStyle = color;
+ ctx.textBaseline = 'top';
- var imageData = ctx.getImageData(0, 0, width, height);
- interpreter.setRgbaInput(0, imageData.data);
+ switch (model.type) {
+ case 'classification':
+ ctx.drawImage(img, 0, 0, img.width, img.height,
+ 0, 0, width, height);
+ break;
+ case 'detection':
+ const alpha = Math.min(width / img.width, height / img.height);
+ ctx.drawImage(img, 0, 0, img.width, img.height,
+ 0, 0, alpha * img.width, alpha * img.height);
+ break;
+ }
+
+ const imageData = ctx.getImageData(0, 0, width, height);
+ tflite.setRgbaInput(interpreter, imageData.data);
document.getElementById("result").textContent = "Recognizing...";
- let inference_start = Date.now();
- interpreter.invoke(() => {
- let inference_time = Date.now() - inference_start;
- let maxIndex = interpreter.getClassificationOutput(0);
- document.getElementById("result").textContent = `${imagenet_labels[maxIndex]} (${inference_time} ms)`;
- });
+ const inferenceStart = Date.now();
+ await interpreter.invoke();
+ const inferenceTime = Date.now() - inferenceStart;
+
+ let label = null;
+ switch (model.type) {
+ case 'classification':
+ const maxIndex = tflite.getClassificationOutput(interpreter);
+ console.log('Class:', maxIndex);
+ label = model.labels[maxIndex];
+ break;
+ case 'detection':
+ const objects = tflite.getDetectionOutput(interpreter, threshold=0.5);
+ console.log('Detected objects:', objects);
+ for (obj of objects) {
+ console.log(obj);
+ const x = obj.bbox.xmin * width;
+ const y = obj.bbox.ymin * height;
+ const w = obj.bbox.xmax * width - x;
+ const h = obj.bbox.ymax * height - y;
+ ctx.strokeRect(x, y, w, h);
+ ctx.fillText(model.labels[obj.id], x + 5, y + 5);
+ }
+ label = `${objects.length} ${objects.length == 1 ? 'object' : 'objects'}`;
+ break;
+ }
+ document.getElementById("result").textContent = `${label}: ${inferenceTime} ms`;
});
};
Module['print'] = txt => console.log(txt);
diff --git a/site/imagenet_labels.js b/site/labels.js
similarity index 95%
rename from site/imagenet_labels.js
rename to site/labels.js
index fb03f1c..b47648c 100644
--- a/site/imagenet_labels.js
+++ b/site/labels.js
@@ -14,7 +14,7 @@
* limitations under the License.
* =============================================================================
*/
-let imagenet_labels = [
+const imagenet_labels = [
"background",
"tench, Tinca tinca",
"goldfish, Carassius auratus",
@@ -1017,3 +1017,96 @@
"ear, spike, capitulum",
"toilet tissue, toilet paper, bathroom tissue"
];
+
+const coco_labels = [
+ 'person',
+ 'bicycle',
+ 'car',
+ 'motorcycle',
+ 'airplane',
+ 'bus',
+ 'train',
+ 'truck',
+ 'boat',
+ 'traffic light',
+ 'fire hydrant',
+ 'n/a',
+ 'stop sign',
+ 'parking meter',
+ 'bench',
+ 'bird',
+ 'cat',
+ 'dog',
+ 'horse',
+ 'sheep',
+ 'cow',
+ 'elephant',
+ 'bear',
+ 'zebra',
+ 'giraffe',
+ 'n/a',
+ 'backpack',
+ 'umbrella',
+ 'n/a',
+ 'n/a',
+ 'handbag',
+ 'tie',
+ 'suitcase',
+ 'frisbee',
+ 'skis',
+ 'snowboard',
+ 'sports ball',
+ 'kite',
+ 'baseball bat',
+ 'baseball glove',
+ 'skateboard',
+ 'surfboard',
+ 'tennis racket',
+ 'bottle',
+ 'n/a',
+ 'wine glass',
+ 'cup',
+ 'fork',
+ 'knife',
+ 'spoon',
+ 'bowl',
+ 'banana',
+ 'apple',
+ 'sandwich',
+ 'orange',
+ 'broccoli',
+ 'carrot',
+ 'hot dog',
+ 'pizza',
+ 'donut',
+ 'cake',
+ 'chair',
+ 'couch',
+ 'potted plant',
+ 'bed',
+ 'n/a',
+ 'dining table',
+ 'n/a',
+ 'n/a',
+ 'toilet',
+ 'n/a',
+ 'tv',
+ 'laptop',
+ 'mouse',
+ 'remote',
+ 'keyboard',
+ 'cell phone',
+ 'microwave',
+ 'oven',
+ 'toaster',
+ 'sink',
+ 'refrigerator',
+ 'n/a',
+ 'book',
+ 'clock',
+ 'vase',
+ 'scissors',
+ 'teddy bear',
+ 'hair drier',
+ 'toothbrush',
+];
diff --git a/site/tflite.js b/site/tflite.js
index 97d373f..1547317 100644
--- a/site/tflite.js
+++ b/site/tflite.js
@@ -14,7 +14,7 @@
* limitations under the License.
* =============================================================================
*/
-let tflite = {};
+const tflite = {};
(function() {
'use strict';
@@ -22,8 +22,8 @@
let nextId = 0;
function rgbaArrayToRgbArray(rgbaArray) {
- var rgbArray = new Uint8Array(new ArrayBuffer(3 * rgbaArray.length / 4));
- for (var i = 0, j = 0; i < rgbaArray.length; i += 4, j += 3) {
+ const rgbArray = new Uint8Array(new ArrayBuffer(3 * rgbaArray.length / 4));
+ for (let i = 0, j = 0; i < rgbaArray.length; i += 4, j += 3) {
rgbArray[j + 0] = rgbaArray[i + 0];
rgbArray[j + 1] = rgbaArray[i + 1];
rgbArray[j + 2] = rgbaArray[i + 2];
@@ -35,6 +35,55 @@
return 'interpreter_' + id;
}
+ tflite.setRgbInput = function(interpreter, rgbArray, index=0) {
+ const shape = interpreter.inputShape(index);
+ if (rgbArray.length != shape.reduce((a, b) => a * b))
+ throw new Error('Invalid input array size');
+
+ writeArrayToMemory(rgbArray, interpreter.inputBuffer(index));
+ }
+
+ tflite.setRgbaInput = function(interpreter, rgbaArray) {
+ tflite.setRgbInput(interpreter, rgbaArrayToRgbArray(rgbaArray));
+ }
+
+ tflite.getClassificationOutput = function(interpreter, index=0) {
+ const count = interpreter.outputShape(index).reduce((a, b) => a * b);
+ const scoresPtr = interpreter.outputBuffer(index) / Module.HEAPU8.BYTES_PER_ELEMENT;
+ const scores = Module.HEAPU8.slice(scoresPtr, scoresPtr + count);
+ return scores.indexOf(Math.max(...scores));
+ }
+
+ tflite.getDetectionOutput = function(interpreter, threshold=0.0) {
+ const bboxesPtr = interpreter.outputBuffer(0) / Module.HEAPF32.BYTES_PER_ELEMENT;
+ const idsPtr = interpreter.outputBuffer(1) / Module.HEAPF32.BYTES_PER_ELEMENT;
+ const scoresPtr = interpreter.outputBuffer(2) / Module.HEAPF32.BYTES_PER_ELEMENT;
+ const countPtr = interpreter.outputBuffer(3) / Module.HEAPF32.BYTES_PER_ELEMENT;
+
+ const count = Math.round(Module.HEAPF32[countPtr]);
+ const bboxes = Module.HEAPF32.slice(bboxesPtr, bboxesPtr + 4 * count);
+ const ids = Module.HEAPF32.slice(idsPtr, idsPtr + count);
+ const scores = Module.HEAPF32.slice(scoresPtr, scoresPtr + count);
+
+ const objects = [];
+ for (let i = 0; i < count; ++i) {
+ if (scores[i] < threshold)
+ break;
+
+ objects.push({
+ 'id': ids[i],
+ 'score': scores[i],
+ 'bbox' : {
+ 'ymin': Math.max(0.0, bboxes[4 * i]),
+ 'xmin': Math.max(0.0, bboxes[4 * i + 1]),
+ 'ymax': Math.min(1.0, bboxes[4 * i + 2]),
+ 'xmax': Math.min(1.0, bboxes[4 * i + 3]),
+ },
+ });
+ }
+ return objects;
+ }
+
tflite.Interpreter = function() {
this.interpreter_create = Module.cwrap('interpreter_create', 'number', ['number'], { async: true });
this.interpreter_destroy = Module.cwrap('interpreter_destroy', null, ['number']);
@@ -54,16 +103,52 @@
this.id = nextId++;
Module['invokeDone'] = function(id) {
- let key = callbackKey(id);
- let callback = Module[key];
+ const key = callbackKey(id);
+ const callback = Module[key];
if (callback) callback();
delete Module[key];
};
}
- tflite.Interpreter.prototype.create = async function(modelBuffer, modelBufferSize) {
- this.interpreter = await this.interpreter_create(modelBuffer, modelBufferSize, 0);
- return this.interpreter != null;
+ tflite.Interpreter.prototype.createFromBuffer = async function(buffer) {
+ const model = new Uint8Array(buffer);
+ const modelBufferSize = model.length * model.BYTES_PER_ELEMENT;
+ const modelBufferPtr = Module._malloc(modelBufferSize);
+ Module.HEAPU8.set(model, modelBufferPtr);
+ this.interpreter = await this.interpreter_create(modelBufferPtr, modelBufferSize, 0);
+
+ if (this.interpreter == null)
+ return false;
+
+ this.input_shapes = [];
+ this.input_buffers = [];
+ const num_inputs = this.interpreter_num_inputs(this.interpreter);
+ for (let ti = 0; ti < num_inputs; ++ti) {
+ const shape = [];
+ const dims = this.interpreter_num_input_dims(this.interpreter, ti);
+ for (let i = 0; i < dims; ++i)
+ shape.push(this.interpreter_input_dim(this.interpreter, ti, i));
+ this.input_shapes.push(shape);
+
+ const buffer = this.interpreter_input_buffer(this.interpreter, ti);
+ this.input_buffers.push(buffer);
+ }
+
+ this.output_shapes = [];
+ this.output_buffers = [];
+ const num_outputs = this.interpreter_num_outputs(this.interpreter);
+ for (let ti = 0; ti < num_outputs; ++ti) {
+ const shape = [];
+ const dims = this.interpreter_num_output_dims(this.interpreter, ti);
+ for (let i = 0; i < dims; ++i)
+ shape.push(this.interpreter_output_dim(this.interpreter, ti, i));
+ this.output_shapes.push(shape);
+
+ const buffer = this.interpreter_output_buffer(this.interpreter, ti);
+ this.output_buffers.push(buffer);
+ }
+
+ return true;
}
tflite.Interpreter.prototype.destroy = function() {
@@ -71,58 +156,34 @@
}
tflite.Interpreter.prototype.numInputs = function() {
- return this.interpreter_num_inputs(this.interpreter);
+ return this.input_shapes.length;
}
tflite.Interpreter.prototype.inputBuffer = function(index) {
- return this.interpreter_input_buffer(this.interpreter, index);
+ return this.input_buffers[index];
}
tflite.Interpreter.prototype.inputShape = function(index) {
- let dims = this.interpreter_num_input_dims(this.interpreter, index);
- let shape = [];
- for (let i = 0; i < dims; ++i)
- shape.push(this.interpreter_input_dim(this.interpreter, index, i));
- return shape;
+ return this.input_shapes[index];
}
tflite.Interpreter.prototype.numOutputs = function() {
- return this.interpreter_num_outputs(this.interpreter);
+ return this.output_shapes.length;
}
tflite.Interpreter.prototype.outputBuffer = function(index) {
- return this.interpreter_output_buffer(this.interpreter, index);
+ return this.output_buffers[index];
}
tflite.Interpreter.prototype.outputShape = function(index) {
- let dims = this.interpreter_num_output_dims(this.interpreter, index);
- let shape = [];
- for (let i = 0; i < dims; ++i)
- shape.push(this.interpreter_output_dim(this.interpreter, index, i));
- return shape;
+ return this.output_shapes[index];
}
- tflite.Interpreter.prototype.invoke = function(callback) {
- Module[callbackKey(this.id)] = callback;
- this.interpreter_invoke_async(this.interpreter, this.id);
- }
-
- tflite.Interpreter.prototype.setRgbInput = function(index, rgbArray) {
- let shape = this.inputShape(index);
- if (rgbArray.length != shape.reduce((a, b) => a * b))
- throw new Error('Invalid input array size');
-
- writeArrayToMemory(rgbArray, this.inputBuffer(index));
- }
-
- tflite.Interpreter.prototype.setRgbaInput = function(index, rgbaArray) {
- this.setRgbInput(index, rgbaArrayToRgbArray(rgbaArray));
- }
-
- tflite.Interpreter.prototype.getClassificationOutput = function(index, rgbaArray) {
- let size = this.outputShape(index).reduce((a, b) => a * b);
- let buf = this.outputBuffer(index);
- let tensor = Module.HEAPU8.slice(buf, buf + size);
- return tensor.indexOf(Math.max(...tensor))
+ tflite.Interpreter.prototype.invoke = function() {
+ const self = this;
+ return new Promise(resolve => {
+ Module[callbackKey(self.id)] = resolve;
+ self.interpreter_invoke_async(self.interpreter, self.id);
+ });
}
})();
diff --git a/tflite/libusb.cc b/tflite/libusb.cc
index 6195c93..18ac6f6 100644
--- a/tflite/libusb.cc
+++ b/tflite/libusb.cc
@@ -25,6 +25,18 @@
#define LIBUSB_NANO 0
#define LIBUSB_RC ""
+//#define LIBUSB_ENABLE_LOG
+
+#ifdef LIBUSB_ENABLE_LOG
+#define LIBUSB_LOG(...) \
+ do { \
+ fprintf(stdout, __VA_ARGS__); \
+ fflush(stdout); \
+ } while (false)
+#else // LIBUSB_ENABLE_LOG
+#define LIBUSB_LOG(...)
+#endif // LIBUSB_ENABLE_LOG
+
struct libusb_device {
uint8_t bus_number;
uint8_t port_number;
@@ -54,7 +66,8 @@
static int js_request_device(struct libusb_device *dev) {
return MAIN_THREAD_EM_ASM_INT({
return Asyncify.handleAsync(async () => {
- console.log('js_request_device');
+ //console.log('js_request_device');
+
// Bus 001 Device 005: ID 1a6e:089a Global Unichip Corp.
// Bus 002 Device 007: ID 18d1:9302 Google Inc.
let options = {'filters': [{'vendorId': 0x18d1, 'productId': 0x9302}]};
@@ -69,7 +82,7 @@
}
}
- console.log('js_request_device, device list:', devices);
+ //console.log('js_request_device, device list:', devices);
if (devices.length === 1) {
let d = devices[0];
@@ -94,7 +107,7 @@
uint16_t wIndex, uint8_t *data, uint16_t wLength, unsigned int timeout) {
return MAIN_THREAD_EM_ASM_INT({
return Asyncify.handleAsync(async () => {
- console.log('js_control_transfer');
+ //console.log('js_control_transfer');
let bmRequestType = $0;
let bRequest = $1;
@@ -160,7 +173,7 @@
extern "C" {
int libusb_init(libusb_context **ctx) {
- std::cout << "libusb_init" << std::endl;
+ LIBUSB_LOG("libusb_init");
if (!EM_ASM_INT(return navigator.usb !== undefined))
return LIBUSB_ERROR_NOT_SUPPORTED;
@@ -170,21 +183,21 @@
}
void LIBUSB_CALL libusb_exit(libusb_context *ctx) {
- std::cout << "libusb_exit" << std::endl;
+ LIBUSB_LOG("libusb_exit");
delete ctx;
}
void LIBUSB_CALL libusb_set_debug(libusb_context *ctx, int level) {
- std::cout << "<NOT IMPLEMENTED> libusb_set_debug" << std::endl;
+ LIBUSB_LOG("<NOT IMPLEMENTED> libusb_set_debug");
}
const struct libusb_version* LIBUSB_CALL libusb_get_version() {
- std::cout << "libusb_get_version" << std::endl;
+ LIBUSB_LOG("libusb_get_version");
return &libusb_version_internal;
}
struct libusb_transfer* LIBUSB_CALL libusb_alloc_transfer(int iso_packets) {
- std::cout << "libusb_alloc_transfer" << std::endl;
+ LIBUSB_LOG("libusb_alloc_transfer");
size_t size = sizeof(struct libusb_transfer) +
sizeof(struct libusb_iso_packet_descriptor) * iso_packets;
@@ -193,7 +206,7 @@
}
int LIBUSB_CALL libusb_submit_transfer(struct libusb_transfer *transfer) {
- std::cout << "libusb_submit_transfer" << std::endl;
+ LIBUSB_LOG("libusb_submit_transfer");
bool dir_in = (transfer->endpoint & 0x80) == 0x80;
uint8_t endpoint = transfer->endpoint & 0x7f;
@@ -203,7 +216,8 @@
case LIBUSB_TRANSFER_TYPE_INTERRUPT:
if (dir_in) {
MAIN_THREAD_ASYNC_EM_ASM({
- console.log('js_submit_bulk_in_transfer, endpoint: ', $0);
+ //console.log('js_submit_bulk_in_transfer, endpoint: ', $0);
+
this.libusb_device.transferIn($0, $2).then(function(result) {
var data = new Uint8Array(result.data.buffer);
writeArrayToMemory(data, $1);
@@ -215,7 +229,7 @@
}, endpoint, transfer->buffer, transfer->length, transfer);
} else {
MAIN_THREAD_ASYNC_EM_ASM({
- console.log('js_submit_bulk_out_transfer, endpoint: ', $0);
+ //console.log('js_submit_bulk_out_transfer, endpoint: ', $0);
var data = new Uint8Array($2);
for(let i = 0; i < $2; ++i)
@@ -231,29 +245,29 @@
}
break;
default:
- printf("Transfer type not implemented: %u\n", transfer->type);
+ LIBUSB_LOG("Transfer type not implemented: %u\n", transfer->type);
return LIBUSB_ERROR_IO;
}
return LIBUSB_SUCCESS;
}
int LIBUSB_CALL libusb_cancel_transfer(struct libusb_transfer *transfer) {
- std::cout << "<NOT IMPLEMENTED> libusb_cancel_transfer" << std::endl;
+ LIBUSB_LOG("<NOT IMPLEMENTED> libusb_cancel_transfer");
return 0;
}
void LIBUSB_CALL libusb_free_transfer(struct libusb_transfer *transfer) {
- std::cout << "libusb_free_transfer" << std::endl;
+ LIBUSB_LOG("libusb_free_transfer");
free(transfer);
}
uint8_t libusb_get_port_number(libusb_device * dev) {
- std::cout << "libusb_get_port_number" << std::endl;
+ LIBUSB_LOG("libusb_get_port_number");
return dev->port_number;
}
int libusb_get_port_numbers(libusb_device *dev,uint8_t *port_numbers, int port_numbers_len) {
- std::cout << "libusb_get_port_numbers" << std::endl;
+ LIBUSB_LOG("libusb_get_port_numbers");
if (port_numbers_len <= 0)
return LIBUSB_ERROR_INVALID_PARAM;
@@ -270,7 +284,7 @@
while (true) {
if (auto item = ctx->completed_transfers.Pop(25)) {
auto* transfer = item.value();
- std::cout << "== Running callback ==" << std::endl;
+ //std::cout << "== Running callback ==" << std::endl;
transfer->callback(transfer);
} else {
break;
@@ -280,11 +294,12 @@
}
int LIBUSB_CALL libusb_reset_device(libusb_device_handle *dev) {
- std::cout << "libusb_reset_device" << std::endl;
+ LIBUSB_LOG("libusb_reset_device");
+
return MAIN_THREAD_EM_ASM_INT({
return Asyncify.handleAsync(async () => {
try {
- console.log('js_reset_device');
+ //console.log('js_reset_device');
await this.libusb_device.reset();
return 0; // LIBUSB_SUCCESS
} catch (error) {
@@ -299,31 +314,31 @@
int LIBUSB_CALL libusb_control_transfer(libusb_device_handle *dev_handle,
uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
unsigned char *data, uint16_t wLength, unsigned int timeout) {
- std::cout << "libusb_control_transfer" << std::endl;
+ LIBUSB_LOG("libusb_control_transfer");
return js_control_transfer(request_type, bRequest, wValue, wIndex, data, wLength, timeout);
}
int LIBUSB_CALL libusb_bulk_transfer(libusb_device_handle *dev_handle,
unsigned char endpoint, unsigned char *data, int length,
int *actual_length, unsigned int timeout) {
- std::cout << "<NOT IMPLEMENTED> libusb_bulk_transfer" << std::endl;
+ LIBUSB_LOG("<NOT IMPLEMENTED> libusb_bulk_transfer");
return 0;
}
int LIBUSB_CALL libusb_interrupt_transfer(libusb_device_handle *dev_handle,
unsigned char endpoint, unsigned char *data, int length,
int *actual_length, unsigned int timeout) {
- std::cout << "<NOT IMPLEMENTED> libusb_interrupt_transfer" << std::endl;
+ LIBUSB_LOG("<NOT IMPLEMENTED> libusb_interrupt_transfer");
return 0;
}
int LIBUSB_CALL libusb_open(libusb_device *dev, libusb_device_handle **handle) {
- std::cout << "libusb_open" << std::endl;
+ LIBUSB_LOG("libusb_open");
// dev->descriptor.idVendor, dev->descriptor.idProduct
MAIN_THREAD_EM_ASM_INT({
return Asyncify.handleAsync(async () => {
- console.log('js_open_device');
+ //console.log('js_open_device');
await this.libusb_device.open();
try {
await this.libusb_device.reset(); // TODO(dkovalev)
@@ -343,11 +358,11 @@
}
void LIBUSB_CALL libusb_close(libusb_device_handle *dev_handle) {
- std::cout << "libusb_close" << std::endl;
+ LIBUSB_LOG("libusb_close");
MAIN_THREAD_EM_ASM_INT({
Asyncify.handleAsync(async () => {
- console.log('js_close_device');
+ //console.log('js_close_device');
return await this.libusb_device.close();
});
});
@@ -356,12 +371,12 @@
}
libusb_device * LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle) {
- std::cout << "libusb_get_device" << std::endl;
+ LIBUSB_LOG("libusb_get_device");
return dev_handle->dev;
}
ssize_t LIBUSB_CALL libusb_get_device_list(libusb_context *ctx, libusb_device ***list) {
- std::cout << "libusb_get_device_list" << std::endl;
+ LIBUSB_LOG("libusb_get_device_list");
auto* dev = &ctx->dev;
dev->ctx = ctx;
@@ -377,7 +392,7 @@
}
void LIBUSB_CALL libusb_free_device_list(libusb_device* *list, int unref_devices) {
- std::cout << "libusb_free_device_list: unref_devices=" << unref_devices << std::endl;
+ LIBUSB_LOG("libusb_free_device_list: unref_devices=%d", unref_devices);
int i = 0;
while (true) {
@@ -390,32 +405,32 @@
}
int LIBUSB_CALL libusb_get_device_descriptor(libusb_device *dev, struct libusb_device_descriptor *desc) {
- std::cout << "libusb_get_device_descriptor" << std::endl;
+ LIBUSB_LOG("libusb_get_device_descriptor");
*desc = dev->descriptor;
return 0;
}
int LIBUSB_CALL libusb_get_device_speed(libusb_device *dev) {
- std::cout << "libusb_get_device_speed" << std::endl;
+ LIBUSB_LOG("libusb_get_device_speed");
return LIBUSB_SPEED_SUPER; // TODO(dkovalev)
}
uint8_t LIBUSB_CALL libusb_get_bus_number(libusb_device *dev) {
- std::cout << "libusb_get_bus_number" << std::endl;
+ LIBUSB_LOG("libusb_get_bus_number");
return dev->bus_number;
}
int LIBUSB_CALL libusb_set_configuration(libusb_device_handle *dev, int configuration) {
- std::cout << "<NOT IMPLEMENTED> libusb_set_configuration" << std::endl;
+ LIBUSB_LOG("<NOT IMPLEMENTED> libusb_set_configuration");
return 0;
}
int LIBUSB_CALL libusb_claim_interface(libusb_device_handle *dev, int interface_number) {
- std::cout << "libusb_claim_interface: " << interface_number << std::endl;
+ LIBUSB_LOG("libusb_claim_interface: %d", interface_number);
return MAIN_THREAD_EM_ASM_INT({
return Asyncify.handleAsync(async () => {
try {
- console.log('js_claim_interface: ', $0);
+ //console.log('js_claim_interface: ', $0);
await this.libusb_device.claimInterface($0);
return 0; // LIBUSB_SUCCESS
} catch (error) {
@@ -427,11 +442,11 @@
}
int LIBUSB_CALL libusb_release_interface(libusb_device_handle *dev, int interface_number) {
- std::cout << "libusb_release_interface: " << interface_number << std::endl;
+ LIBUSB_LOG("libusb_release_interface: %d", interface_number);
return MAIN_THREAD_EM_ASM_INT({
return Asyncify.handleAsync(async () => {
try {
- console.log('js_release_interface: ', $0, this.libusb_device);
+ //console.log('js_release_interface: ', $0, this.libusb_device);
await this.libusb_device.releaseInterface($0);
return 0; // LIBUSB_SUCCESS
} catch (error) {
@@ -444,7 +459,7 @@
EMSCRIPTEN_KEEPALIVE void set_transfer_error(struct libusb_transfer* transfer) {
- std::cout << "==> set_tansfer_error [" << transfer << "]" << std::endl;
+ LIBUSB_LOG("==> set_tansfer_error [%p]", transfer);
libusb_context* ctx = transfer->dev_handle->dev->ctx;
transfer->status = LIBUSB_TRANSFER_CANCELLED;
@@ -454,7 +469,7 @@
}
EMSCRIPTEN_KEEPALIVE void set_transfer_completed(struct libusb_transfer* transfer, int actual_length) {
- std::cout << "==> set_tansfer_completed [" << transfer << "]: " << actual_length << std::endl;
+ LIBUSB_LOG("==> set_tansfer_completed [%p]: %d", transfer, actual_length);
libusb_context* ctx = transfer->dev_handle->dev->ctx;
transfer->status = LIBUSB_TRANSFER_COMPLETED;
