← Back to branch summary

~ubuntu-branches/ubuntu/karmic/xpuzzles/karmic

« back to all changes in this revision

Viewing changes to xpanex/vms/vms_mmov.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-22 16:29:42 UTC
  • mfrom: (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050822162942-tdtf178zkpd3xxdg
Tags: 7.1.3-1ubuntu1
Update {build-,}depends for xorg -> mesa transition.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xpanex/vms/vms_mmov.c
 
1
#include <stdio.h>
 
2
#include <signal.h>
 
3
#include <mme/mme_api.h>
 
4
#include "mmc_buffers.h"
 
5
#include "mmc_cmdlin.h"
 
6
#include "mmc_memory.h"
 
7
#include "mmc_wave_format.h"
 
8
#include "mmc_wave_file.h"
 
9
#include "mmc_wave.h"
 
10
 
 
11
#define BUFFER_PAD 4
 
12
 
 
13
#define DEFAULT_NCHANNELS       1
 
14
#define DEFAULT_ENCODING        WAVE_FORMAT_MULAW
 
15
#define DEFAULT_SAMPLESIZE      8
 
16
#define DEFAULT_SAMPLERATE      8000
 
17
 
 
18
#define DIV_ROUND_UP_(n,d) ((n + d - 1) / d)
 
19
#define ROUND_UP_(n,d) (DIV_ROUND_UP_(n,d) * d)
 
20
 
 
21
enum mmov_state
 
22
{
 
23
  MMOV_START,
 
24
  MMOV_PLAY,
 
25
  MMOV_WAITING,
 
26
  MMOV_CLOSE
 
27
};
 
28
 
 
29
#define NUM_DATA 32
 
30
struct mmov_soundformat
 
31
{
 
32
   WAVEFORMATEX wave;
 
33
   char extra_data[ NUM_DATA ];
 
34
};
 
35
 
 
36
static int Verbose;
 
37
static mmcWaveFileState_t wavefilestatus = mmcWaveFileStateInitialValue;
 
38
static mmcBufferList_t mmov_buffer = mmcBufferListInitialValue;
 
39
static enum mmov_state play_state;
 
40
 
 
41
static void mmov_cleanup( )
 
42
{
 
43
   if (mmov_buffer.b)
 
44
     {
 
45
        mmcBuffersFree (&mmov_buffer);
 
46
     }
 
47
   mmcFreeAll ();
 
48
    {
 
49
       mmcWaveInFileClose (&wavefilestatus);
 
50
    }
 
51
    return;
 
52
}
 
53
 
 
54
static void mmov_driver (HANDLE hWaveOut,
 
55
                             UINT wMsg,
 
56
                             DWORD dwInstance,
 
57
                             LPARAM lParam1,
 
58
                             LPARAM lParam2)
 
59
{
 
60
    switch (wMsg)
 
61
    {
 
62
      case WOM_OPEN:
 
63
        play_state = MMOV_PLAY;
 
64
        break;
 
65
      case WOM_CLOSE:
 
66
        play_state = MMOV_CLOSE;
 
67
        break;
 
68
 
 
69
      case WOM_DONE:
 
70
      {
 
71
          int buffer_index = mmcWaveOutGotData (&mmov_buffer, lParam1);
 
72
          mmcBuffer_p bp = &mmov_buffer.b[buffer_index];
 
73
          mmcBufferSetStatus (&mmov_buffer, buffer_index, Empty,
 
74
                              mmov_buffer.nbytes);
 
75
      }
 
76
        break;
 
77
      default:
 
78
        mmcVerboseDisplay(Verbose, "Unknown index %d", wMsg);
 
79
        break;
 
80
    }
 
81
}
 
82
 
 
83
void play_sound_mmov( char* FileName , int verbose )
 
84
{
 
85
    HWAVEOUT hwaveout;
 
86
    MMRESULT status;
 
87
    int mask1;
 
88
    int allDone;
 
89
 
 
90
    static int uDeviceId = WAVE_MAPPER;
 
91
    static int AdpcmBitsPerSample = 16;
 
92
    static int AdpcmSamplesPerBlock = 0;
 
93
    static int sizeBuffers = 0;
 
94
    static int msBuffers = 0;
 
95
    static int numBuffers = 4;
 
96
    static struct mmov_soundformat sound_format =
 
97
    {
 
98
        {
 
99
            DEFAULT_ENCODING,
 
100
            DEFAULT_NCHANNELS,
 
101
            DEFAULT_SAMPLERATE,
 
102
            0,
 
103
            0,
 
104
            DEFAULT_SAMPLESIZE,
 
105
            NUM_DATA
 
106
        }, {
 
107
            0, 0, 0, 0, 0, 0, 0, 0,
 
108
            0, 0, 0, 0, 0, 0, 0, 0,
 
109
            0, 0, 0, 0, 0, 0, 0, 0,
 
110
            0, 0, 0, 0, 0, 0, 0, 0
 
111
        }
 
112
    };
 
113
 
 
114
   Verbose = verbose;
 
115
   play_state = MMOV_START;
 
116
 
 
117
    /* Open the Wave In file */
 
118
    if (mmcWaveInFileOpen (FileName, &sound_format.wave, &wavefilestatus) != 0)
 
119
    {
 
120
        mmcVerboseDisplay(Verbose,"Error opening input file");
 
121
        mmov_cleanup();
 
122
       return;
 
123
    }
 
124
 
 
125
    if ( sound_format.wave.wFormatTag == WAVE_FORMAT_PCM)
 
126
      mmcVerboseDisplay(Verbose,"PCM file");
 
127
    else if ( sound_format.wave.wFormatTag == WAVE_FORMAT_MULAW)
 
128
      mmcVerboseDisplay(Verbose,"mu-law file");
 
129
    else if ( sound_format.wave.wFormatTag == WAVE_FORMAT_IMA_ADPCM)
 
130
      mmcVerboseDisplay(Verbose,"IMA file");
 
131
    else
 
132
      mmcVerboseDisplay(Verbose,"Unknown sound format %d",
 
133
                                sound_format.wave.wFormatTag);
 
134
    mmcVerboseDisplay(Verbose,"Channels = %d ",  sound_format.wave.nChannels );
 
135
    mmcVerboseDisplay(Verbose,"Sample rate = %d",
 
136
                      sound_format.wave.nSamplesPerSec);
 
137
    mmcVerboseDisplay(Verbose,
 
138
                      "Sample size = %d", sound_format.wave.wBitsPerSample );
 
139
 
 
140
    if( sound_format.wave.nChannels == 0)
 
141
      sound_format.wave.nChannels = DEFAULT_NCHANNELS;
 
142
    if( sound_format.wave.nSamplesPerSec == 0)
 
143
      sound_format.wave.nSamplesPerSec = DEFAULT_SAMPLERATE;
 
144
    if( sound_format.wave.wBitsPerSample == 0)
 
145
      sound_format.wave.wBitsPerSample = DEFAULT_SAMPLESIZE;
 
146
 
 
147
    if ( sound_format.wave.wFormatTag == WAVE_FORMAT_IMA_ADPCM ) {
 
148
      AdpcmSamplesPerBlock = *(Uint16 *)(&sound_format.extra_data[0]);
 
149
    }
 
150
 
 
151
    if ( ( sound_format.wave.wFormatTag == WAVE_FORMAT_PCM) ||
 
152
        ( sound_format.wave.wFormatTag == WAVE_FORMAT_MULAW) ) {
 
153
      mask1 = WAVE_FORMAT_FIX_BLOCK_ALIGN | WAVE_FORMAT_FIX_AVG_BPS;
 
154
      mmcWaveFormatFix((LPPCMWAVEFORMAT)(&sound_format), mask1 );
 
155
    }
 
156
 
 
157
    if ( sound_format.wave.wFormatTag == WAVE_FORMAT_IMA_ADPCM) {
 
158
      sizeBuffers = sound_format.wave.nBlockAlign;
 
159
      msBuffers = sizeBuffers * 1000 /
 
160
          (DIV_ROUND_UP_(AdpcmBitsPerSample,8) *
 
161
           sound_format.wave.nSamplesPerSec *
 
162
           sound_format.wave.nChannels);
 
163
 
 
164
 
 
165
    } else {
 
166
      if (!msBuffers && !sizeBuffers)
 
167
        msBuffers = 1000/numBuffers;
 
168
 
 
169
      if (msBuffers)
 
170
        sizeBuffers =
 
171
          ROUND_UP_(DIV_ROUND_UP_(msBuffers *
 
172
                                DIV_ROUND_UP_( sound_format.wave.wBitsPerSample,
 
173
                                              8) *
 
174
                                sound_format.wave.nSamplesPerSec *
 
175
                                sound_format.wave.nChannels,1000), BUFFER_PAD);
 
176
      else
 
177
        {
 
178
          sizeBuffers = ROUND_UP_(sizeBuffers, BUFFER_PAD);
 
179
          msBuffers = sizeBuffers * 1000 /
 
180
            (DIV_ROUND_UP_( sound_format.wave.wBitsPerSample,8) *
 
181
             sound_format.wave.nSamplesPerSec *
 
182
             sound_format.wave.nChannels);
 
183
        }
 
184
    }
 
185
 
 
186
 
 
187
    mmcVerboseDisplay(Verbose, "Buffer size = %d bytes or %d milliseconds",
 
188
                      sizeBuffers, msBuffers);
 
189
 
 
190
    hwaveout = NULL;
 
191
 
 
192
    status = mmcWaveOutOpen(&sound_format.wave, uDeviceId, &mmov_driver ,
 
193
                            WAVE_OPEN_SHAREABLE, &hwaveout);
 
194
 
 
195
    if (status != MMSYSERR_NOERROR)
 
196
     {
 
197
        mmov_cleanup();
 
198
        return;
 
199
     }
 
200
 
 
201
   if (mmcBuffersCreate (&mmov_buffer, numBuffers, sizeBuffers, BUFFER_PAD)
 
202
        != MMSYSERR_NOERROR)
 
203
     {
 
204
        mmov_cleanup();
 
205
        return;
 
206
     }
 
207
 
 
208
    while (1)
 
209
    {
 
210
        switch ( play_state )
 
211
        {
 
212
          case MMOV_START:
 
213
            break;
 
214
 
 
215
          case MMOV_PLAY:
 
216
            status = mmcWaveOutQueueBufferAll (hwaveout, &mmov_buffer, Verbose,
 
217
                                               &wavefilestatus, &allDone);
 
218
            if (allDone)
 
219
              play_state = MMOV_WAITING;
 
220
            else
 
221
             {
 
222
                if (status != MMSYSERR_NOERROR)
 
223
                  {
 
224
                     mmov_cleanup();
 
225
                     return;
 
226
                  }
 
227
             }
 
228
            break;
 
229
 
 
230
          case MMOV_WAITING:
 
231
            if ((mmcBufferFind(&mmov_buffer,Filling) != mmcBufferNone) ||
 
232
                (mmcBufferFind(&mmov_buffer,Full) != mmcBufferNone) ||
 
233
                (mmcBufferFind(&mmov_buffer,Playing) != mmcBufferNone))
 
234
              break;
 
235
            play_state = MMOV_CLOSE;
 
236
 
 
237
          case MMOV_CLOSE:
 
238
           status = mmcWaveOutClose (hwaveout, &mmov_buffer);
 
239
           if (status != MMSYSERR_NOERROR)
 
240
                  {
 
241
                     mmov_cleanup();
 
242
                     return;
 
243
                  }
 
244
            mmov_cleanup();
 
245
           return;
 
246
 
 
247
          default:
 
248
            mmcVerboseDisplay(Verbose,"Unknown play_state %d", play_state);
 
249
            mmov_cleanup();
 
250
           return;
 
251
        }
 
252
 
 
253
        mmeWaitForCallbacks (); /* block so we don't hog 100% of the CPU */
 
254
        mmeProcessCallbacks ();
 
255
    }
 
256
}