We had several wireless lavalier mics whose vendor app had been discontinued. The mics still powered on and paired, but the only thing a phone or PC could use was the standard Bluetooth headset profile. The good audio path ran over a private serial protocol that only the vendor app spoke, and the vendor’s update and licence servers were offline.

The goal was concrete: record several of these mics at once, each as its own track, on Windows and Android, with the protocol fully under our control. Later goals added video, other microphones, a build pipeline that ships to stores, and a remote mode where one device starts and collects takes from another.

This post follows the path from a decompiled APK to that result, and covers the failures that shaped each step.

Production Symptoms

• Through the headset profile the mic was a call microphone: 16 kHz wideband at best, and one mic at a time.
• The vendor app no longer installed or worked on current phones. Its servers timed out, refused connections or redirected to a DNS block page.
• No public documentation existed for the serial protocol or the audio codec.
• Each mic has its own crystal. Two mics, a sound card and a camera run on four different clocks, so long takes drift apart.

Step 1: Recover the Protocol Statically

The first plan assumed we would need Bluetooth HCI snoop logs and runtime hooking, because the vendor SDK shipped an “authenticate” native library. Neither was needed.

The path that worked:

1. Decompile the APK (jadx). The SDK core was obfuscated into single-letter packages: transport, session logic, parsers, a setting-to-command map, payload builders and codec detection.
2. Map the obfuscated classes against a public sample project of an older version of the same SDK, which still had readable names.
3. Rewrite framing, commands and parameter encoding as a small Python module.
4. Check the encoder against the two session packets that the app hard-codes. Both came out byte-identical, which confirmed the checksum rule before any hardware test.

The link format is a 9-byte header followed by an optional command frame. All integers are big-endian, and every checksum is the two’s complement of the byte sum:

def checksum(data: bytes) -> int:
    """Two's complement of the byte sum: sum(data) + cksum == 0 mod 256."""
    return (-sum(data)) & 0xFF


def build_link_header(total_len: int, seq: int, ack: int, ptype: int) -> bytes:
    """9-byte link header: FF 5A len16 40 seq ack type cksum."""
    h = SYNC + struct.pack(">HBBBB", total_len, HDR_BYTE4, seq & 0xFF, ack & 0xFF, ptype)
    return h + bytes([checksum(h)])


def build_frame(cmd: int, payload: bytes, seq: int = 0, ack: int = 0) -> bytes:
    sub = b"\x00\x00" + SUB_MAGIC + struct.pack(">HH", len(payload) + 6, cmd)
    total = 9 + len(sub) + len(payload) + 1
    body = sub + payload
    return build_link_header(total, seq, ack, 2) + body + bytes([checksum(body)])

Settings use a 6-byte parameter block (00 06 | subtype16 | value16). The vendor code divides by 255 instead of 256 when it splits the high byte. The reference encoder keeps that bug on purpose, because the device firmware was written against it.

The static pass also covered authentication. The licence library checks the app’s own SDK licence against a server, not the device. The device-level challenge command exists, but its handler in the app is empty and no response is ever sent. On the firmware we tested, the device never sent the challenge.

Step 2: Identify the Audio Codec

The audio command carries a 4-byte timestamp and then a frame with a 4-byte header. Three findings together identified the codec:

• The decoder library imports celt_mode_create, celt_decoder_create and a four-argument celt_decode. That signature exists only in CELT 0.7 to 0.10; 0.11 added a frame-size argument.
• Its internal functions carry a prefix over upstream names. All 19 of them exist in the CELT 0.7.1 source. Pitch prediction is among them, and it was removed in 0.8, which rules out later versions.
• The rate and frame-size tables were read straight from the library’s read-only data section (in a disassembler, after mapping virtual addresses to file offsets).

The 4-byte header is a vendor wrapper that the decoder strips before calling stock libcelt:

def parse_header(b):
    if len(b) < 4 or b[0] != 0x9E or (b[1] & 0x24):
        return None
    rate = RATES[(b[1] >> 6) & 3]
    ch_code = (b[1] >> 4) & 3
    if ch_code > 1:
        return None
    return {"rate": rate, "channels": ch_code + 1, "frame_size": FRAME_SIZES[b[1] & 3],
            "flags": b[2], "nbytes": b[3]}

The proof was empirical: stock CELT 0.7.1, built from the upstream tarball, decoded the first 443 captured frames with zero errors. The stream is 44.1 kHz stereo with 512 samples and 190 bytes per frame. That is about 86 packets per second and about 131 kbit/s. Left and right are identical, because the mic has a mono capsule.

Step 3: The Proof of Concept on Real Hardware

The proof of concept was a Python client on a Windows ARM64 laptop. On Windows you can connect an RFCOMM socket to a service UUID with port 0, and the stack resolves the channel through SDP. That removes the need to know the channel number:

def open_rfcomm(mac, channel=None, timeout=10.0):
    s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM)
    if channel:
        s.settimeout(timeout)
        s.connect((mac, channel))
    elif os.name == "nt":
        s.setblocking(True)  # raw Winsock connect must not see a non-blocking socket
        _connect_by_uuid_windows(s, mac, SPP_UUID)
    ...

The setblocking(True) line was the first live bug. The first probe failed with Winsock error 10035 (WSAEWOULDBLOCK). A timeout set earlier had made the socket non-blocking, and the raw connect call through ctypes does not handle that.

After the fix the observed sequence was:

1. Session open at +0.5 s.
2. Device version report at +0.84 s, followed by an unprompted state dump.
3. Four rounds of clock sync (about 130 ms each).
4. Start-audio command at +1.37 s, first audio at +2.29 s.

A heartbeat every 500 ms keeps the stream alive. Session open and clock sync turned out to be optional; audio streams without them.

The live tests answered the questions static analysis could not:

• Setting writes are never acknowledged, but they persist across reconnects.
• The quality levels request 190/170/140 bytes per frame, and the device actually delivers 190/180/150.
• The standard A2DP headphone output works while the private stream is running, so audio back to the mic needs no private protocol.
• An early assumption from community material was that the headset profile would be narrowband (3.5 kHz). On Windows 11 it negotiates wideband mSBC at 16 kHz. It is still far below the private stream, which is full band to about 20 kHz.

