← Back to branch summary

~broder/ubuntu/natty/gst-plugins-base0.10/perlsectomy

« back to all changes in this revision

Viewing changes to ext/vorbis/gstvorbisdeclib.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2010-06-26 21:12:29 UTC
  • mfrom: (11.5.1 upstream) (33.1.6 sid)
  • Revision ID: james.westby@ubuntu.com-20100626211229-0k34egbnd2octtpv
Tags: 0.10.29.2-1
* New upstream pre-release:
  + debian/rules,
    debian/compat,
    debian/control.in,
    debian/source/format,
    debian/patches/*:
    - Update to debhelper compat level 7.
    - Update to source format 3.0 (quilt).
    - Update to Standards-Version 3.8.4.
  + debian/build-deps.in,
    debian/rules:
    - Build depend on GLib 2.20 and GStreamer 0.10.29.2.
    - Build depend on ORC instead of liboil.
  + debian/patches/00*:
    - Dropped, merged upstream.
  + debian/libgstreamer-plugins-base.symbols:
    - Update symbols file with the new API.
  + debian/patches/01_videotestsrc-libm-linking.patch,
    debian/patches/02_videoscale-libm-linking.patch:
    - Link videotestsrc and videoscale with libm to fix FTBFS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/vorbis/gstvorbisdeclib.c
26
26
#include "config.h"
27
27
#endif
28
28
 
 
29
#include <string.h>
29
30
#include "gstvorbisdeclib.h"
30
31
 
31
32
#ifndef TREMOR
32
33
/* These samples can be outside of the float -1.0 -- 1.0 range, this
33
34
 * is allowed, downstream elements are supposed to clip */
34
 
void
 
35
static void
 
36
copy_samples_m (vorbis_sample_t * out, vorbis_sample_t ** in, guint samples,
 
37
    gint channels, gint width)
 
38
{
 
39
  memcpy (out, in[0], samples * sizeof (float));
 
40
}
 
41
 
 
42
static void
 
43
copy_samples_s (vorbis_sample_t * out, vorbis_sample_t ** in, guint samples,
 
44
    gint channels, gint width)
 
45
{
 
46
#ifdef GST_VORBIS_DEC_SEQUENTIAL
 
47
  memcpy (out, in[0], samples * sizeof (float));
 
48
  out += samples;
 
49
  memcpy (out, in[1], samples * sizeof (float));
 
50
#else
 
51
  gint j;
 
52
 
 
53
  for (j = 0; j < samples; j++) {
 
54
    *out++ = in[0][j];
 
55
    *out++ = in[1][j];
 
56
  }
 
57
#endif
 
58
}
 
59
 
 
60
static void
35
61
copy_samples (vorbis_sample_t * out, vorbis_sample_t ** in, guint samples,
36
62
    gint channels, gint width)
