← Back to branch summary

~ubuntu-branches/ubuntu/vivid/oss4/vivid-proposed

« back to all changes in this revision

Viewing changes to .pc/301_libsalsa_fixes.patch/lib/libsalsa/timer.c

  • Committer: Package Import Robot
  • Author(s): Sebastien NOEL
  • Date: 2012-11-19 11:47:24 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20121119114724-svu8mq7x3pk64nez
Tags: 4.2-build2007-1
http://bugs.debian.org/630737
http://bugs.debian.org/687086
http://bugs.debian.org/628876
http://bugs.debian.org/675933
http://bugs.debian.org/693657
http://bugs.debian.org/693657
http://bugs.debian.org/587191
http://bugs.debian.org/653374
* New upstream release.
* Acknowledge NMU, thanks Michael Gilbert.
* Add debian/patches/110_ld-as-needed.patch: Rearrange order of linker
  arguments to fix building with "ld --as-needed" (closes: #630737).
* Add missing dependency on dpkg-dev to oss4-dkms and oss4-source
  (closes: #687086).
* Fix typo in the changelog (closes: #628876, #675933)
* Add debian/patches/002_fix-linux-oss_native_word.patch (closes: #693657).
  Thanks to Ben Hutchings.
* Add debian/patches/003_linux-error-logging-fixes.patch (closes: #693657).
  Thanks to Ben Hutchings.
* check for /lib/modules/${kernelver}/build in addition of
  /lib/modules/${kernelver}/source (closes: #587191).
* oss4-dkms.dkms.in: fix 'CLEAN' rules (closes: #653374).

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/301_libsalsa_fixes.patch/lib/libsalsa/timer.c
 
1
/*
 
2
 *  Copyright (c) 2004 by Hannu Savolainen < hannu@opensound.com>
 
3
 *
 
4
 *   This library is free software; you can redistribute it and/or modify
 
5
 *   it under the terms of the GNU Lesser General Public License version 2.1 as
 
6
 *   published by the Free Software Foundation.
 
7
 *
 
8
 *   This program is distributed in the hope that it will be useful,
 
9
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 *   GNU Lesser General Public License for more details.
 
12
 *
 
13
 *   You should have received a copy of the GNU Lesser General Public
 
14
 *   License along with this library; if not, write to the Free Software
 
15
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 
16
 *
 
17
 */
 
18
#include <stdio.h>
 
19
#include "local.h"
 
20
 
 
21
struct _snd_timer
 
22
{
 
23
  int dummy;
 
24
};
 
25
 
 
26
struct _snd_timer_id
 
27
{
 
28
  int dummy;
 
29
};
 
30
 
 
31
struct _snd_timer_info
 
32
{
 
33
  int dummy;
 
34
};
 
35
 
 
36
/**
 
37
 * \brief Opens a new connection to the timer interface.
 
38
 * \param timer Returned handle (NULL if not wanted)
 
39
 * \param name ASCII identifier of the timer handle
 
40
 * \param mode Open mode
 
41
 * \return 0 on success otherwise a negative error code
 
42
 *
 
43
 * Opens a new connection to the timer interface specified with
 
44
 * an ASCII identifier and mode.
 
45
 */
 
46
int
 
47
snd_timer_open (snd_timer_t ** tmr, const char *name, int mode)
 
48
{
 
49
  snd_timer_t *timer;
 
50
 
 
51
  ALIB_INIT ();
 
52
  if (!alib_appcheck ())
 
53
    {
 
54
      dbg_printf ("snd_timer_open(%s, %x) refused,\n", name, mode);
 
55
      return -ENODEV;
 
56
    }
 
57
 
 
58
  timer = malloc (sizeof (*timer));
 
59
 
 
60
  dbg_printf ("snd_timer_open(name='%s', mode=%x)=%x\n", name, mode, timer);
 
61
 
 
62
  if (timer == NULL)
 
63
    return -ENOMEM;
 
64
 
 
65
  *tmr = timer;
 
66
 
 
67
  return 0;
 
68
}
 
69
 
 
70
/**
 
71
 * \brief close timer handle
 
72
 * \param timer timer handle
 
73
 * \return 0 on success otherwise a negative error code
 
74
 *
 
75
 * Closes the specified timer handle and frees all associated
 
76
 * resources.
 
77
 */
 
78
int
 
79
snd_timer_close (snd_timer_t * timer)
 
80
{
 
81
  dbg_printf ("snd_timer_close(%x)\n", timer);
 
82
 
 
83
  free (timer);
 
84
  return 0;
 
85
}
 
86
 
 
87
/**
 
88
 * \brief get size of the snd_timer_id_t structure in bytes
 
89
 * \return size of the snd_timer_id_t structure in bytes
 
90
 */
 
91
size_t
 
92
snd_timer_id_sizeof ()
 
93
{
 
94
  return sizeof (snd_timer_id_t);
 
95
}
 
96
 
 
97
/**
 
98
 * \brief get timer card
 
99
 * \param params pointer to #snd_timer_id_t structure
 
100
 * \return timer card number
 
101
 */
 
102
int
 
103
snd_timer_id_get_card (snd_timer_id_t * tid)
 
104
{
 
105
  dbg_printf ("snd_timer_id_get_card(tid=%x)\n", tid);
 
106
 
 
107
  return 0;                     // TODO
 
108
}
 
109
 
 
110
/**
 
111
 * \brief get timer class
 
112
 * \param tid pointer to #snd_timer_id_t structure
 
113
 * \return timer class
 
114
 */
 
115
int
 
116
snd_timer_id_get_class (snd_timer_id_t * tid)
 
117
{
 
118
  dbg_printf ("snd_timer_id_get_class(tid=%x)\n", tid);
 
119
 
 
120
  return 0;                     // TODO
 
121
}
 
122
 
 
123
 
 
124
/**
 
125
 * \brief get timer device
 
126
 * \param params pointer to #snd_timer_id_t structure
 
127
 * \return timer device number
 
128
 */
 
129
int
 
130
snd_timer_id_get_device (snd_timer_id_t * tid)
 
131
{
 
132
  dbg_printf ("snd_timer_id_get_device(tid=%x)\n", tid);
 
133
 
 
134
  return 0;                     // TODO
 
135
}
 
136
 
 
137
/**
 
138
 * \brief get timer sub-class
 
139
 * \param params pointer to #snd_timer_id_t structure
 
140
 * \return timer sub-class
 
141
 */
 
142
int
 
143
snd_timer_id_get_sclass (snd_timer_id_t * tid)
 
144
{
 
145
  dbg_printf ("snd_timer_id_get_sclass(tid=%x)\n", tid);
 
146
 
 
147
  return 0;                     // TODO
 
148
}
 
149
 
 
150
/**
 
151
 * \brief get timer subdevice
 
152
 * \param params pointer to #snd_timer_id_t structure
 
153
 * \return timer subdevice number
 
154
 */
 
155
int
 
156
snd_timer_id_get_subdevice (snd_timer_id_t * tid)
 
157
{
 
158
  dbg_printf ("snd_timer_id_get_subdevice(tid=%x)\n", tid);
 
159
 
 
160
  return 0;                     // TODO
 
161
}
 
162
 
 
163
/**
 
164
 * \brief set timer card
 
165
 * \param tid pointer to #snd_timer_id_t structure
 
166
 * \param card card number
 
167
 */
 
168
void
 
169
snd_timer_id_set_card (snd_timer_id_t * tid, int card)
 
170
{
 
171
  dbg_printf ("snd_timer_id_set_card(tid=%x, card=%d)\n", tid, card);
 
172
 
 
173
  // TODO
 
174
}
 
175
 
 
176
/**
 
177
 * \brief set timer class
 
178
 * \param tid pointer to #snd_timer_id_t structure
 
179
 * \param dev_class class of timer device
 
180
 */
 
181
void
 
182
snd_timer_id_set_class (snd_timer_id_t * tid, int dev_class)
 
183
{
 
184
  dbg_printf ("snd_timer_id_set_class(tid=%x, dev_class=%d)\n", tid,
 
185
              dev_class);
 
186
  // TODO
 
187
}
 
188
 
 
189
/**
 
190
 * \brief set timer device
 
191
 * \param tid pointer to #snd_timer_id_t structure
 
192
 * \param device device number
 
193
 */
 
194
void
 
195
snd_timer_id_set_device (snd_timer_id_t * tid, int device)
 
196
{
 
197
  dbg_printf ("snd_timer_id_set_device(tid=%x, device=%d)\n", tid, device);
 
198
 
 
199
  // TODO
 
200
}
 
201
 
 
202
/**
 
203
 * \brief set timer sub-class
 
204
 * \param tid pointer to #snd_timer_id_t structure
 
205
 * \param dev_sclass sub-class of timer device
 
206
 */
 
207
void
 
208
snd_timer_id_set_sclass (snd_timer_id_t * tid, int dev_sclass)
 
209
{
 
210
  dbg_printf ("snd_timer_id_set_sclass(tid=%x, dev_sclass=%d)\n",
 
211
              tid, dev_sclass);
 
212
  // TODO
 
213
}
 
214
 
 
215
/**
 
216
 * \brief set timer subdevice
 
217
 * \param tid pointer to #snd_timer_id_t structure
 
218
 * \param subdevice subdevice number
 
219
 */
 
220
void
 
221
snd_timer_id_set_subdevice (snd_timer_id_t * tid, int subdevice)
 
222
{
 
223
  dbg_printf ("snd_timer_id_set_subdevice(tid=%x, subdevice=%d)\n",
 
224
              tid, subdevice);
 
225
 
 
226
  // TODO
 
227
}
 
228
 
 
229
/**
 
230
 * \brief get size of the snd_timer_info_t structure in bytes
 
231
 * \return size of the snd_timer_info_t structure in bytes
 
232
 */
 
233
size_t
 
234
snd_timer_info_sizeof ()
 
235
{
 
236
  return sizeof (snd_timer_info_t);
 
237
}
 
238
 
 
239
/**
 
240
 * \brief allocate a new snd_timer_info_t structure
 
241
 * \param ptr returned pointer
 
242
 * \return 0 on success otherwise a negative error code if fails
 
243
 *
 
244
 * Allocates a new snd_timer_info_t structure using the standard
 
245
 * malloc C library function.
 
246
 */
 
247
int
 
248
snd_timer_info_malloc (snd_timer_info_t ** info)
 
249
{
 
250
  *info = calloc (1, sizeof (snd_timer_info_t));
 
251
  dbg_printf ("snd_timer_info_malloc()=%x\n", *info);
 
252
  if (!*info)
 
253
    return -ENOMEM;
 
254
  return 0;
 
255
}
 
256
 
 
257
/**
 
258
 * \brief frees the snd_timer_info_t structure
 
259
 * \param info pointer to the snd_timer_info_t structure to free
 
260
 *
 
261
 * Frees the given snd_timer_info_t structure using the standard
 
262
 * free C library function.
 
263
 */
 
264
void
 
265
snd_timer_info_free (snd_timer_info_t * info)
 
266
{
 
267
  dbg_printf ("snd_timer_info_free(%x)\n", info);
 
268
  free (info);
 
269
}
 
270
 
 
271
/**
 
272
 * \brief get information about timer handle
 
273
 * \param timer timer handle
 
274
 * \param info pointer to a snd_timer_info_t structure to be filled
 
275
 * \return 0 on success otherwise a negative error code
 
276
 */
 
277
int
 
278
snd_timer_info (snd_timer_t * timer, snd_timer_info_t * info)
 
279
{
 
280
  dbg_printf ("snd_timer_info(timer=%x, info=%x)\n", timer, info);
 
281
 
 
282
  // TODO
 
283
 
 
284
  return 0;
 
285
}
 
286
 
 
287
/**
 
288
 * \brief get timer name
 
289
 * \param info pointer to #snd_timer_info_t structure
 
290
 * \return timer name
 
291
 */
 
292
const char *
 
293
snd_timer_info_get_name (snd_timer_info_t * info)
 
294
{
 
295
  dbg_printf ("snd_timer_info_get_name(info=%x)\n", info);
 
296
 
 
297
  return "OSS Timer";           // TODO
 
298
}
 
299
 
 
300
 
 
301
/**
 
302
 * \brief get timer resolution in us
 
303
 * \param info pointer to #snd_timer_info_t structure
 
304
 * \return timer resolution
 
305
 */
 
306
long
 
307
snd_timer_info_get_resolution (snd_timer_info_t * info)
 
308
{
 
309
  dbg_printf ("snd_timer_info_get_resolution(info=%x)\n", info);
 
310
 
 
311
  return 1000;                  // TODO
 
312
}
 
313
 
 
314
 
 
315
static int
 
316
snd_timer_query_open_conf (snd_timer_query_t ** timer,
 
317
                           const char *name, snd_config_t * timer_root,
 
318
                           snd_config_t * timer_conf, int mode)
 
319
{
 
320
  dbg_printf
 
321
    ("snd_timer_query_open_conf(name='%s', root=%x, conf=%x, mode=%x)\n",
 
322
     name, timer_root, timer_conf, mode);
 
323
  ALIB_INIT ();
 
324
  if (!alib_appcheck ())
 
325
    return -ENODEV;
 
326
 
 
327
  return -EIO;
 
328
}
 
329
 
 
330
/**
 
331
 * \brief close timer query handle
 
332
 * \param timer timer handle
 
333
 * \return 0 on success otherwise a negative error code
 
334
 *
 
335
 * Closes the specified timer handle and frees all associated
 
336
 * resources.
 
337
 */
 
338
int
 
339
snd_timer_query_close (snd_timer_query_t * timer)
 
340
{
 
341
  dbg_printf ("snd_timer_query_close(timer=%x)\n", timer);
 
342
 
 
343
  return 0;
 
344
}
 
345
 
 
346
/**
 
347
 * \brief obtain the next timer identification
 
348
 * \param timer timer handle
 
349
 * \param tid timer identification
 
350
 * \return 0 on success otherwise a negative error code
 
351
 *
 
352
 * if tid->dev_class is -1, then the first device is returned
 
353
 * if result tid->dev_class is -1, no more devices are left
 
354
 */
 
355
int
 
356
snd_timer_query_next_device (snd_timer_query_t * timer, snd_timer_id_t * tid)
 
357
{
 
358
  dbg_printf ("snd_timer_query_next_device(timer=%x, tid=%x)\n", timer, tid);
 
359
 
 
360
  return -1;
 
361
}