Firmware modification was part of the original question. It was dropped: no firmware image newer than the device’s own was obtainable, and nothing was ever sent to or flashed onto a mic.

The clock problem shows up

A bridge script played the decoded stream to a Windows output device. The first run used a plain FIFO. The buffer grew to 174 ms and 232 ms of audio was dropped. The mic’s sample clock and the sound card’s clock do not run at the same rate, and a FIFO between them either fills up or runs dry.

The fix was a jitter buffer that resamples by a ratio steered by its own fill level, clamped to ±0.5 % so the correction is inaudible. The same controller ended up in the app:

var err = (_count - _frac - TargetSamples) / Math.Max(TargetSamples, 1);
Ratio = 1.0 + Math.Clamp(Gain * err, -MaxRatioDeviation, MaxRatioDeviation);
var lastIdx = _frac + (frames - 1) * Ratio;
if (lastIdx + 1 >= _count)
{
    Underruns++;
    _started = false;
    output.Clear();
    return false;
}

With it, a 40 s live run decoded 3,489 frames with 0 decode errors and 0 underruns, and buffer latency stayed between 46 and 91 ms.

Step 4: From Script to Windows App

Requirements for the app: several mics at once, one start/stop for all of them, native on Windows ARM64 and x64, and nothing that blocks a later macOS or Linux port.

.NET MAUI was the first candidate. It was dropped because it has no Linux target, and on macOS (through Mac Catalyst) it cannot use the classic Bluetooth API that RFCOMM needs. The stack became .NET 10 with Avalonia.

The architecture has three layers:

• Core, with no OS APIs: framing, session handling, the CELT binding, jitter buffer and recorder. It is unit-tested against real captures.
• Platform layers per OS: RFCOMM, device discovery, audio output, and later camera and encoders.
• App heads: thin per-platform entry points. They hand the shared UI an IAppHost with the hub factory, recording folder, permission prompts and share/open actions.

The first Windows build took minutes, not days, because Core was a direct port of the Python module that was already verified against hardware. The first CLI run on the real mic recorded 440 frames with 0 decode errors.

Native code was the hard part

CELT is C, so every target needs its own binary. Two problems came out of that.

The first was loading. A Zig-built ARM64 Windows DLL failed to load with “incorrect format”, although its headers looked correct. Rebuilding with llvm-mingw fixed it, and Zig was dropped. Loading is now one resolver that knows each platform’s layout:

private static IntPtr Resolve(string name, Assembly assembly, DllImportSearchPath? path)
{
    if (!Libs.TryGetValue(name, out var f))
    {
        return IntPtr.Zero;
    }
    if (OperatingSystem.IsAndroid())
    {
        return NativeLibrary.TryLoad(f.Unix, out var lib) ? lib : IntPtr.Zero;
    }
    if (OperatingSystem.IsIOS())
    {
        var framework = Path.Combine(AppContext.BaseDirectory, "Frameworks", $"{name}.framework", name);
        return NativeLibrary.TryLoad(framework, out var lib) ? lib : IntPtr.Zero;
    }
    var os = OperatingSystem.IsWindows() ? "win" : OperatingSystem.IsMacOS() ? "osx" : "linux";
    // ... map ProcessArchitecture to arm64/x64/x86 ...
    var candidate = Path.Combine(AppContext.BaseDirectory, "runtimes", $"{os}-{arch}", "native", file);
    if (NativeLibrary.TryLoad(candidate, out var handle))
    {
        return handle;
    }
    return NativeLibrary.TryLoad(name, assembly, path, out handle) ? handle : IntPtr.Zero;
}

The second was thread safety, and it only showed up with several mics. Rendering store screenshots with several simulated mics crashed the process inside celt_decode. Without -DVAR_ARRAYS, CELT 0.7.1 falls back to one process-wide scratch stack, so two decoders on two threads corrupt each other. Every build script now passes the flag. A regression test that decodes the same capture on several threads at once crashed the test host on the old binary and passes on the new one.

Step 5: Android

The Android head went in after the shared UI was moved into a UserControl that both heads host. Bluetooth maps directly: BluetoothSocket to the same service UUID, with a fallback for stacks that refuse an authenticated link to an already-bonded device. CELT is built with NDK r29, aligned to 16 KB pages for Android 15+.

Audio-only recording worked on the first install. Video did not.

Eight frames, all at timestamp 0

The first Android video take contained 8 video frames, all stamped 0 ms, next to 7.6 s of correct audio. The first guesses were a wrong clock mapping and a stalled encoder drain. A self-test that opened the camera on the phone and counted frames showed something else: the preview stopped after about five frames, and the encoder received none.

The cause was one line. The preview ImageReader image was wrapped in a C# using. In .NET for Android, Dispose() releases the managed peer but does not call the Java Image.close(). With maxImages=2 the reader’s buffers were never returned, the camera HAL timed out dequeuing new ones, and the whole repeating capture request stalled. That included the encoder’s stream.

private void OnImage(ImageReader reader)
{
    var image = reader.AcquireLatestImage();
    if (image is null)
    {
        return;
    }
    try { ConvertPreview(image); }
    finally { image.Close(); } // Dispose() does not close the Java Image; unclosed images stall the whole capture session.
}

After the fix the same self-test produced 89 frames in 3 s, 3 key frames, and monotonic timestamps.

Rotation hints are not reliable

Portrait video played sideways. The recorder wrote the rotation as a container hint, and players handle the Matroska hint inconsistently. Our sign was also wrong. Fixing the sign was not enough, so the phone now draws each camera frame upright through OpenGL into the encoder’s input surface, and the container hint is 0. One more trap: on the test phone, SurfaceTexture.GetTransformMatrix() already contained the sensor rotation, so applying it as well rotated the frames twice.

Step 6: Build and Release Pipeline

