Category Archives: AmigaOS

I was Wrong

I was wrong.blog_dev

Some people have a tough time admitting they were wrong. In this case at least, I am really quite happy about it.

I was the lucky guy who got to finish the HD Audio sound driver for the AmigaOne X1000. That was a long enough story in itself and is covered as an earlier blog entry.

But due to technical difficulties, I was unable to add support for monitoring inputs “Live” and unable to add support for it in the “Mixer” program. I have had to explain this dozens of times, and it was even added to the AmigaOS Wiki X1000 FAQ. Now, just one more time, I’ll detail exactly what went wrong with these features.

9548513-no-soundThe first big problem

The audio chip in the AmigaOne X1000 follows the Intel HD Audio standard, which is emerging as the replacement for the older AC’97 standard. Most (almost all) of the existing sound drivers are AC97 based. The new standard has lots of great features but there is one particular “sticking point”. The control registers for the older cards just showed up in PCI address space. Any program that knows where to look and what values to poke* can take control of the sound card. There is a register to hold the volume, another to choose which input to use, most of the features and options are simply controlled by poking different numbers into this memory space.

These new HD Audio chips have special communications ring buffers for sending commands and data between the computer and the sound Coder/Decoder chip (Codec). It’s all detailed in the Intel HD Audio specification, exactly how instructions can ride alongside the data, how fast things move back and forth, where the response to each command will come back out of the data stream… all a rather complex but capable system for driving up to four audio codecs at once.

But there’s the problem.

We get the driver going, and AHI knows how to control volume through the “correct” means… but when users ask for “Mixer” support there is simply no PCI address space to poke numbers into. There is no way provided to get the volume instructions merged into the command stream that is already running. Mixer doesn’t work through AHI and it simply bypasses it. To explain it simply: It is designed for all the sounds and commands to come from one place, there’s no provisions for other programs to just poke numbers into the sound chip. Some programs use the volume controls provided by AHI and some ignore them and expect “Mixer” to save the day.

The second big problem

“Live” playback of audio, useful for listening to MP3 players, Audio CD’s or other sound sources. The codec is broken into small sections called “Widgets” (no kidding). There’s a Widget for each jack, a widget for each ADC or DAC, and selector widgets to choose which input to record from. There’s a map showing all the Widgets and all the connections between them in the documentation.

This does make things pretty simple to work on. Just look at the Widgets involved in the signal path and each one comes with a list of options you can control. An example, you are listening to a 7.1 channel audio recording of your favorite group. The path and the widgets involved go something like this:

AHI continues to stream 8 channels of audio data through the Ring Buffers I mentioned earlier, which then are passed to the Audio bus. There are four DAC (Digital to Analog Converter) widgets that can each take part of the data stream and convert it to 2 channels of sound. So DAC0, DAC1, DAC2 and DAC3 have controls to describe the format, sample rate and bit width of the sound data. Each one is also told which channels they are listening to. The driver is responsible for configuring all these different settings.

On the output side are four more Widgets, each describing a jack on the computer. The four widgets for the four jacks that carry 7.1 sound and there’s another one for the headphone jack. Each of these needs to be set to which DAC widget they are connected to. Most of these jacks can also be switched to an input if needed and some can even swap the left and right channels they are carrying.

Once all these widgets are set up, then the stream of music from AHI has a path to your speakers, and the music plays.

Now getting back to that problem monitoring an input live.

I checked the signal chart and I saw no connections available from any selected input back to an output. Every path was either for playing or for recording with no “feedback” available. I kept looking. I checked every option available for every input Widget and for every output widget. There was nothing marked “feedback” or “monitor.”

I was left with the conclusion that these chips don’t do live monitoring. They must need a program to record the incoming sound and send it right back out again (digital loop back).

Now that I have given such detail about all the things I couldn’t do, let’s find out just how wrong I was.

Man-Megaphone-3

At AmiWest 2013 (highly recommended, it’s a blast) I got to meet many Amiga Developers, Betas and users. One of the many friends I made was Alex Carmona. Alex is one of the other developers who has worked on this HD Audio driver and he had been looking over the documents. As luck would have it, he found two details that I had missed completely:

In response to problem 1, there is a special “back door” register where one command at a time can be added to the stream without messing about with those command ring buffers. Just one, and it will only work rather slowly, but there is the opportunity for Mixer to get some commands into the codec.