37
63
{
38
 
  gint i, j;
39
 
 
40
 
  g_assert (width == 4);
41
 
 
42
64
#ifdef GST_VORBIS_DEC_SEQUENTIAL
 
65
  gint i;
 
66
 
43
67
  for (i = 0; i < channels; i++) {
44
68
    memcpy (out, in[i], samples * sizeof (float));
45
69
    out += samples;
46
70
  }
47
71
#else
 
72
  gint i, j;
 
73
 
48
74
  for (j = 0; j < samples; j++) {
49
75
    for (i = 0; i < channels; i++) {
50
76
      *out++ = in[i][j];
53
79
#endif
54
80
}
55
81
 
 
82
CopySampleFunc
 
83
get_copy_sample_func (gint channels, gint width)
 
84
{
 
85
  CopySampleFunc f = NULL;
 
86
 
 
87
  g_assert (width == 4);
 
88
 
 
89
  switch (channels) {
 
90
    case 1:
 
91
      f = copy_samples_m;
 
92
      break;
 
93
    case 2:
 
94
      f = copy_samples_s;
 
95
      break;
 
96
    default:
 
97
      f = copy_samples;
 
98
      break;
 
99
  }
 
100
 
 
101
  return f;
 
102
}
 
103
 
56
104
#else
57
105
 
58
106
/* Taken from Tremor, misc.h */
83
131
#endif
84
132
 
85
133
static void
86
 
copy_samples_32 (gint32 * out, ogg_int32_t ** in, guint samples, gint channels)
87
 
{
88
 
  gint i, j;
89
 
 
90
 
  for (j = 0; j < samples; j++) {
91
 
    for (i = 0; i < channels; i++) {
92
 
      *out++ = CLIP_TO_15 (in[i][j] >> 9);
93
 
    }
94
 
  }
95
 
}
96
 
 
97
 
static void
98
 
copy_samples_16 (gint16 * out, ogg_int32_t ** in, guint samples, gint channels)
99
 
{
100
 
  gint i, j;
101
 
 
102
 
  for (j = 0; j < samples; j++) {
103
 
    for (i = 0; i < channels; i++) {
104
 
      *out++ = CLIP_TO_15 (in[i][j] >> 9);
105
 
    }
106
 
  }
107
 
}
108
 
 
109
 
void
110
 
copy_samples (vorbis_sample_t * out, vorbis_sample_t ** in, guint samples,
111
 
    gint channels, gint width)
112
 
{
 
134
copy_samples_32_m (vorbis_sample_t * _out, vorbis_sample_t ** _in,
 
135
    guint samples, gint channels, gint width)
 
136
{
 
137
  gint32 *out = (gint32 *) _out;
 
138
  ogg_int32_t **in = (ogg_int32_t **) _in;
 
139
  gint j;
 
140
 
 
141
  for (j = 0; j < samples; j++) {
 
142
    *out++ = CLIP_TO_15 (in[0][j] >> 9);
 
143
  }
 
144
}
 
145
 
 
146
static void
 
147
copy_samples_32_s (vorbis_sample_t * _out, vorbis_sample_t ** _in,
 
148
    guint samples, gint channels, gint width)
 
149
{
 
150
  gint32 *out = (gint32 *) _out;
 
151
  ogg_int32_t **in = (ogg_int32_t **) _in;
 
152
  gint j;
 
153
 
 
154
  for (j = 0; j < samples; j++) {
 
155
    *out++ = CLIP_TO_15 (in[0][j] >> 9);
 
156
    *out++ = CLIP_TO_15 (in[1][j] >> 9);
 
157
  }
 
158
}
 
159
 
 
160
static void
 
161
copy_samples_32 (vorbis_sample_t * _out, vorbis_sample_t ** _in, guint samples,
 
162
    gint channels, gint width)
 
163
{
 
164
  gint32 *out = (gint32 *) _out;
 
165
  ogg_int32_t **in = (ogg_int32_t **) _in;
 
166
  gint i, j;
 
167
 
 
168
  for (j = 0; j < samples; j++) {
 
169
    for (i = 0; i < channels; i++) {
 
170
      *out++ = CLIP_TO_15 (in[i][j] >> 9);
 
171
    }
 
172
  }
 
173
}
 
174
 
 
175
static void
 
176
copy_samples_16_m (vorbis_sample_t * _out, vorbis_sample_t ** _in,
 
177
    guint samples, gint channels, gint width)
 
178
{
 
179
  gint16 *out = (gint16 *) _out;
 
180
  ogg_int32_t **in = (ogg_int32_t **) _in;
 
181
  gint j;
 
182
 
 
183
  for (j = 0; j < samples; j++) {
 
184
    *out++ = CLIP_TO_15 (in[0][j] >> 9);
 
185
  }
 
186
}
 
187
 
 
188
static void
 
189
copy_samples_16_s (vorbis_sample_t * _out, vorbis_sample_t ** _in,
 
190
    guint samples, gint channels, gint width)
 
191
{
 
192
  gint16 *out = (gint16 *) _out;
 
193
  ogg_int32_t **in = (ogg_int32_t **) _in;
 
194
  gint j;
 
195
 
 
196
  for (j = 0; j < samples; j++) {
 
197
    *out++ = CLIP_TO_15 (in[0][j] >> 9);
 
198
    *out++ = CLIP_TO_15 (in[1][j] >> 9);
 
199
  }
 
200
}
 
201
 
 
202
static void
 
203
copy_samples_16 (vorbis_sample_t * _out, vorbis_sample_t ** _in, guint samples,
 
204
    gint channels, gint width)
 
205
{
 
206
  gint16 *out = (gint16 *) _out;
 
207
  ogg_int32_t **in = (ogg_int32_t **) _in;
 
208
  gint i, j;
 
209
 
 
210
  for (j = 0; j < samples; j++) {
 
211
    for (i = 0; i < channels; i++) {
 
212
      *out++ = CLIP_TO_15 (in[i][j] >> 9);
 
213
    }
 
214
  }
 
215
}
 
216
 
 
217
CopySampleFunc
 
218
get_copy_sample_func (gint channels, gint width)
 
219
{
 
220
  CopySampleFunc f = NULL;
 
221
 
113
222
  if (width == 4) {
114
 
    copy_samples_32 ((gint32 *) out, in, samples, channels);
 
223
    switch (channels) {
 
224
      case 1:
 
225
        f = copy_samples_32_m;
 
226
        break;
 
227
      case 2:
 
228
        f = copy_samples_32_s;
 
229
        break;
 
230
      default:
 
231
        f = copy_samples_32;
 
232
        break;
 
233
    }
115
234
  } else if (width == 2) {
116
 
    copy_samples_16 ((gint16 *) out, in, samples, channels);
 
235
    switch (channels) {
 
236
      case 1:
 
237
        f = copy_samples_16_m;
 
238
        break;
 
239
      case 2:
 
240
        f = copy_samples_16_s;
 
241
        break;
 
242
      default:
 
243
        f = copy_samples_16;
 
244
        break;
 
245
    }
117
246
  } else {
118
247
    g_assert_not_reached ();
119
248
  }
 
249
  return f;
120
250
}
121
251
 
122
252
#endif