The pipeline runs on a GitHub release. The tag version (v1.2.3) gives every store its build number: the Android version code, the Apple build number and the MSIX version.

Native libraries are cross-compiled on a single Linux runner:

• CELT and LAME are downloaded from pinned URLs and checked against pinned SHA-256 hashes.
• llvm-mingw produces the Windows DLLs and the NDK produces the Android .so files.
• The results are uploaded as artifacts and consumed by the platform jobs.

There is no build matrix; the per-target loop lives in the same scripts developers run locally:

for pair in aarch64:android-arm64 x86_64:android-x64; do
  arch="${pair%%:*}"
  rid="${pair#*:}"
  out="$here/runtimes/$rid/native"
  mkdir -p "$out"
  (cd "$src" && "$clang" --target="$arch-linux-android$api" -shared -fPIC -O2 -DHAVE_LRINTF -DVAR_ARRAYS \
      -Wl,-z,max-page-size=16384 -Wl,-soname,libcelt071.so -Wno-everything \
      -o "$out/libcelt071.so" $files -lm)
  echo "built $out/libcelt071.so"
done

A screenshot job renders the UI headlessly with simulated mics that replay a real captured session. A Python step frames those screenshots and builds every store asset. It also validates the listing text against store limits.

What the first real releases broke

• iOS: the newest .NET iOS workload required an Xcode version the default macOS runner did not have. The fix was to move the job to a newer runner image and add an explicit Xcode selection step.
• Android: the release asked for an AAB, but only an APK came out. The project file set AndroidPackageFormat (singular) and CI passed AndroidPackageFormats (plural). The singular property won, so the CI override had no effect. The fix was renaming one property. A second fix was needed because the signed APK lands one directory above publish/, while the AAB lands inside it.
• Microsoft Store: the submission API has no image type for the portrait poster we generated, and the submission failed. The poster is still generated, but it is no longer uploaded.
• Signing: a missing keystore had produced a debug-signed build instead of an error. It is now a hard failure, and keystore passwords are passed as file: paths instead of command-line values.

Google Play publishing uses no stored key. GitHub’s OIDC token is exchanged through Google Workload Identity Federation for a short-lived service-account identity:

- name: Authenticate to Google Cloud
  uses: google-github-actions/auth@v3
  with:
    workload_identity_provider: ${{ vars.GCP_WORKLOAD_IDENTITY_PROVIDER }}
    service_account: ${{ vars.GCP_PLAY_SERVICE_ACCOUNT }}
- name: Submit to Google Play
  run: >
    python Tools/store/google_play.py --assets in/store-assets/android
    --package "in/android/app-$VERSION-android.aab" --build-number "$BUILD"
    --version "$VERSION" --track "$TRACK" --status "$STATUS"

The submission script does everything in one Play “edit”: upload, check that the version code matches, update listings and images, set the track, validate and commit. If any step fails it deletes the edit, so a broken run never leaves a half-updated listing.

Step 7: Remote Mode

The requirement: any instance can control any other over Wi-Fi or Bluetooth, each device records its own audio and video locally, and when the take stops the controller collects everything into one package. Finding another device should be a simple search, regardless of transport.

Discovery

On Wi-Fi the searcher broadcasts a short query to the global broadcast address, a multicast group and each interface’s subnet broadcast. It repeats the query, because single datagrams get lost on busy Wi-Fi:

async Task SendLoop()
{
    // Datagrams get lost on busy Wi-Fi: ask a few times.
    foreach (var delay in new[] { 0, 700, 1500, 3000 })
    {
        await Task.Delay(delay, ct).ConfigureAwait(false);
        foreach (var t in targets)
        {
            try { await udp.SendAsync(query, t, ct).ConfigureAwait(false); }
            catch (SocketException) { /* unreachable network */ }
        }
    }
}

On Bluetooth each instance runs an RFCOMM service with its own UUID, and the searcher probes paired phones and computers. Results from both transports are merged by a per-install ID, and Wi-Fi is preferred. The link itself is a minimal frame format over any duplex stream: a 1-byte kind, a 4-byte length, and a JSON payload (raw bytes for file chunks). Header and payload go out in one write, because on Bluetooth each write can become its own packet. Control requires a consent prompt on the remote device.

Starting at the same instant

The controller estimates each remote’s clock offset with an NTP-style exchange, and keeps the sample with the lowest round-trip time:

var offset = p.T2 - (p.T1 + t3) / 2;
lock (_lock)
{
    _samples.Add((rtt, offset));
    // Keep ~2 minutes: during a file sync pings wait behind file data, and only the old, fast samples are accurate.
    if (_samples.Count > 120)
    {
        _samples.RemoveAt(0);
    }
    var best = _samples.MinBy(s => s.Rtt);
    ClockOffset = best.Offset;
    ClockRtt = TimeSpan.FromTicks(best.Rtt);
}

To start a take, the controller picks a start time 700 ms ahead (1,200 ms if any remote is on Bluetooth). It translates that time into each remote’s clock and sends it. Each device sleeps until shortly before the instant and then spins until its own clock reaches it:

var wait = TimeSpan.FromTicks(startAt - MediaClock.Now);
if (wait > TimeSpan.FromMilliseconds(20))
{
    await Task.Delay(wait - TimeSpan.FromMilliseconds(15));
}
while (MediaClock.Now < startAt)
{
    Thread.Yield();
}
_hub.StartRecordingAll(RecordingRoot);

Each remote reports its actual start, and the controller stores the residual offset and its uncertainty in the take manifest. Every audio track is already locked to the device’s host clock, so an editor only has to shift each device by one constant.

The bug behind the comment

The comment about pings waiting behind file data came from a real failure. After a long Bluetooth file sync, the manifest recorded an offset of 1.9 s ± 1.9 s. The pings sent during the transfer had queued behind 64 KiB file chunks on a link that moved only 55–80 KB/s. Their slow samples replaced the good one. Two changes fixed it: keep the best sample over about two minutes, and store the offset measured at Start instead of a later one. The retest gave 25 ms ± 4 ms.

