Yesterday, I began working on my second collaboration for the exhale xHE-AAC USAC encoder. This time, I worked on adding an argument to print the software version on the console.
The above is the main software, printing its information as well as how to use it.
There was no option to print the version only. Ideally, I just wanted a way to print something like exhale version 1.0.3 .....so that I can easily parse it as I do with other tools like Opusenc and Flac. Because of this, I began working on adding this functionality.
The code that performs this will check if there is just one argument (actually 2, since the first one is the executable filename). It also checks if the argument is either -v or -V. If this is true, we print the software information to the user:
This is the result:
A very simple and minimalistic output. Thanks to this, I can parse it and use on tools like my upcoming exchale GUI:
This Merge Request was approved and merged and is ready to use for everyone. As for the GUI, expect it in the next couple of days!
Let’s set the distro to eoan, the current stable Ubuntu version: DISTRO="eoan"
Now, we need to add the repository to our Linux installation: echo "deb https://deb.nodesource.com/$VERSION $DISTRO main" | sudo tee /etc/apt/sources.list.d/nodesource.list echo "deb-src https://deb.nodesource.com/$VERSION $DISTRO main" | sudo tee -a /etc/apt/sources.list.d/nodesource.list
The commands should like this in the terminal:
We can now run sudo apt update to update the repository information:
We will now attempt to install the nodejs package by running sudo apt install nodejs:
As you can see above, following the manual installation steps fails as well because there is no python-minimal package in Ubuntu 20.04. To solve this, we will manually download the Node.js Debian package and modify it to have it refer to python2-minimal instead of python-minimal.
Manually downloading, modifying and installing Node.js 10.x
From there, just copy the desired Node.js package link to the clipboard. Then, use wget to download it on the terminal. I recommend downloading it to a clean directory since we will run some commands to extract and perform some modifications to it:
Once the download finishes, we need to extract the downloaded debian package with the ar utility: ar x nodejs_10.19.0-1nodesource1_amd64.deb
We need to extract the control.tar.gz file: tar -xzf control.tar.gz
Using nano or your favorite text editor, we will edit the control file. Look for python-minimal: nano control
Change python-minimal to python2-minimal:
Save the file. On nano, press CTRL + O, then exit pressing CTRL + X.
We now need to recreate the control.tar.gz tar package to include the modified control file. To do this, we will run the following command: tar -czf control.tar.gz control md5sums postinst pr einst prerm
Finally, we will replace the control.tar.gz in the debian package file. We will run the following command to do so: ar -r nodejs_10.19.0-1nodesource1_amd64.deb control.tar.gz
We can now install the package with dpkg. We’ll run the following: sudo dpkg -i nodejs_10.19.0-1nodesource1_amd64.deb
After following the above steps, we should have Node.js installed on our operating system. We can confirm this by running node -v and npm -v:
And that’s it! We have successfully installed Node.js on our Ubuntu Focal installation.
This new version adds support for ffmpeg’s native Opus encoder. I also included the latest x64 release of opusenc.
As to what ffmpeg encoder to use, I recommend sticking to ffmpeg libopus, as my own tests revealed some artifact issues using ffmpeg opus. A difference between these 2 is that libopus encodes using variable bitrate while ffmpeg opus encodes only with a constant bitrate. Since libopus use variable bitrate, it can allocate more bits to those complex audio sections, hence having a better quality.
You can download this new version at the project’s GitHub release page by clicking here.
I’ve been working on a brand-new software called TIFF Recompressor:
This is a tool that allows you to recompress TIFF files by using different compression methods. It also allows you to store them uncompressed so that you can use another software to further compress the files.
The following compression methods can be used in the software:
This new release allows you to click on the opusenc and ffmpeg version labels to copy the text to your clipboard. This allows you to create folders by pasting the version string from the clipboard to better organize your content if you want to maintain the encodes organized by encoder version. This could be also useful if you want to store the files in folders named with the encoder version to compare them against other versions.
The other change this version provides is that if ffmpeg does not exist in your system and you want to encode MP3 or M4A audio files, these will simply be skipped as opusenc cannot encode those file formats.
paq8pxv v6 provided only one executable, and it was not labeled either with their usual “jit.exe” ending nor with “vm.exe”. Because of this, I had to write a new function that will check in the version folder whenever we have a version ending with “jit.exe” and/or “vm.exe”. If we have them, the software adds the respective entry to the “compiler” list box, and selects the option that the user has previously selected if it is available for the selected PAQ version.
If none of the versions exist, we simply disable the listbox and just use the paq filename as it is, without any of the above terminations:
We call this function whenever the version has changed (seen in the end of the above screenshot) or when the PAQ family/series has changed:
That’s what’s new in the code of this new release.
I got my HiBy R3 music player some time ago and I’ve been enjoying it a lot, and I recently started playing the DLNA portion of it.
Using DLNA with Android is a piece of cake thanks to an app called BubbleUPnP, for which I purchased the app license as it allows me to stream my media files without limitations compared with the free version. However, it is when it comes to the PC where I had difficulties finding compatible DLNA-compatible software. All of which I tried were either buggy or were not able to playback the files to my HiBy R3. That’s when I started researching about the DLNA/UPnP protocol and found some examples. I then started developing software to fit my needs immediately.
DLNA is a protocol used to send media files to wireless players. It usually consists of a Server, Renderer, and a Controller:
Server: This is where the media files are stored. They are sent to the player by the controller or the player itself if it is able to browse the server
Renderer: This is the device that plays back the media file. The renderer can also be able to browse and play the media acting as a controller, but if the renderer is just a renderer, a controller is needed.
Controller: This is like a remote control. You choose the media file and the renderer device with this.
I found one great resource at CodeProject, which you can see here. It talked about how to communicate with DLNA devices and send media files to it, given you have a DLNA Server. It worked using my own HTTP server, but then I wanted to develop software that allows me to playback my media locally. That’s where the fun part began.
I then started researching how to implement HTTP servers in C#. I found some examples which I tried and they seemed to work, but were not able to handle partial requests, which seems are needed for media playback as my player was sending partial requests in the HTTP header. That’s when I also found this other great resource at CodeProject which implemented a simple DLNA server.
Since both codes are open source and their license allows its use in projects including modifying them to fit the needs of others, I used both of these as a base for my project.
I adapted the above codes to work with a player I designed. It allows you to select a rendered device to playback your music files, build a queue, and control your device with its Play, Pause, Stop, Previous and Next buttons. It also allows you to seek the track by using the slider and shows the track progress in real-time! Clearly, this is my first app that deals with socket connections in particular, since this is all the software does. It’s all about sockets!
You simply need to specify your machine’s IP Address, choose a port and press the Apply button, then Scan for Media Renderers, select one, and then drag and drop your music files. Then press the Play button and enjoy your music!
When you playback a file, it is copied to your machine’s RAM which is then used to send the media file to the renderer as it requests it when it sends the HTTP request. This means the software has its own internal web server, so you don’t need a separate DLNA Server as this software does that, serving the files in the queue as it’s being played.
Tested with my Hiby R3 player, I can now enjoy true wireless music playback without the quality loss that happens during the Bluetooth transmission. This is all done via Wifi and the player does all the rendering using the original file. I’ve tested it with FLAC 16-bit/44.1Hz as well as MP3 files, which are working correctly.
I hope this tool is useful for others and this has been an incredible learning journey.