CloverBootloader/rEFIt_UEFI/Platform/StartupSound.cpp
2020-08-17 22:40:52 +03:00

462 lines
14 KiB
C++

//
// StartupSound.c
// Clover
//
// Created by Slice on 02.01.2019.
//
// based on AudioPkg by Goldfish64
// https://github.com/Goldfish64/AudioPkg
/*
* Copyright (c) 2018 John Davis
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Platform.h> // Only use angled for Platform, else, xcode project won't compile
#include "StartupSound.h"
#include "Settings.h"
#include "Nvram.h"
extern UINTN AudioNum;
extern HDA_OUTPUTS AudioList[20];
extern UINT8 EmbeddedSound[];
extern UINTN EmbeddedSoundLength;
#ifndef DEBUG_ALL
#define DEBUG_SOUND 1
#else
#define DEBUG_SOUND DEBUG_ALL
#endif
#if DEBUG_SOUND == 0
#define DBG(...)
#else
#define DBG(...) DebugLog(DEBUG_SOUND, __VA_ARGS__)
#endif
//EFI_GUID gBootChimeVendorVariableGuid = {0x89D4F995, 0x67E3, 0x4895, { 0x8F, 0x18, 0x45, 0x4B, 0x65, 0x1D, 0x92, 0x15 }};
extern EFI_GUID gBootChimeVendorVariableGuid;
EFI_AUDIO_IO_PROTOCOL *AudioIo = NULL;
EFI_STATUS
StartupSoundPlay(EFI_FILE *Dir, CONST CHAR16* SoundFile)
{
EFI_STATUS Status;
UINT8 *FileData = NULL;
UINTN FileDataLength = 0U;
WAVE_FILE_DATA WaveData;
UINT8 OutputIndex;
UINT8 OutputVolume = DefaultAudioVolume;
UINT16 *TempData = NULL;
UINTN Len;
if (OldChosenAudio > AudioNum) {
OldChosenAudio = 0; //security correction
}
OutputIndex = (OldChosenAudio & 0xFF);
WaveData.Samples = NULL;
WaveData.SamplesLength = 0;
if (!AudioIo) {
Status = EFI_DEVICE_ERROR;
// DBG("not found AudioIo to play\n");
goto DONE_ERROR;
}
if (SoundFile) {
Status = egLoadFile(Dir, SoundFile, &FileData, &FileDataLength);
if (EFI_ERROR(Status)) {
// DBG("file sound read: %ls %s\n", SoundFile, strerror(Status));
goto DONE_ERROR;
}
} else {
FileData = EmbeddedSound;
FileDataLength = EmbeddedSoundLength;
// DBG("got embedded sound\n");
}
Status = WaveGetFileData(FileData, (UINT32)FileDataLength, &WaveData); //
if (EFI_ERROR(Status)) {
MsgLog(" wrong sound file, wave status=%s\n", strerror(Status));
//if error then data not allocated
goto DONE_ERROR;
}
Len = WaveData.SamplesLength; //byte length
MsgLog(" Channels: %hu Sample rate: %u Hz Bits: %hu\n", WaveData.Format->Channels, WaveData.Format->SamplesPerSec, WaveData.Format->BitsPerSample);
EFI_AUDIO_IO_PROTOCOL_BITS bits;
switch (WaveData.Format->BitsPerSample) {
case 8:
bits = EfiAudioIoBits8;
break;
case 16:
bits = EfiAudioIoBits16;
break;
case 20:
bits = EfiAudioIoBits20;
break;
case 24:
bits = EfiAudioIoBits24;
break;
case 32:
bits = EfiAudioIoBits32;
break;
default:
goto DONE_ERROR;
}
EFI_AUDIO_IO_PROTOCOL_FREQ freq;
switch (WaveData.Format->SamplesPerSec) {
case 8000:
freq = EfiAudioIoFreq8kHz;
break;
case 11000:
freq = EfiAudioIoFreq11kHz;
break;
case 16000:
freq = EfiAudioIoFreq16kHz;
break;
case 22050:
freq = EfiAudioIoFreq22kHz;
break;
case 32000:
freq = EfiAudioIoFreq32kHz;
break;
case 44100:
freq = EfiAudioIoFreq44kHz;
break;
case 48000:
freq = EfiAudioIoFreq48kHz;
break;
case 88000:
freq = EfiAudioIoFreq88kHz;
break;
case 96000:
freq = EfiAudioIoFreq96kHz;
break;
case 192000:
freq = EfiAudioIoFreq192kHz;
break;
default:
goto DONE_ERROR;
}
DBG("output to channel %d with volume %d, len=%d\n", OutputIndex, OutputVolume, WaveData.SamplesLength);
DBG(" sound channels=%d bits=%d freq=%d\n", WaveData.Format->Channels, WaveData.Format->BitsPerSample, WaveData.Format->SamplesPerSec);
if (!WaveData.SamplesLength || !OutputVolume) {
// DBG("nothing to play\n"); //but data allocated
Status = EFI_NOT_FOUND;
goto DONE_ERROR;
}
if ((freq == EfiAudioIoFreq8kHz) && (bits == EfiAudioIoBits16)) {
//making conversion
Len *= 6; //8000<->48000
UINTN Ind, Out=0, Tact;
INT16 Tmp, Next;
float Delta;
INT16 *Ptr = (INT16*)WaveData.Samples;
if (!Ptr) {
Status = EFI_NOT_FOUND;
// DBG("not found wave data\n");
goto DONE_ERROR;
}
// TempData = (__typeof__(TempData))AllocateZeroPool(Len * sizeof(INT16));
TempData = (__typeof__(TempData))AllocateAlignedPages(EFI_SIZE_TO_PAGES(Len + 4095), 128);
Tmp = *(Ptr++);
for (Ind = 0; Ind < WaveData.SamplesLength / 2 - 1; Ind++) {
Next = *(Ptr++);
Delta = (Next - Tmp) / 6.f;
for (Tact = 0; Tact < 6; Tact++) {
TempData[Out++] = Tmp;
Tmp = (INT16)(Delta + Tmp + 0.5f);
}
Tmp = Next;
}
freq = EfiAudioIoFreq48kHz;
// Samples was allocated via AllocateAlignedPages, so it must not be freed with FreePool, but according to the number of pages allocated
FreeAlignedPages(WaveData.Samples,EFI_SIZE_TO_PAGES(WaveData.SamplesLength + 4095));
WaveData.SamplesLength *= 6;
DBG("sound converted to 48kHz\n");
WaveData.Samples = (UINT8*)TempData;
}
// Setup playback.
if (OutputIndex > AudioNum) {
OutputIndex = 0;
DBG("wrong index for Audio output\n");
}
Status = AudioIo->SetupPlayback(AudioIo, (UINT8)(AudioList[OutputIndex].Index), OutputVolume,
freq, bits, (UINT8)(WaveData.Format->Channels));
if (EFI_ERROR(Status)) {
MsgLog("StartupSound: Error setting up playback: %s\n", strerror(Status));
goto DONE_ERROR;
}
// DBG("playback set\n");
// Start playback.
if (gSettings.PlayAsync) {
Status = AudioIo->StartPlaybackAsync(AudioIo, WaveData.Samples, WaveData.SamplesLength, 0, NULL, NULL);
// DBG("async started, status=%s\n", strerror(Status));
} else {
Status = AudioIo->StartPlayback(AudioIo, WaveData.Samples, WaveData.SamplesLength, 0);
// DBG("sync started, status=%s\n", strerror(Status));
// if (!EFI_ERROR(Status)) {
// FreePool(TempData);
// }
}
if (EFI_ERROR(Status)) {
MsgLog("StartupSound: Error starting playback: %s\n", strerror(Status));
}
DONE_ERROR:
if (FileData && SoundFile) { //dont free embedded sound
// DBG("free sound\n");
FreePool(FileData);
}
if (!gSettings.PlayAsync && WaveData.Samples) {
//dont free sound when async play
// here we have memory leak with WaveData.Samples
// and we can't free memory up to stop AsyncPlay
FreeAlignedPages(WaveData.Samples, EFI_SIZE_TO_PAGES(WaveData.SamplesLength + 4095));
}
DBG("sound play end with status=%s\n", strerror(Status));
return Status;
}
EFI_STATUS
GetStoredOutput()
{
// Create variables.
EFI_STATUS Status;
UINTN h;
// Device Path.
EFI_DEVICE_PATH_PROTOCOL *DevicePath = NULL;
UINT8 *StoredDevicePath = NULL; //it is EFI_DEVICE_PATH_PROTOCOL*
UINTN StoredDevicePathSize = 0;
// Audio I/O.
EFI_HANDLE *AudioIoHandles = NULL;
UINTN AudioIoHandleCount = 0;
EFI_AUDIO_IO_PROTOCOL *AudioIoProto = NULL;
// Output.
UINTN OutputPortIndex;
UINTN OutputPortIndexSize = sizeof(OutputPortIndex);
UINT8 OutputVolume;
UINTN OutputVolumeSize = sizeof(OutputVolume);
// Get Audio I/O protocols.
Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiAudioIoProtocolGuid, NULL, &AudioIoHandleCount, &AudioIoHandles);
if (EFI_ERROR(Status)) {
MsgLog("No AudioIoProtocol, status=%s\n", strerror(Status));
goto DONE;
}
DBG("found %llu handles with audio\n", AudioIoHandleCount);
// Get stored device path size. First from AppleBootGuid
StoredDevicePath = (__typeof__(StoredDevicePath))GetNvramVariable(L"Clover.SoundDevice", &gEfiAppleBootGuid, NULL, &StoredDevicePathSize);
if (!StoredDevicePath) {
// second attempt with BootChimeGuid
StoredDevicePath = (__typeof__(StoredDevicePath))GetNvramVariable(BOOT_CHIME_VAR_DEVICE, &gBootChimeVendorVariableGuid, NULL, &StoredDevicePathSize);
if (!StoredDevicePath) {
MsgLog("No AudioIoDevice stored\n");
Status = EFI_NOT_FOUND;
goto DONE;
}
}
//we have to convert str->data if happen
if ((StoredDevicePath[0] != 2) && (StoredDevicePath[1] != 1)) {
XStringW StoredDevicePathStr = SWPrintf("%ls", (CHAR16*)StoredDevicePath);
FreePool(StoredDevicePath);
DBG("stored device=%ls\n", StoredDevicePathStr.wc_str());
StoredDevicePath = (UINT8*)ConvertTextToDevicePath(StoredDevicePathStr.wc_str());
StoredDevicePathSize = GetDevicePathSize((EFI_DEVICE_PATH_PROTOCOL *)StoredDevicePath);
}
// Try to find the matching device exposing an Audio I/O protocol.
for (h = 0; h < AudioIoHandleCount; h++) {
// Open Device Path protocol.
Status = gBS->HandleProtocol(AudioIoHandles[h], &gEfiDevicePathProtocolGuid, (VOID**)&DevicePath);
if (EFI_ERROR(Status)) {
DBG("no DevicePath at %llu handle AudioIo\n", h);
continue;
}
// Compare Device Paths. If they match, we have our Audio I/O device.
if (!CompareMem(StoredDevicePath, DevicePath, StoredDevicePathSize)) {
// Open Audio I/O protocol.
Status = gBS->HandleProtocol(AudioIoHandles[h], &gEfiAudioIoProtocolGuid, (VOID**)&AudioIoProto);
if (EFI_ERROR(Status)) {
DBG("dont handle AudioIo\n");
goto DONE;
}
break;
}
}
// If the Audio I/O variable is still null, we couldn't find it.
if (AudioIoProto == NULL) {
Status = EFI_NOT_FOUND;
DBG("not found AudioIo in nvram\n");
goto DONE;
}
// Get stored device index.
OutputPortIndex = 0;
Status = gRT->GetVariable(L"Clover.SoundIndex", &gEfiAppleBootGuid, NULL,
&OutputPortIndexSize, &OutputPortIndex);
if (EFI_ERROR(Status)) {
Status = gRT->GetVariable(BOOT_CHIME_VAR_INDEX, &gBootChimeVendorVariableGuid, NULL,
&OutputPortIndexSize, &OutputPortIndex);
if (EFI_ERROR(Status)) {
MsgLog("Bad output index, status=%s, set 0\n", strerror(Status));
OutputPortIndex = 0;
}
}
OutputPortIndex &= 0x2F;
DBG("got index=%llu\n", OutputPortIndex);
if (OutputPortIndex > AudioNum) {
DBG("... but max=%llu, so reset to 0\n", AudioNum);
OutputPortIndex = 0;
}
// Get stored volume. If this fails, just use the max.
OutputVolume = DefaultAudioVolume;
Status = gRT->GetVariable(L"Clover.SoundVolume", &gEfiAppleBootGuid, NULL,
&OutputVolumeSize, &OutputVolume);
if (EFI_ERROR(Status)) {
Status = gRT->GetVariable(BOOT_CHIME_VAR_VOLUME, &gBootChimeVendorVariableGuid, NULL,
&OutputVolumeSize, &OutputVolume);
if (EFI_ERROR(Status)) {
OutputVolume = DefaultAudioVolume; //EFI_AUDIO_IO_PROTOCOL_MAX_VOLUME;
}
}
DefaultAudioVolume = OutputVolume;
DBG("got volume %d\n", OutputVolume);
// Success. Assign global variables
AudioIo = AudioIoProto;
OldChosenAudio = OutputPortIndex;
Status = EFI_SUCCESS;
DONE:
if (StoredDevicePath != NULL)
FreePool(StoredDevicePath);
if (AudioIoHandles != NULL)
FreePool(AudioIoHandles);
return Status;
}
EFI_STATUS CheckSyncSound(BOOLEAN Stop)
{
EFI_STATUS Status;
AUDIO_IO_PRIVATE_DATA *AudioIoPrivateData;
EFI_HDA_IO_PROTOCOL *HdaIo;
BOOLEAN StreamRunning = FALSE;
if (!AudioIo) {
return EFI_NOT_STARTED;
}
// Get private data.
AudioIoPrivateData = AUDIO_IO_PRIVATE_DATA_FROM_THIS(AudioIo);
if (!AudioIoPrivateData || !AudioIoPrivateData->HdaCodecDev || !AudioIoPrivateData->HdaCodecDev->HdaIo) {
return EFI_NOT_STARTED;
}
HdaIo = AudioIoPrivateData->HdaCodecDev->HdaIo;
Status = HdaIo->GetStream(HdaIo, EfiHdaIoTypeOutput, &StreamRunning);
if ((EFI_ERROR(Status) || Stop) && StreamRunning) {
DBG("stream stopping & controller reset\n");
HdaIo->StopStream(HdaIo, EfiHdaIoTypeOutput);
// HDA_IO_PRIVATE_DATA *HdaIoPrivateData = HDA_IO_PRIVATE_DATA_FROM_THIS(HdaIo);
// HDA_CONTROLLER_DEV *HdaControllerDev = HdaIoPrivateData->HdaControllerDev;
// EFI_PCI_IO_PROTOCOL *PciIo = HdaControllerDev->PciIo;
// HdaControllerCleanup(HdaControllerDev);
}
if (!StreamRunning) {
AudioIo = NULL;
Status = EFI_NOT_STARTED;
}
return Status;
}
VOID GetOutputs()
{
EFI_STATUS Status;
// Audio I/O.
EFI_HANDLE *AudioIoHandles = NULL;
UINTN AudioIoHandleCount = 0;
AUDIO_IO_PRIVATE_DATA *AudioIoPrivateData;
EFI_AUDIO_IO_PROTOCOL *AudioIoTmp = NULL;
HDA_CODEC_DEV *HdaCodecDev;
EFI_AUDIO_IO_PROTOCOL_PORT *HdaOutputPorts = NULL;
UINTN OutputPortsCount = 0;
UINTN h;
AudioNum = 0;
// Get Audio I/O protocols.
Status = gBS->LocateHandleBuffer(ByProtocol, &gEfiAudioIoProtocolGuid, NULL, &AudioIoHandleCount, &AudioIoHandles);
if (EFI_ERROR(Status)) {
MsgLog("No AudioIoProtocols, status=%s\n", strerror(Status));
return;
}
for (h = 0; h < AudioIoHandleCount; h++) {
UINTN i;
Status = gBS->HandleProtocol(AudioIoHandles[h], &gEfiAudioIoProtocolGuid, (VOID**)&AudioIoTmp);
if (EFI_ERROR(Status)) {
DBG("dont handle AudioIo at %llu\n", h);
continue;
}
// Get output ports.
Status = AudioIoTmp->GetOutputs(AudioIoTmp, &HdaOutputPorts, &OutputPortsCount);
if (EFI_ERROR(Status)) {
continue;
}
AudioIoPrivateData = AUDIO_IO_PRIVATE_DATA_FROM_THIS(AudioIoTmp);
if (!AudioIoPrivateData) {
continue;
}
HdaCodecDev = AudioIoPrivateData->HdaCodecDev;
for (i = 0; i < OutputPortsCount; i++) {
// HdaCodecDev->OutputPorts[i];
AudioList[AudioNum].Name = HdaCodecDev->Name;
AudioList[AudioNum].Handle = AudioIoHandles[h];
AudioList[AudioNum].Device = HdaOutputPorts[i].Device;
AudioList[AudioNum++].Index = i;
}
}
Status = GetStoredOutput();
if (EFI_ERROR(Status)) {
DBG("no stored audio parameters\n");
}
}