Two other fixes came out of cross-platform testing:

• A mic name containing a colon was valid on Android and invalid as a Windows file name, so the transfer to Windows failed. All received and generated file names now go through one sanitiser.
• A protocol level bump was nearly shipped in a way that would make older releases refuse the handshake. The wire version stays 1, and a separate level field announces newer messages such as pause. Old peers ignore the field and are flagged as not supporting pause.

Runtime Impact

• Decoding: 0 decode errors across every live capture, from the first 443 frames to multi-minute takes.
• Tests: 10 tests on day one, about 350 later, run on win-arm64 and win-x64. They include bit-exact decode of a real capture and the multi-threaded CELT regression test.
• Windows video: 1080p30 on the hardware H.264 encoder, about 10.5 Mbit/s against a 12 Mbit/s target. Recording starts in 24–40 ms with a pre-warmed encoder.
• Remote over Wi-Fi: the peer is found in 100–161 ms, remotes start 3–19 ms from the scheduled instant, and a 5 s WAV transfers in under 0.4 s.
• Remote over Bluetooth only: discovery takes 0.5–2.4 s, starts land within 12–25 ms (±4–6 ms clock uncertainty), and transfer is the bottleneck, at 55–80 KB/s.
• Failure recovery: a Windows MP4 recorder killed at 8.0 s kept 8.05 s of video and 7.96 s of audio, and the file played.

Final Takeaway

The protocol work was mostly static. Matching the decompiled code against a public sample, and checking the encoder against packets the app hard-codes, gave a verified spec before the first Bluetooth connection. The expensive bugs came later and were all about state that crosses a boundary:

• clocks between devices;
• buffers between Java and .NET;
• a global scratch stack between threads;
• an MSBuild property between a project file and CI;
• a ping queue behind file data.

Each one is now pinned by a clock-locked track, an explicit Close(), a compiler flag with a regression test, a single property name, and a best-sample offset estimate. Those are the class of failures this setup now prevents: silent drift, frozen capture, cross-thread corruption, missing release artifacts, and wrong alignment in multi-device takes.

The full article is in the works, lets on know in the comments field if we should hurry.

The quick cheat sheet for success is the following steps

• Install the domain server on bare metal, and set it up
• Install the Hyper-V role on the domain server
• Install a new 2012 server in Hyper-V, which will run your RDP Licensing server
• Install RDP licensing role to the virtual 2012 server
  Also install all RDP gateway services that you need:
  • Remote desktop Gateway
  • Remote desktop proxy
  • This is also a nice place to put VPN, etc.

For a little bit of security, you can strip the domain server of everything else, GUI, applications, etc.

The full article is in the works, lets on know in the comments field if we should hurry.

This requires a bit of coding, and the results might come up on this page

This has been documented many places, among others:

• https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/U_K1NHuMLic
• http://www.ubergizmo.com/how-to/how-to-google-chrome-hidpi-support-windows/

However with the most recent dev version of chrome (Version 37+) you need a different (or to be safe two) registry keys. Since 64bit and 32bit windows applications can place their registry information in two places.

[HKEY_CURRENT_USER\Software\Wow6432Node\Google\Chrome\Profile]

and as previously

[HKEY_CURRENT_USER\Software\Google\Chrome\Profile]

In both these locations you should create a DWORD entry named “high-dpi-support” with the value of 1.

For convenience you can download the registry files here which will set the registry for you:

• ChromeHIDPI.reg

1. It is not possible to switch virtual desktops on the client from within a remote desktop session
2. The second monitor taskbar is on-top of the remote desktop client application

The remote desktop client for windows, allows ONLY the Caps-Lock key to be captured by other programs while in full screen, this is when the “Send windows shortcuts to remote system” is enabled.
Using the autohotkey scripts below you are able to switch desktops using the Cube from Dexpot using Ctrl+CapsLock. The use case for the script is as follows:

1. Press and hold CTRL
2. Press and RELEASE Caps-Lock
3. Use the arrow left/right to navigate available desktops
4. Release CTRL when you wish to switch to selected desktop

The requirements for the setup described here, are the following applications:

• Dexpot Window Manager with Cube plugin
  • You must have mapped the Cube manual show to Alt + Win + Up Arrow
• Dual Monitor Taskbar
• Autohotkey

The script can also be found, downloaded and forked at github:

https://github.com/ecomerc/code/blob/master/RotateCube-from-RDP/rotatecube.ahk

The code for the autohotkey is also outlined below. The implementation is:

• Capture the pressing of CTRL+Caps-Lock
  Block the capture of this (we don’t want to enable Caps-Lock)
• If a remote desktop client is full screen, restore it to window mode, and enlarge the window to fill the screen
  We do this so the cube is still covered with the RDP client
• Send Ctrl+Win+Arrow Up to launch the Cube
• Capture the release of Ctrl nonblocking (allow other applications to see the event as well)
  If a Remote Desktop Window is present on the new virtual desktop make it full screen, and make the second monitor toolbar not topmost
  If no Remote Desktop Window is present, make the second monitor toolbar topmost

#SingleInstance force
; Usage: Press CTRL+CapsLock, hold CTRL and use arrow keys to navigate desktops

RotatingCube := 0
^Capslock::
    SetKeyDelay -1 
	if (RotatingCube = 0) { 
		;Get MSTSC window (this may have to be ahk_class TSSHELLWND for some systems)
		;TODO: make multiple detection
		
		If WinActive("ahk_class TscShellContainerClass") {
			WinGet, active_id, ID, A
			WinGet, maxOrMin, MinMax, ahk_id %active_id%
			
			if (maxOrMin = 0) {
				WinGetPos, PosX, PosY, WinWidth, WinHeight, ahk_id %active_id%
				if (PosY = 0) {
					;Wait for focus to restore properly
					Sleep 50
					
					;Force the MSTSC windows to restore (unmaximize)
					PostMessage, 0x112, 0xF120,,, ahk_id %active_id%   ; 0x112 = WM_SYSCOMMAND, 0xF120 = SC_RESTORE
					Sleep 50
					
					;Move it so it fills the screen, but not 0,0 because then we would think it was maximized
					WinMove, ahk_id %active_id%,, 1, 1, WinWidth - 2, WinHeight-2
					
				}
			}
			
		}
		; Launch the Cube
		send, {LCtrl Down}{LWin Down}{Up DownTemp}
		RotatingCube := 1
	}
    return
	
