src/audio/psp/SDL_pspaudio.c
author Ryan C. Gordon
Fri, 05 Aug 2016 01:59:06 -0400
changeset 10257 f17581d00c26
parent 10256 620329de23d4
child 10258 0ba7106e9a6d
permissions -rw-r--r--
audio: changed some SDL_memset() calls to SDL_zero(), other minor corrections.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "../../SDL_internal.h"
    22 
    23 #if SDL_AUDIO_DRIVER_PSP
    24 
    25 #include <stdio.h>
    26 #include <string.h>
    27 #include <stdlib.h>
    28 #include <malloc.h>
    29 
    30 #include "SDL_audio.h"
    31 #include "SDL_error.h"
    32 #include "SDL_timer.h"
    33 #include "../SDL_audio_c.h"
    34 #include "../SDL_audiodev_c.h"
    35 #include "../SDL_sysaudio.h"
    36 #include "SDL_pspaudio.h"
    37 
    38 #include <pspaudio.h>
    39 #include <pspthreadman.h>
    40 
    41 /* The tag name used by PSP audio */
    42 #define PSPAUD_DRIVER_NAME         "psp"
    43 
    44 static int
    45 PSPAUD_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
    46 {
    47     int format, mixlen, i;
    48     this->hidden = (struct SDL_PrivateAudioData *)
    49         SDL_malloc(sizeof(*this->hidden));
    50     if (this->hidden == NULL) {
    51         return SDL_OutOfMemory();
    52     }
    53     SDL_zerop(this->hidden);
    54     switch (this->spec.format & 0xff) {
    55         case 8:
    56         case 16:
    57             this->spec.format = AUDIO_S16LSB;
    58             break;
    59         default:
    60             return SDL_SetError("Unsupported audio format");
    61     }
    62 
    63     /* The sample count must be a multiple of 64. */
    64     this->spec.samples = PSP_AUDIO_SAMPLE_ALIGN(this->spec.samples);
    65     this->spec.freq = 44100;
    66 
    67     /* Update the fragment size as size in bytes. */
    68     SDL_CalculateAudioSpec(&this->spec);
    69 
    70     /* Allocate the mixing buffer.  Its size and starting address must
    71        be a multiple of 64 bytes.  Our sample count is already a multiple of
    72        64, so spec->size should be a multiple of 64 as well. */
    73     mixlen = this->spec.size * NUM_BUFFERS;
    74     this->hidden->rawbuf = (Uint8 *) memalign(64, mixlen);
    75     if (this->hidden->rawbuf == NULL) {
    76         return SDL_SetError("Couldn't allocate mixing buffer");
    77     }
    78 
    79     /* Setup the hardware channel. */
    80     if (this->spec.channels == 1) {
    81         format = PSP_AUDIO_FORMAT_MONO;
    82     } else {
    83         format = PSP_AUDIO_FORMAT_STEREO;
    84     }
    85     this->hidden->channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, this->spec.samples, format);
    86     if (this->hidden->channel < 0) {
    87         free(this->hidden->rawbuf);
    88         this->hidden->rawbuf = NULL;
    89         return SDL_SetError("Couldn't reserve hardware channel");
    90     }
    91 
    92     memset(this->hidden->rawbuf, 0, mixlen);
    93     for (i = 0; i < NUM_BUFFERS; i++) {
    94         this->hidden->mixbufs[i] = &this->hidden->rawbuf[i * this->spec.size];
    95     }
    96 
    97     this->hidden->next_buffer = 0;
    98     return 0;
    99 }
   100 
   101 static void PSPAUD_PlayDevice(_THIS)
   102 {
   103     Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
   104 
   105     if (this->spec.channels == 1) {
   106         sceAudioOutputBlocking(this->hidden->channel, PSP_AUDIO_VOLUME_MAX, mixbuf);
   107     } else {
   108         sceAudioOutputPannedBlocking(this->hidden->channel, PSP_AUDIO_VOLUME_MAX, PSP_AUDIO_VOLUME_MAX, mixbuf);
   109     }
   110 
   111     this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
   112 }
   113 
   114 /* This function waits until it is possible to write a full sound buffer */
   115 static void PSPAUD_WaitDevice(_THIS)
   116 {
   117     /* Because we block when sending audio, there's no need for this function to do anything. */
   118 }
   119 static Uint8 *PSPAUD_GetDeviceBuf(_THIS)
   120 {
   121     return this->hidden->mixbufs[this->hidden->next_buffer];
   122 }
   123 
   124 static void PSPAUD_CloseDevice(_THIS)
   125 {
   126     if (this->hidden->channel >= 0) {
   127         sceAudioChRelease(this->hidden->channel);
   128     }
   129     free(this->hidden->rawbuf);  /* this uses memalign(), not SDL_malloc(). */
   130     SDL_free(this->hidden);
   131 }
   132 
   133 static void PSPAUD_ThreadInit(_THIS)
   134 {
   135     /* Increase the priority of this audio thread by 1 to put it
   136        ahead of other SDL threads. */
   137     SceUID thid;
   138     SceKernelThreadInfo status;
   139     thid = sceKernelGetThreadId();
   140     status.size = sizeof(SceKernelThreadInfo);
   141     if (sceKernelReferThreadStatus(thid, &status) == 0) {
   142         sceKernelChangeThreadPriority(thid, status.currentPriority - 1);
   143     }
   144 }
   145 
   146 
   147 static int
   148 PSPAUD_Init(SDL_AudioDriverImpl * impl)
   149 {
   150     /* Set the function pointers */
   151     impl->OpenDevice = PSPAUD_OpenDevice;
   152     impl->PlayDevice = PSPAUD_PlayDevice;
   153     impl->WaitDevice = PSPAUD_WaitDevice;
   154     impl->GetDeviceBuf = PSPAUD_GetDeviceBuf;
   155     impl->WaitDone = PSPAUD_WaitDevice;
   156     impl->CloseDevice = PSPAUD_CloseDevice;
   157     impl->ThreadInit = PSPAUD_ThreadInit;
   158 
   159     /* PSP audio device */
   160     impl->OnlyHasDefaultOutputDevice = 1;
   161 /*
   162     impl->HasCaptureSupport = 1;
   163 
   164     impl->OnlyHasDefaultInputDevice = 1;
   165 */
   166     /*
   167     impl->DetectDevices = DSOUND_DetectDevices;
   168     impl->Deinitialize = DSOUND_Deinitialize;
   169     */
   170     return 1;   /* this audio target is available. */
   171 }
   172 
   173 AudioBootStrap PSPAUD_bootstrap = {
   174     "psp", "PSP audio driver", PSPAUD_Init, 0
   175 };
   176 
   177  /* SDL_AUDI */
   178 
   179 #endif /* SDL_AUDIO_DRIVER_PSP */
   180 
   181 /* vi: set ts=4 sw=4 expandtab: */