And about the second problem, he showed me a second signal chart that looked very much like the first, but it showed one possible path from a selected input back to mix live with the output! How can this be? Even if I missed seeing that from the other drawing, there are absolutely no options on either end of the signal path for turning this feature on and off. The DAC widgets don’t have it, the ADC widgets, the input selector, the input gains and volume controls. No mention ever of “monitor” or “feedback” controls anywhere in the signal path.

Somewhere buried deep in the “AFG” widget, which is mostly for chip-wide controls, there was a single bit buried there named “karaoke“. Yup, turning that on enabled the selected input to mix live with the audio out!

So finally, after reading all this, I get to the point of my story.

I told many people that the AmigaOne X1000 sound chip can not monitor inputs “live”. And I told many more people that Mixer would never work on the X1000 because there was no way to “poke” numbers in from outside of AHI. In both cases, I was wrong. A more experienced developer took the time to explain what I was missing and to help me figure out how to get there.

So, my hat is off to Alex and he deserves full credit for showing me the error of my ways.e2010010875386

hdaudio.audio 6.22 (now available to registered users via AmiUpdate) has the ability be controlled from Mixer. Javier was kind enough to add the Mixer code, so we can hope for a matching release of Mixer to support control of AmigaOne X1000 audio.

There was one more little snag. Every time any program opens AHI, all settings are forced back to whatever the boot up preset is. When I am playing an MP3 player “live” it gets really irritating. So all the Live monitoring controls have been taken out of the Mixer. Mixer has control of AHI playback and AHI recording but a separate program will be released soon that allows control of the monitor loop without AHI getting in a chance to muck things around. This monitor loop allows live playback from Front Microphone, Rear Microphone, Line In or the CD header. It might be handy for listening to analog audio from an older CD player or using “line in” you could mix in audio from a MP3 player. Or possibly to share your Amiga speakers with a second computer. Or you could even use it for Karaoke. :)

The users get what they asked for and they can each tell me how wrong I was the next time we cross paths. In this particular case, I am quite happy to be set straight on these matters.

And if you happen to see Alex in your travels, please thank him for being patient with the “new guy”.
We all get the benefits from it.

* “poke” as used in this article, is a reference to a BASIC command to store a value at a given address.
It usually shows up when someone is trying to reach further than the OS wants them to and it’s a
great way to screw things up if you’re not really careful. Would you want someone “poking” around
randomly into your brain?

Breaking the Memory Barrier

Overview

AmigaOS is a 32 bit OS. There is little we can change about it. The size of an address pointer is intrinsically entangled into the API, and getting rid of this legacy is, for the most part, a matter of replacing all of the API with a new one. Every time a programmer writes something like “sizeof(struct Message)”, the 32 bit nature is fused into his code.

This has some repercussions that cannot be easily ignored. It means that our address space is inherently limited to 32 bits (meaning 4 gigabytes). In reality this space is even smaller than that. PCI space, the kernel, memory buffers, and other memory areas take up a large chunk of the already limited address space, leaving roughly 2 gigabytes for the applications running on the machine – 2 gigs which also are shared between all of the programs running.

Physical Vs. Virtual

A physical address of a memory block is implicitly defined by its position within the memory chips, and the order in which the modules are inserted into the mainboard’s memory slots. They start at zero and go up to a specific maximum.

A virtual address, on the other hand, is what the CPU and hence the application program sees. They might be the same, but as a general rule, they are different. Virtual addresses are given on the fly, but there is a rule that every memory cell must have a unique virtual address, because all references to that cell are stored as the virtual address the application sees.

Modern systems like the X1000 or upcoming models can take more than 4 gigabytes of memory, but so far, the extra memory will never be used. Even in a 4 gigabyte system, there is memory that will never be touched because there is just no free address; and unfortunately, every byte needs to have its own virtual address, and no two bytes can have the same.

Unless…

Extended Memory Object

Extended memory objects (ExtMem) are a means to access memory beyond the 2 gigabyte barrier by applications that are written to make use of them. In a nutshell, an extended memory object is a chunk of physical memory that exists in a “nirvana” state somewhere in the memory of the computer without a virtual address of its own. The memory cannot be accessed by anyone or anything in this state. In order to access it, an application must map part of the object into its own virtual address space. This mapping does make a part of the memory represented by the ExtMem object accessible in a memory window in the application’s own address space.

There is no limit to the number of mappings an application can do. If needed, it can have several mappings active at a time, and add or delete mappings as required. The only restriction is that mappings must not overlap (either in virtual address space or in the memory object itself). Each mappings opens up a view into a part of the memory object, and, depending on how the mapping was performed, the application can read and/or write to the memory as if it were normal memory.