~LCtrl up::
	if (RotatingCube <> 0) {
		send, {LWin Up}
		Sleep 50
		DetectHiddenWindows, off
		WinWait, ahk_class TscShellContainerClass, , 1
		if ErrorLevel {
			;;Did not find MSTSC
			
			;;Set SecondaryTaskbar as Always OnTop
			Winset, AlwaysOnTop, off, SecondaryTaskbar
		} else {
			;;Set SecondaryTaskbar as Not Always OnTop (it has a bug)
			Winset, AlwaysOnTop, off, SecondaryTaskbar
			
			;;Maximizing MSTSC
			WinActivate ahk_class TscShellContainerClass
			send !^{vk03sc146}
			
		}
	}
	RotatingCube := 0
    return	

The code is based completely on the Autohotkey language file for highligh 3.12 made by Andre Simon. The code can be downloaded, copied and forked on github.

https://github.com/ecomerc/code/tree/master/Autohotkey-Syntax-Highlight

Read more:

• http://www.andre-simon.de/
• http://www.gnu.org/software/src-highlite/
• http://shjs.sourceforge.net/
• https://web.archive.org/web/20131218000800/http://steamdev.com/snippet/

1. Install the build toolchain:

   ipkg install buildroot

   or

   ipkg install optware-devel

   and

   ipkg install unzip

2. Download the MP3 Gain sources, pick the latest from http://sourceforge.net/projects/mp3gain/files/mp3gain/.

   wget http://sourceforge.com/...

3. CD to the directory and unzip the source code

4. Make the program

   make

   if you run into the error:

   cc -Wall -DHAVE_MEMCPY   -c -o mp3gain.o mp3gain.c
   cc: can't resolve symbol '__fsetlocking'
   make: *** [mp3gain.o] Error 1

   you need to point the LD_LIBRARY_PATH to your optware lib:

   export LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATH

5. I have not gotten make install working, but it should be enough to copy mp3gain into /opt/bin

DECLARE @xml xml
SELECT @xml=REPLACE(dbo.af_LoadRemoteFile('http://rss.cnn.com/rss/edition.rss'), 'utf-8' ,'utf-16')

using System;
using System.Data;
using System.Data.Sql;
using System.Data.SqlTypes;
using System.Data.SqlServer;
using Microsoft.SqlServer.Server;

public class StoredProcedures
{

    [SqlFunction(IsDeterministic = true, IsPrecise = true)]
    public static SqlString LoadRemoteFile(string remoteFile)
    {
		System.Net.WebClient remote = new System.Net.WebClient();
		byte[] myDataBuffer = remote.DownloadData (remoteFile);
		string download = System.Text.Encoding.ASCII.GetString(myDataBuffer);

        return download;
    }


};

Error handling and check for unauthorized remote files are completely up to the user.

This article is a reconstruction from a small batch launcher and a shortcut script. The original article file was empty. The date above is the surviving scripts’ SVN commit date, not a verified first publication date. The application names and paths below are generic.

The likely goal was to distribute an Access application from one shared location without making everyone open the same front-end file over the network.

Each user would launch a small updater. It would copy the current client into a directory under that user’s application-data folder, then open the local copy. Publishing an updated client to the share would make it available on the next launch, without a separate installation on each workstation.

Here, “remote start” appears to mean starting an application distributed from a remote file share. The scripts do not start a process on another computer.

One shared release, one local copy per user

The setup script supplies a few application-specific values to a reusable launcher. A sanitized version of that configuration looks like this:

@echo off
set "name=Shared Application"
set "root=\\fileserver\applications\shared-app"
set "client=%root%\Client"
set "destination=%APPDATA%\SharedApplication"
set "batfile=%client%\%~nx0%"
set "icon=icon.ico"

call "%~dp0run.bat"

This is only the configuration wrapper, not a complete replacement updater.

The distinction between client and destination is the important part. The share contains the distributable client; the user profile contains a disposable working copy. There is no need for users to write into the release directory, and one user’s local front end is separate from another’s.

What the surviving implementation does

The generic launcher follows this sequence:

1. Create the local destination directory.
2. List .adp client files on the share in modification-date order and retain the final filename, apparently intending to select the newest release.
3. Delete the files directly inside the local destination, then copy the selected client and icon files from the share.
4. Write a per-user trusted-location registry entry for the local client folder.
5. Write the shared root path into a local lnk.txt file.
6. Locate an installed Access executable using a short list of conventional installation paths.
7. Create or update a desktop shortcut that points back to the shared launcher.
8. Start Access with the local client file.

The .adp extension identifies a legacy Access project rather than an ordinary file-based database. Such a client would typically connect to a database server, but these scripts do not establish the actual backend configuration.

The lnk.txt file probably let the client discover the shared application root. The launcher only writes the file; no surviving application code here proves how it was consumed.

Why the shortcut points to the launcher

The shortcut helper accepts a display name, target path, and icon path. It uses the user’s desktop folder to create the shortcut, with the shared batch file as its target and the copied local icon as its icon.

That target is deliberate. If the shortcut opened the local client directly, later launches would bypass the update step. Returning to the shared launcher keeps release selection in one place.

The trade-off is dependence on the share: a local client may exist, but this shortcut still requires the shared launcher to be reachable.

Where the original approach is fragile

The mechanism is small, but the original implementation is not a robust updater:

• It deletes the old local files before checking that the new copy succeeded. A lost connection can leave the user with no usable client.
• Its filename-selection loop does not preserve names containing spaces. There is also no explicit handling for an empty release directory.
• It has no release manifest, signature verification, rollback, or check for an already-running client.
• Executable discovery assumes particular installation directories, including a final fallback that is not checked for existence.
• The trusted-location entry targets one Access version even though executable discovery considers several versions.

