src/audio/psp/SDL_pspaudio.c
author Philipp Wiesemann
Wed, 27 Jan 2016 23:20:23 +0100
changeset 10058 d141e7945ddf
parent 9998 f67cf37e9cd4
child 10255 9530fc07da6c
permissions -rw-r--r--
PSP: Removed inlined copy of SDL_CalculateAudioSpec()'s functionality.
     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_audiomem.h"
    34 #include "../SDL_audio_c.h"
    35 #include "../SDL_audiodev_c.h"
    36 #include "../SDL_sysaudio.h"
    37 #include "SDL_pspaudio.h"
    38 
    39 #include <pspaudio.h>
    40 #include <pspthreadman.h>
    41 
    42 /* The tag name used by PSP audio */
    43 #define PSPAUD_DRIVER_NAME         "psp"
    44 
    45 static int
    46 PSPAUD_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
    47 {
    48     int format, mixlen, i;
    49     this->hidden = (struct SDL_PrivateAudioData *)
    50         SDL_malloc(sizeof(*this->hidden));
    51     if (this->hidden == NULL) {
    52         return SDL_OutOfMemory();
    53     }
    54     SDL_memset(this->hidden, 0, sizeof(*this->hidden));
    55     switch (this->spec.format & 0xff) {
    56         case 8:
    57         case 16:
    58             this->spec.format = AUDIO_S16LSB;
    59             break;
    60         default:
    61             return SDL_SetError("Unsupported audio format");
    62     }
    63 
    64     /* The sample count must be a multiple of 64. */
    65     this->spec.samples = PSP_AUDIO_SAMPLE_ALIGN(this->spec.samples);
    66     this->spec.freq = 44100;
    67 
    68     /* Update the fragment size as size in bytes. */
    69     SDL_CalculateAudioSpec(&this->spec);
    70 
    71     /* Allocate the mixing buffer.  Its size and starting address must
    72        be a multiple of 64 bytes.  Our sample count is already a multiple of
    73        64, so spec->size should be a multiple of 64 as well. */
    74     mixlen = this->spec.size * NUM_BUFFERS;
    75     this->hidden->rawbuf = (Uint8 *) memalign(64, mixlen);
    76     if (this->hidden->rawbuf == NULL) {
    77         return SDL_SetError("Couldn't allocate mixing buffer");
    78     }
    79 
    80     /* Setup the hardware channel. */
    81     if (this->spec.channels == 1) {
    82         format = PSP_AUDIO_FORMAT_MONO;
    83     } else {
    84         format = PSP_AUDIO_FORMAT_STEREO;
    85     }
    86     this->hidden->channel = sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL, this->spec.samples, format);
    87     if (this->hidden->channel < 0) {
    88         free(this->hidden->rawbuf);
    89         this->hidden->rawbuf = NULL;
    90         return SDL_SetError("Couldn't reserve hardware channel");
    91     }
    92 
    93     memset(this->hidden->rawbuf, 0, mixlen);
    94     for (i = 0; i < NUM_BUFFERS; i++) {
    95         this->hidden->mixbufs[i] = &this->hidden->rawbuf[i * this->spec.size];
    96     }
    97 
    98     this->hidden->next_buffer = 0;
    99     return 0;
   100 }
   101 
   102 static void PSPAUD_PlayDevice(_THIS)
   103 {
   104     Uint8 *mixbuf = this->hidden->mixbufs[this->hidden->next_buffer];
   105 
   106     if (this->spec.channels == 1) {
   107         sceAudioOutputBlocking(this->hidden->channel, PSP_AUDIO_VOLUME_MAX, mixbuf);
   108     } else {
   109         sceAudioOutputPannedBlocking(this->hidden->channel, PSP_AUDIO_VOLUME_MAX, PSP_AUDIO_VOLUME_MAX, mixbuf);
   110     }
   111 
   112     this->hidden->next_buffer = (this->hidden->next_buffer + 1) % NUM_BUFFERS;
   113 }
   114 
   115 /* This function waits until it is possible to write a full sound buffer */
   116 static void PSPAUD_WaitDevice(_THIS)
   117 {
   118     /* Because we block when sending audio, there's no need for this function to do anything. */
   119 }
   120 static Uint8 *PSPAUD_GetDeviceBuf(_THIS)
   121 {
   122     return this->hidden->mixbufs[this->hidden->next_buffer];
   123 }
   124 
   125 static void PSPAUD_CloseDevice(_THIS)
   126 {
   127     if (this->hidden->channel >= 0) {
   128         sceAudioChRelease(this->hidden->channel);
   129         this->hidden->channel = -1;
   130     }
   131 
   132     if (this->hidden->rawbuf != NULL) {
   133         free(this->hidden->rawbuf);
   134         this->hidden->rawbuf = NULL;
   135     }
   136 }
   137 static void PSPAUD_ThreadInit(_THIS)
   138 {
   139     /* Increase the priority of this audio thread by 1 to put it
   140        ahead of other SDL threads. */
   141     SceUID thid;
   142     SceKernelThreadInfo status;
   143     thid = sceKernelGetThreadId();
   144     status.size = sizeof(SceKernelThreadInfo);
   145     if (sceKernelReferThreadStatus(thid, &status) == 0) {
   146         sceKernelChangeThreadPriority(thid, status.currentPriority - 1);
   147     }
   148 }
   149 
   150 
   151 static int
   152 PSPAUD_Init(SDL_AudioDriverImpl * impl)
   153 {
   154 
   155     /* Set the function pointers */
   156     impl->OpenDevice = PSPAUD_OpenDevice;
   157     impl->PlayDevice = PSPAUD_PlayDevice;
   158     impl->WaitDevice = PSPAUD_WaitDevice;
   159     impl->GetDeviceBuf = PSPAUD_GetDeviceBuf;
   160     impl->WaitDone = PSPAUD_WaitDevice;
   161     impl->CloseDevice = PSPAUD_CloseDevice;
   162     impl->ThreadInit = PSPAUD_ThreadInit;
   163 
   164     /* PSP audio device */
   165     impl->OnlyHasDefaultOutputDevice = 1;
   166 /*
   167     impl->HasCaptureSupport = 1;
   168 
   169     impl->OnlyHasDefaultInputDevice = 1;
   170 */
   171     /*
   172     impl->DetectDevices = DSOUND_DetectDevices;
   173     impl->Deinitialize = DSOUND_Deinitialize;
   174     */
   175     return 1;   /* this audio target is available. */
   176 }
   177 
   178 AudioBootStrap PSPAUD_bootstrap = {
   179     "psp", "PSP audio driver", PSPAUD_Init, 0
   180 };
   181 
   182  /* SDL_AUDI */
   183 
   184 #endif /* SDL_AUDIO_DRIVER_PSP */
   185 
   186 /* vi: set ts=4 sw=4 expandtab: */