fig2A mapping is defined by the virtual address in application memory (which can be chosen by the application, or picked at random by the OS), the length of the map’s window, and the offset it maps to in the ExtMem object.

There are some caveats though. Most notably, the ExtMem object itself doesn’t have an address. In that sense it should be treated more like a file than a memory block. If an application wants to have permanent references to memory in the ExtMem object, it needs to store them by offset, just like it would with a file. The first offset is zero, so to address the 1000th byte in the memory block, the application needs to reference it by the offset of 1000. Obviously, this offset must be calculated against the base of the mapping’s offset; just like in a file, reading a part of the file into a buffer makes the first byte read the offset zero in the buffer.

As an example, consider the following situation. We want to access byte 3000 of the ExtMem object. We created a mapping that has length 4000 and starts at offset 2000. The resulting address for our byte would be the base address of the mapping plus 1000, since the offset of the beginning is already at 2000.

Downsides of the ExtMem system

If you think now that this all sounds suspiciously like bank switching, then you are right. The method has been used way back in the Home computer age, and even earlier. The Sinclair ZX Spectrum 128K was equipped with twice as much memory as the Z80 CPU could address; the upper 16k of the machine could be swapped between different chunks of the rest of the memory. Similarly, the Commodore 64 used bank switching to address a larger memory than its 6502 CPU could handle. It was the only possibility at the time to add more memory.

This method we employ now is basically the same (with a bit more added comfort).

Obviously, the method is a compromise. A “real” 64 bit system would be better, and much more transparent to use. However, as I already outlined in the beginning, there is a lot of work involved to make AmigaOS 64 bit compatible, and with the method of ExtMem objects, breaking the barrier is possible now as opposed to years down the road.

Who can benefit from ExtMem objects?

Well, every application that, in some way or the other, has to cope with large amounts of data. Even if the dataset is only potentially large (like, for example, a text editor), using an ExtMem object has its advantages. The text editor (or word processor), by its nature, only presents a small subset of the text it is editing to the user. Likewise, a movie editor would only need to have access to a few frames in order to show thumbnails of the movie on a timeline, or display a single frame that the user is working with.

Another example is RAM disk. Plans are currently underway to update the RAM disk to make use of the ExtMem object interface, allowing out-of-the-box usage of those normally unassigned memory blocks without draining the valuable main memory. Since (depending on programmer setting) memory blocks can even be allocated “on-demand” instead of ahead of time, this will make RAM disk have an even lower footprint, on top of making it possible to store larger amounts of data than ever before in it.

It needs to be said that the ExtMem system doesn’t require memory beyond the 4 gigabyte bounds. It can work with normal memory as well, even though that is not its purpose.

So, as you can see, a good number of applications have a natural tendency to only access a very small subset of their memory at a given time. All of these are good candidate for using ExtMem objects to break the memory barrier.

FUSE and NTFS for AmigaOS

280px-FUSE_structure.svgFUSE is short for Filesystem in Userspace. FUSE was created to enable non-privileged users to run file systems outside of the kernel which is a big deal for Unix-like operating systems. In AmigaOS, everything runs in userspace so FUSE is not nearly as important for Amiga users. What makes FUSE valuable is all the file system implementations which use FUSE such as NTFS, ext2, ZFS, etc.

The Amiga Operating System implementation of FUSE has been realized via a project called Filesysbox by Leif Salomonsson. A special thanks goes out to Leif for allowing his hard work to be utilized.

Amiga programmer extraordinaire Fredrik Wikström was then commissioned to port Filesysbox over to AmigaOS. Fredrik took the original code and updated it to AmigaOS 4.1 standards. This work included utilizing advanced DOS features such as object notification and the new file system API which seeks to completely avoid the esoteric DOS packet interface. Colin Wenzel is the main man behind the advanced DOS features.

Master_500pxIn order to test whether Filesysbox was working properly we needed a file system to go with it. NTFS-3G by Tuxera was chosen for this purpose. Fredrik also ported a full suite of tools to go along with NTFS itself.

Both Filesysbox and NTFS-3G are contributions being offered to registered AmigaOS users via AmiUpdate. The software licenses require that the source code be made available so registered users can download the matching source code from Hyperion’s web site in the downloads section.

blog_devIt is hoped that 3rd party developers will become interested in porting more file systems in the near future whether they are via the FUSE API or the new DOS file system API. The upcoming SDK will include everything you need. In the mean time, please feel free to utilize the provided source code and the AmigaOS support forum for assistance.