The local destination must therefore be dedicated to replaceable application files, never user documents or the authoritative database. A replacement should stage and validate an update before replacing the working copy, handle failures explicitly, and keep the previous client available for recovery.

Trusting the local folder also makes the release share a security boundary. Only authorized publishers should be able to change the files that users will copy and execute. Broadening trusted locations is not a substitute for that control.

Takeaway

The best reading of these scripts is a lightweight deployment scheme for a shared Access application: publish centrally, copy locally, and always enter through the updater. The useful idea is separating distribution from execution. The destructive replacement step and unchecked assumptions are historical limitations, not recommendations to reproduce unchanged.

Object Reference

The Microsoft Office Ribbon is referenced as an IRibbonUI object. The reference is retrieved by implementing:

Public gobjRibbon As IRibbonUI

Sub CallbackOnLoad(ribbon As IRibbonUI)
    Set gobjRibbon = ribbon
End Sub

Unfortunatly the global variable gobjRibbon is only initialized once, and is lost after errors or during a reset from the VBA-IDE.

A user “WernerGg” has published a brilliant solution for Excel, based on the work of user rorya (Rory) from the MrExcel board: http://www.mrexcel.com/forum/showthread.php?t=518629 and https://web.archive.org/web/20120707125013/http://www.thecodecage.com/forumz/top-tips/208306-excel-store-regain-iribbonui-object-reference.html.

How to preserve or regain the Id of my custom ribbon UI?

The problem is that the UI is initialized only once during load. To change enabled-state or visibility, controls must be forced to reinitialize. For that we have to store the UIs Id during load by means of the onLoad-callback.

But this Id can only be stored in a static variable (Private guiRibbon As IRibbonUI), which gets lost after errors or during reset from the VBA-IDE.

We have implemented code to store the guiRibbon at a save place (a defined name “thisWorkbook_IRibbonUI_Ptr” on cell H2 in this example) from where it can be retrieved when the static variable is lost. See module ObjectStore. Basically it does:

Sub StoreObjRef(obj As Object)           
' Store an object reference              
    Dim longObj As Long                  
    longObj = ObjPtr(obj)                
    Range("...") = longObj               
End Sub          
                        
Function RetrieveObjRef() As Object
' Retrieve the object reference
   Dim longObj As Long, obj as Object
   longObj = Range("...")
   CopyMemory obj, longObj, 4
 Set RetrieveObjRef = obj
End Function
										 
' where CopyMem is a Windows kernel function:
Private Declare Sub CopyMemory Lib "kernel32" _
    Alias "RtlMoveMemory" (destination As Any, source As Any, ByVal length As Long)

For the entire sample and description please see the file TestRibbonUI_3.xlsm by WernerG

Persistant Storage

The method of storing values in named ranges or worksheet cells only works with Excel, for the additional Office Applications we must find another storage location.

On the website http://www.cpearson.com/excel/trulyglobalvariables.htm, Chip Pearson describes how to create truly global variables in Excel. If we combine this with the sample from WernerG, we can place the Ribbon pointer in a truly global persistant variable.

First we implement object storage in the truly global variable module.

Public Const C_OBJ_STORAGENAME As String = "AC_RIBBON_PTR"

Private Declare Sub CopyMemory Lib "kernel32" _
    Alias "RtlMoveMemory" (destination As Any, source As Any, ByVal length As Long)

