tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

audio-data-serialization.any.js (2703B)

      1 // META: global=window
      2 // META: script=/common/media.js
      3 // META: script=/webcodecs/utils.js
      4 
      5 var defaultInit = {
      6  timestamp: 1234,
      7  channels: 2,
      8  sampleRate: 8000,
      9  frames: 100,
     10 }
     11 
     12 function createDefaultAudioData() {
     13  return make_audio_data(defaultInit.timestamp,
     14                          defaultInit.channels,
     15                          defaultInit.sampleRate,
     16                          defaultInit.frames);
     17 }
     18 
     19 async_test(t => {
     20  let originalData = createDefaultAudioData();
     21 
     22  let channel = new MessageChannel();
     23  let localPort = channel.port1;
     24  let externalPort = channel.port2;
     25 
     26  externalPort.onmessage = t.step_func((e) => {
     27    let newData = e.data;
     28 
     29    // We should have a valid deserialized buffer.
     30    assert_equals(newData.numberOfFrames, defaultInit.frames, 'numberOfFrames');
     31    assert_equals(
     32        newData.numberOfChannels, defaultInit.channels, 'numberOfChannels');
     33    assert_equals(newData.sampleRate, defaultInit.sampleRate, 'sampleRate');
     34 
     35    const originalData_copyDest = new Float32Array(defaultInit.frames);
     36    const newData_copyDest = new Float32Array(defaultInit.frames);
     37 
     38    for (var channel = 0; channel < defaultInit.channels; channel++) {
     39      originalData.copyTo(originalData_copyDest, { planeIndex: channel});
     40      newData.copyTo(newData_copyDest, { planeIndex: channel});
     41 
     42      for (var i = 0; i < newData_copyDest.length; i+=10) {
     43        assert_equals(newData_copyDest[i], originalData_copyDest[i],
     44          "data (ch=" + channel + ", i=" + i + ")");
     45      }
     46    }
     47 
     48    newData.close();
     49    externalPort.postMessage("Done");
     50  })
     51 
     52  localPort.onmessage = t.step_func_done((e) => {
     53    assert_equals(originalData.numberOfFrames, defaultInit.frames);
     54    originalData.close();
     55  })
     56 
     57  localPort.postMessage(originalData);
     58 
     59 }, 'Verify closing AudioData does not propagate accross contexts.');
     60 
     61 async_test(t => {
     62  let data = createDefaultAudioData();
     63 
     64  let channel = new MessageChannel();
     65  let localPort = channel.port1;
     66 
     67  localPort.onmessage = t.unreached_func();
     68 
     69  data.close();
     70 
     71  assert_throws_dom("DataCloneError", () => {
     72    localPort.postMessage(data);
     73  });
     74 
     75  t.done();
     76 }, 'Verify posting closed AudioData throws.');
     77 
     78 async_test(t => {
     79  let localData = createDefaultAudioData();
     80 
     81  let channel = new MessageChannel();
     82  let localPort = channel.port1;
     83  let externalPort = channel.port2;
     84 
     85  externalPort.onmessage = t.step_func_done((e) => {
     86    let externalData = e.data;
     87    assert_equals(externalData.numberOfFrames, defaultInit.frames);
     88    externalData.close();
     89  })
     90 
     91  localPort.postMessage(localData, [localData]);
     92  assert_not_equals(localData.numberOfFrames, defaultInit.frames);
     93 }, 'Verify transferring audio data closes them.');