Finally, a big thanks needs to go out to the AmigaOS beta testing team for risking their hard drive partitions while testing NTFS-3G and Filesysbox. It is demanding and potentially destructive work that should not be taken for granted.

Ready for Music!

blog_softwareThe convenience of AmiUpdate has also allowed a few additions to your AmigaOS system. Camd.library was quietly added a few updates back. This contribution provides a common interface for programs that work with music in the MIDI format to connect with MIDI interfaces or to interconnect between applications. Now programs like Bars&Pipes Professional, AudioEvolution, HD_Rec, Dg-midi-monitor, Horny and CamdPlay will no longer require the user to go download and install camd.library. It will also ease installation of newer programs like Andy “Broadblues” Broad’s Line6PodEditor and his Perl to CAMD Link (Perl Amiga::CAMD).

Now, to make things even easier for the end user, the USB driver for MIDI devices is being added to the default AmigaOS installation as well. This means that if a user plugs in any MIDI class compatible USB device, AmigaOS will recognize the device and make it available to any program.

These additions together make programs for music much easier to install and run, so you can get right in to making music without worrying about the libraries and drivers to install.

71170_l

Bars&Pipes Professional and camd.library are maintained by, and the USB MIDI driver for camd was written by Lyle Hazelwood. Lyle accepts donations for his software at Lyle’s web site.

AmiWest 2013 AmigaOS Team

AmiWest2013-AmigaOS-Team1200AmiWest 2013 is now over and it was a heck of a lot of fun. We managed to grab a team photo this time.

From left to right in the front row sitting down we have Ken Wilde and Lyle Hazelwood. Next row back we have Bill Borsari, Flip LaFramboise, Trevor Dickinson and Tony Wyatt. In the back row we have Matthew Leaman, Val Marti, Paul Sadlik, Steven Solie and Alex Carmona.

A special thanks to Mike Brantley for taking the photo. Mike also took a lot more photos at the AmiWest 2013 show.

I think the big smiles on those faces says it all really.

I also took some time to update the AmiWest 2013 crowd on the current status of the Amiga Operating System which I will now summarize here:

  1. The netbook project initially announced at AmiWest 2011 has been cancelled. Below is an excerpt from an email to me from Ben Hermans dated October 10, 2013 on this matter.

    Despite best efforts by Hyperion and A-EON we were unable to get acceptable and stable conditions and terms from the Chinese supplier (price point, paying terms, required upfront, etc.)…

    The project was therefore cancelled in favour of a more future proof solution.

  2. A-EON Technology announces the Cyrus Plus Beta Test Programme. Follow the link for all the details and how to apply.
  3. Gallium3D Update
    • Software rendering completed
    • Working on the WinSys part of the implementation
    • Challenges encountered along the way:
      • Must be re-entrant, thread safe and multicore capable
      • Must run on a bare minimum system
      • Efficient
      • Possible to load non-Mesa and non-Gallium drivers
  4. X-Kernel Update
    • Task scheduler rewritten in C
    • Removed reliance on data structures (e.g. ExecBase task lists and ThisTask pointer)
    • Moving scheduler to run on auxiliary cores
    • All cores schedule tasks independently
    • Load balancing between cores
  5. AmigaOS 4.2
    • Depends on Gallium3D release
    • May or may not depend on multicore support
  6. AmigaOS 4.1 Update 7
    • Will be needed for Cyrus Plus product release
    • Consolidates all previous updates
  7. AmigaOS 4.1 Update 6
  8. FUSE and NTFS-3G
  9. New development team members since AmiWest 2012

We also had a chance to have a team meeting on Friday night in one of the hotel rooms while at the show. We had the usual Airing of Grievances and a lengthy discussion on where we are going and how to get there. At one point we were interrupted by an outsider who likened the gathering to a secret Masons meeting.

If you would like to come to AmiWest 2014 and join in the fun then keep October 24, 25 and 26 open. There is also a programming seminar planned for October 23 and 24. See you there!

An SDK Update (finally)

blog_devIt has been a long time coming but we finally got around to releasing an updated Software Development Kit (SDK) for the Amiga Operating System. You can download it from Hyperion’s server.

This SDK includes all the usual includes and autodocs you need to use all the latest released AmigaOS features. The AmigaOS Documentation Wiki contains all the higher level information you need and will continue to be updated to help explain everything. The wiki also has a new Frequently Asked Questions section where we will post the most common problems and solutions.