Public Function StoreObjRef(obj As Object) As Boolean
	' Serialize and savely store an object reference
    StoreObjRef = False
    
    ' Serialize
    Dim longObj As Long
    longObj = ObjPtr(obj)
    
    ' Store into a defined name
    If Not PropertyExists(C_OBJ_STORAGENAME) Then
        SetProperty C_OBJ_STORAGENAME, longObj
        Debug.Print "Save storage """; C_OBJ_STORAGENAME; """ stored the object reference"; longObj
		StoreObjRef = True
    Else
        Debug.Print "Property exists"
    End If
    
    ' Return
End Function

Public Function RetrieveObjRef() As Object
' Retrieve from save storage, deserialize and return the object reference
' stored with StoreObjRef

    Set RetrieveObjRef = Nothing
    
    ' Retrieve from a defined name
    Dim longObj As Long
    If PropertyExists(C_OBJ_STORAGENAME) Then
        If GetProperty(C_OBJ_STORAGENAME, longObj) Then
            Debug.Print "Object reference"; longObj; "retrieved from save storage """; C_OBJ_STORAGENAME; """"
            
            ' Deserialize
            Dim obj As Object
            CopyMemory obj, longObj, 4
            
            ' Return
            Set RetrieveObjRef = obj
            Set obj = Nothing
        Else
            Debug.Print "object not retrieved"
        End If
    Else
        Debug.Print "object does not exist"
    End If
End Function

Then we add the call to store the reference:

Public gobjRibbon As IRibbonUI

Sub CallbackOnLoad(ribbon As IRibbonUI)
    Set gobjRibbon = ribbon
    Storage.StoreObjRef ribbon
End Sub

Additionally we add a function to retrieve the object again, for performance issues we check to see if we still have the “local” copy first.

Function getRibbonObj() as object
    If gobjRibbon Is Nothing Then
        Set gobjRibbon = Storage.RetrieveObjRef
    End If
	set getRibbonObj = gobjRibbon
End Function

However for use in other Office Applications the code will need a little modification. In his original file Chip has defaulted the DestHWnd to:

    If HWnd <= 0 Then
        DestHWnd = FindWindow("XLMAIN", Application.Caption)
    Else
        DestHWnd = HWnd
    End If

However this is not terribly dynamic and we have changed it to:

    If HWnd <= 0 Then
        DestHWnd = GetDefaultHandle()
    Else
        DestHWnd = HWnd
    End If

Additionally the GetDefaultHandle() was introduced. Obviously this should be expanded to include the main windows of the remaining Office Applications

Private Function GetDefaultHandle() As Long

    If Application.name = "Microsoft Access" Then
        GetDefaultHandle = Application.hWndAccessApp
    ElseIf Application.name = "Microsoft Excel" Then
        GetDefaultHandle = FindWindow("XLMAIN", Application.Caption)
    Else
        MsgBox "Undefined Application"
    End If

End Function

The code consists of two files:

• Storage.bas
• CPropType.cls

Sub SheetNames()
    Dim wb As Workbook
    Dim ws As Worksheet

    For Each wb In Application.Workbooks
        
        Debug.Print "-------------"
    
        Debug.Print wb.Name
    
        For Each ws In wb.Worksheets
            Debug.Print " ;" & ws.Name
        Next
    Next
End Sub

The “;” was added for quick text import where the workbook name was not in the same column as the worksheet name.

Just for good measure we will just show how to create the symlinks to network drives. And remember SkyDrive must not be running when creating the symlinks otherwise SkyDrive will upload them as a file, and then crash. Which can only be fixed with a reinstall.

This has also been an issue with the DropBox client, and here is a Good article on how this issue is handled with the DropBox client. However with networked folders, you are not able to symlink from the remote location into the SkyDrive folder. In order to link a remote location to your SkyDrive, do the following:

taskkill.exe /IM skydrive.exe
mklink /D "Link name" "\\remote.server\Share\Folder"

Once the link has been made, you can restart the SkyDrive application.

Forced Syncronization

The forced syncronization is a simple procedure, that will restart the SkyDrive application. It will kill with taskkill, and start it again with the \background paramter. It is possible to force the sync simply by running SkyDrive.exe \background, however this will also bring up an explorer view of the SkyDrive folder.

@echo off

set tasklist=%windir%\System32\tasklist.exe
set taskkill=%windir%\System32\taskkill.exe
set skydrive=%AppData%\..\Local\Microsoft\SkyDrive\SkyDrive.exe
set wasStopped=0
set skydriveexe=skydrive.exe

set procFound=0
set notFound_result=ERROR:
      set procName=%skydriveexe%
for /f "usebackq" %%A in (`%taskkill% /IM %procName%`) do (
    if NOT %%A==%notFound_result% (set procFound=1)
)
if %procFound%==0 (
  echo The process was not running.
  goto :STARTSKYDRIVE
)
set wasStopped=1
set ignore_result=INFO:
:CHECKDEAD
"%windir%\system32\timeout.exe" 3 /NOBREAK
for /f "usebackq" %%A in (`%tasklist% /nh /fi "imagename eq %procName%"`) do (
    if not %%A==%ignore_result% (goto :CHECKDEAD)
)

:STARTSKYDRIVE
start "skydrive" "%skydrive%" /background

This code is based on sample code from http://stackoverflow.com/questions/7861683/from-a-batch-file-how-can-i-wait-for-a-process-to-exit-after-calling-taskkill.

Unfortunately when running this from the task scheduler, it will bring up a command promt, so in order to hide the command line, we use the following vbs code, and call that from the task scheduler instead:

 Set WshShell = WScript.CreateObject("WScript.Shell")
 currentDirectory = Replace(WScript.ScriptFullName,WScript.ScriptName,"")
 cmd = "cmd.exe /c """& currentDirectory &"SkyDriveForceSync.bat"""
 Return = WshShell.Run(cmd, 0, True)
 set WshShell = Nothing

This code is based on the sample from https://web.archive.org/web/20141025231231/http://www.pcreview.co.uk:80/forums/hide-console-window-run-task-scheduler-t1468863.html

Task Scheduling

In order to have SkyDrive force a sync regularly, setup task scheduler to start the vbs script once a day, and have it repeat every hour after that for one day.

Private Sub subfrm_Enter()
    Me.subfrm.Form.DataEntry = True
End Sub

Private Sub subfrm_Exit(Cancel As Integer)
    Me.subfrm.Form.DataEntry = False
End Sub

• Should run on a synology ds209
• Should transfer as many tags as possible
• Create a “playlist” folder with symbolic links to the mp3 files

Prerequisits

• Working SSH connection to the synology
• optware
• faad - ipkg install faad
• faad - ipkg install mp3info

#!/bin/sh


#the iTunes dir is located out of the music shared folder
# because we don't want duplicates in synology.

inputdir="/volume2/media/iTunes/iTunes Media/Music"
iTunesdir="/volume2/media/iTunes/"

outputdir="/volume2/music/iLibrary"
linkdir="/volume2/media/playlists/iPod"

#When done testing set it to /dev/null
logfile="/volume1/@scripts/log/iTunes.log"


#Remove all "playlist" links
rm $linkdir/* 


    
export IFS=$'\n'

playlist=$(cat $iTunesdir/iTunes\ Library.xml | grep -o iTunes%20Media.*\.m4a)

playlist=$(printf $(echo -n $playlist | sed 's/\\/\\\\/g;s/\(%\)\([0-9a-fA-F][0-9a-fA-F]\)/\\x\2/g'))


for i in $(find $inputdir -name "*.m4a" -type f)
do
    inputpath=${i#$inputdir}
    filename=$(basename $i)
    
    
    info=$(faad -i "$i" 2>&1)
    
    
    trackcount=$(echo "$info" | grep -c 'track:')
    
    if [ $trackcount -eq 1 ] ; then
        
        info=$(echo "$info" | sed -e /^iTunNORM:.*$/d)
        info=$(echo "$info" | sed -e /^iTunSMPB:.*$/d)
        
        startline=$(echo "$info" | grep -m 1 -n 'title:\|unknown:'  | cut -f1 -d:)
        trackline=$(echo "$info" | grep -m 1 -n 'track:'  | cut -f1 -d:)
        
        linecount=$(( $trackline - $startline ))
                
        dateline=$( echo "$info" | grep -m 1 -n 'unknown: [0-9][0-9][0-9][0-9]'  | cut -f1 -d:)
        info=$(echo "$info" | sed -e "${dateline}s/unknown: /date: /")
        
        remixline=$(echo "$info" | sed -e "1,${trackline}d" | grep -m 1 -n 'unknown:' | cut -f1 -d:)
        if [ "$remixline" -ne "" ] ; then
            remixline=$(( $trackline + $remixline ))
            info=$(echo "$info" | sed -e "${remixline}s/unknown: /remix: /")
        fi
        
        line=$(( $startline ))
        info=$(echo "$info" | sed -e "${line}s/unknown: /title: /")
        
        
        line=$(( $line + 1 ))
        info=$(echo "$info" | sed -e "${line}s/unknown: /artist: /")
        
        
        
        if [ $linecount -eq 3 ] ; then
            line=$(( $line + 1 ))
            info=$(echo "$info" | sed -e "${line}s/unknown: /album: /")
        fi
        
        if [ $linecount -gt 4 ] ; then
            line=$(( $line + 1 ))
            info=$(echo "$info" | sed -e "${line}s/unknown: /albumartist: /")
        fi
        if [ $linecount -gt 5 ] ; then
            line=$(( $line + 1 ))
            info=$(echo "$info" | sed -e "${line}s/unknown: /composer: /")
        fi
        
        if [ $linecount -gt 3 ] ; then
            line=$(( $line + 1 ))
            info=$(echo "$info" | sed -e "${line}s/unknown: /album: /")
            line=$(( $line + 1 ))
            info=$(echo "$info" | sed -e "${line}s/unknown: /genre: /")
        fi
        
               
        
        song=$(echo "$info" | grep ^title: | sed s/title:\ //g)
        artist=`echo "$info" | grep ^artist: | sed s/artist:\ //g`
        composer=$(echo "$info" | grep ^composer: | sed s/composer:\ //g)
        albumartist=`echo "$info" | grep ^albumartist: | sed s/albumartist:\ //g`
        album=`echo "$info" | grep ^album: | sed s/album:\ //g`
        genre=$(echo "$info" | grep ^genre: | sed s/genre:\ //g)
        track=`echo "$info" | grep ^track: | sed s/track:\ //g`
        year=`echo "$info" | grep ^date: | sed s/date:\ //g`
        remix=`echo "$info" | grep ^remix: | sed s/remix:\ //g`
        
        
        #Sometimes iTunes adds the remix information to the song title
        # and sometimes not, so lets check and add if it is not there
        if [ "$remix" != "" ]
        then
            if [ "${song%$remix}" == "$song" ]
            then
                song="$song $remix" 
            fi
        fi
        
        # The iTunes genres are not the same as MP3 genres, and they are 
        # not consistent either
        # There is not such MP3 genre as Hip-Hop/Rap or Hip Hop/Rap
        # but there is both Hip-Hop, and Rap - so choose your favorite
        # notice that if we do not check and then use $genre as a folder, 
        # we would have unexpected subdirs
        genreorg=$genre
        case "$genre" in
            "Hip-Hop/Rap")
                genre="Hip-Hop"
                ;;
            "Hip Hop/Rap")
                genre="Hip-Hop"
                ;;
            "R&B/Soul")
                genre="R&B"
                ;;
            "Singer/Songwriter")
                genre="Pop"
                ;;
            "Indie Rock")
                genre="Indie"
                ;;
            "Pop/Rock")
                genre="Rock"
                ;;
             
            #*)  
        esac


        
        # Make sure the genre does not contain illegal characters (especially / or \
        gpath=${genre//[^a-zA-Z0-9-&]/ }
        
        #Order the output after genre (or what every you want here)
        # feel free to go nuts with the tags identified above
        # below I use iTunes folder arrangement, but add genre
        # so it is actually: genre/artist/album/tracknumber - song.mp3
        
        outputfile=$outputdir/$gpath${inputpath%.m4a}.mp3
        
        #I want the link name only to be the artist and the song 
        # (when transfered to a usb stick and used in lesser than capable 
        #  mp3 players you still have the most important information)
        
        linkname="$artist - $song"
        
        #Strip illegal characters from the filename (needed if files are to be used
        # in Windows, and makes sure random new dirs is not created
        
        linkname=$(echo $linkname | sed 's/[]['"'"':;*?<>|"[:cntrl:]\\\/]//g')
        linkfile=$linkdir/$linkname.mp3
           
        
        if [ ! -e "$outputfile" ]
        then
            echo Converting: $filename 
        
        
            mkdir -p ${outputfile%/*}
            #--ignore-tag-errors --tv "TXXX=ALBUM ARTIST=String1"
            # --tv "TCOM=$composer"
            faad -o - "$i"| lame -h -b 128 - "$outputfile" --tt "$song" --ty "$year" --tn "$track" --ta "$artist" --tg "$genre" --tl "$album" --ignore-tag-errors --tv "TPE2=$albumartist" --tv "TCOM=$composer"
        fi
        
        #Used as an additional check, to set mp3 tags for previously converted m4a files or to add tags that lame does not add correctly (is not needed anymore since lame supports --tv
        
        #if [ -e "$outputfile" ]
        #then
        #    echo Editing: $outputfile 
        #    mp3info -t "$song" -a "$artist" -l "$album" -n "$track" -g "$genre" $outputfile 
        #fi
        
        
        res=`echo $playlist | grep -i -F "$filename"`; 
        if [[ ${#res} > 0 ]]; then
            #This file is part of the playlist, so add it to the playlist directory
            ln -s "$outputfile" "$linkfile"
        fi 
        
    fi
done

chmod -R 777 "$outputdir"

The original work was based on several m4a2mp3 scripts on the interwebs. However the code was completely rewritten from scratch since iTunes (or faad) are not that good at giving proper tag names. The scripts that provided helpful inspiration were:

• https://web.archive.org/web/20120321071346/http://www.minigeek.org/2007/07/linux-m4a-to-mp3-conversion-script
• https://web.archive.org/web/20120508133653/http://gnuru.org:80/article/1582/convert-m4a-mp3-script