This SDK is also a tad incomplete because I ran out of time to prepare it before AmiWest 2013. Therefore, there will be another SDK update or two sometime after the AmiWest show which will include even more.

We will also try harder to provide an updated SDK much more regularly from now on. Thanks to AmiUpdate we now have a way to deliver all sorts of SDK updates as needed with minimal effort.

Support for the SDK is available from the official AmigaOS support forum. You may also want to give OS4Coding a try if you get stuck on something.

Have fun!

HDAudio driver is complete!

blog_devI am happy to announce the release of the finished HDAudio driver for the AmigaOne X1000!

The driver now supports recording as well as playback. It also now supports S/PDIF optical output.

There have been questions about whether full “32 bit” audio really makes a difference. I’d like to dig a little deeper to better understand the technical specifications.

There are two primary factors that contribute to the quality of a digital sound recording. One is resolution, or how many bits per sample, and the other is sample rate, commonly 44100 or 48000 samples per second.

As you look at the waveform of a sound recording, these two numbers determine the vertical and horizontal resolution of the wave.

I’ll begin with the “bit width” or vertical resolution.

The original Amiga’s sound output supported four channels at eight bits of resolution. Eight bits means there are two hundred and fifty six possible vertical “steps” that can be used as the wave is generated. Now we spread those steps across a -2 volt to +2 volt span and we get 0.015625 volts per step.

At the time of the Amigas introduction, that was a pretty fair sound playback. But only 256 steps is not as “high fidelity” as we might like. As a comparison, Compact Disk Audio is reproduced at 16 bits per sample. This makes for a big improvement in resolution. 16 bits offers us 65536 possible “steps” to spread across the -2 volt to +2 volt range. Now the step size is 0.0000610351562 volts per “step” of vertical resolution. So 16 bit audio is a HUGE increase in accuracy.

Getting back to our driver, AHIPrefs offers both 16 Bit HiFi and 32 bit HiFi modes. But I’ll bet that neither of those modes gives exactly what you might expect. As AHI mixes lots of different sounds together, possibly each sound with it’s own volume and pan settings, it can be useful to have more resolution available to work with. Here’s the clue: ALL AHI modes that say “HiFi” are sending 32 bit data out to the sound device! The “16″ and “32″ only describe what goes IN to the AHI mix routines. if it says HiFi, you WILL get 32 bit output to your card!

Or will you? In truth, while AHI is making it’s calculations using 32 bit registers and 32 bit math, it only promises 24 bits of accuracy. Is this anything to be concerned about? Not at all. I’ll tell you why. 24 bit samples will resolve to a “step size” of 0.0000002384185 volts per step. Wow! That is about one quarter of a microvolt. Those with an electronics background can probably tell you, that attempts to accurately work at those levels are just ridiculous. We have reached an accuracy that is beyond the ability of our amplifiers and speakers to reproduce. Put simply, 24 bits is the reasonable limit of current technology, or at least affordable technology.

So our 32 bit samples are flying out of AHI and in to the HDAudio codec. While the “container” is 32 bits wide, even the “high definition audio codec” that we have in the AmigaOne X1000 only resolves the top 24 bits. So it seems that in the end, both AHI and HDaudio agree that 24 bits is the reasonable limit for now.

And how about sample rate or the “horizontal” resolution?

How rapidly a sound is sampled and played back can also have a BIG impact on sound quality. It all starts with the Nyquist-Shannon sampling theorem or more commonly the Nyquist theorem. It’s pretty simple. As you record an audio signal, you must sample at at least twice the frequency of the highest pitch being recorded. Any sound that is higher than half the sampling frequency will be converted to noise and nasty noise at that.

So how high do we need? It is generally held that human hearing range is from 20 Hz (cycles per second) up to 20000 Hz. So any frequency above 40000 should be great right? Well Yes and No.

One simple problem is that we still must filter out all sound above half the sample frequency, and most frequency dependent volume controls (graphic equalizers) work with gradual slopes. There is no “hard cutoff” at a certain frequency, so we need a bit of headroom.

But there is another reason. As a high frequency sound approaches the Nyquist rate, we are only sampling about once per half-cycle. While this will reproduce the frequency of the original, it will do it at a bare minimum of accuracy. In other words, as frequencies get higher, they get less detail.

So what does it really matter?
Audio CDs play back at 44100 Hz. Not bad at all.
Television/DVD audio is usually at 48000 Hz. Nice.
With the HDAudio chip in the X1000 we support both of those frequencies.
We also support 88200, 96000, 176400, and 192000.
So we can double or quadruple the sample rates of common media!

At first, I really thought it was all a numbers game, but when developing the driver, I can actually hear the noise decrease noticeably as the playback rates went up!

And that is where I’ll leave off. This was enough of a lesson for one day. I am very happy that I could contribute to the completion of this driver. And the chance to “raise the bar” regarding sound capability was really very nice icing on the cake.

Like many of us, I have been using Amigas for a long time. Today, right here in front of me is an Amiga that supports high definition audio, a modern high performance video card. It uses standard, off the shelf keyboard, mouse, monitor and many USB accessories as well. Most of these we unheard of in the classic days. But with all the new and shiny, it is still AmigaOS to the core.
:)

New AmigaOS Core Developers

blog_devWe are pleased to announce that we have joined the AmigaOS development team. We hope that we are able to contribute some good things to AmigaOS using our skills in coding (Frank) and graphics (Thomas).

The follow is a short description of us and our products.

EntwicklerX:
We are currently working full time, self-employed, developing our games on multiple platforms (AmigaOS, Android, iOS, Windows Phone, Xbox Indies) as EntwicklerX. For about 10 years we have worked together on various software projects in our spare time. The focus in the last 5-6 years was to earn some money with the small bonus that it has allowed both of us to live from it (not enough for a Ferrari but enough to have fun at work). A strict separation between design and programming logic helped us build our products in an effective way with our limited time. While Frank takes care of programming, Thomas builds the graphics. Our subsystem is so sophisticated that Thomas can create and test Layouts without the help of Frank and Frank can use this directly in his code. This saves a lot of time and nerves. Before this, Frank had to compile every time if Thomas wanted to move a graphic a few pixels. ;)

AmiBoing Games

Our Amiga platform AmiBoing is used to bring an online connection to our games for high scores and achievements and it is also used for distributing our games. With more than 200 Users we can say this is the leading online gaming community on the Amiga platform. ;)

avatarImago_small

Thomas:
I care about what the user sees, how users interact with a game, paint graphics, create the levels and take care of our website. I have invested a lot of time into understanding how to create themes for AmigaOS and am still learning. The seamless design of an operating system is very important to me and I hope to play a part in this within AmigaOS.

avatarGoos_small

Frank:
I try to bring Thomas’ graphics to life and love to get the maximum out of AmigaOS using any available techniques to optimize (e.g. compositing). In our projects, I take care of all the programming. Together with Thomas, I am working on the game play and new game ideas. I can do my part in helping the Amiga in all areas of coding and to help current developers.

We are a Team:
Even with the split of responsibilities we will usually work as a team because ideas and their implementation always occur together. We look forward to working with the existing developers and also contributing to any interesting discussions. We will do our best but please note that we are only human and have a finite amount of time to work on everything. Give us time to understand how things work within the developer team. ;)

Best regards and let us say thank you for adding us to the list of AmigaOS core developers,
Thomas “imagodespira” Claus and Frank “Goos McGuile” Menzel.

Some Links:
EntwicklerX: www.entwickler-x.de
AmiBoing: www.amiboing.de
Themes: www.amiboing.de/themes.php

M.A.C.E

ThemeScreenshot

Delock PCI Express Sound Card supported

blog_miscAndreas Goiczyk has reported that the Delock PCI Express Sound Card 7.1 works well with the newly updated Envy24HT audio driver.

Thank you Andreas for letting us know!

If you discover a sound card not listed is supported by an AmigaOS audio driver, please use the contact form on the AmigaOS web site to let us know.

More Noise from ACube

blog_softwareThe VIA Envy24HT audio driver has been updated and now supports the VT1618 Codec. That means you can now use inexpensive PCIe audio cards such as the Syba SD-PEX63034 in your AmigaOne 500 and AmigaOne X1000 systems.

Here is a list of audio cards that are known to work with the Envy24HT audio driver:

  • Terratec Aureon 5.1 Sky
  • Terratec Aureon 7.1 Space
  • Terratec Phase22
  • Terratec Phase28
  • M-Audio Revolution 5.1
  • M-Audio Revolution 7.1
  • ESI Juli@
  • ESI Juli@ XTe
  • Speed Dragon EAU01A-1
  • Syba SD-PEX63034

If you happen to have audio card not on this list which also works with this driver please notify us via the AmigaOS contact form.

Special thanks to ACube Systems for helping to improve the Envy24HT driver.

The updated driver is being delivered to registered AmigaOS users using AmiUpdate. If you have any support issues with the driver please use the AmigaOS support forum for assistance.