/[pcsx2_0.9.7]/trunk/3rdparty/liba52/downmix.c
ViewVC logotype

Annotation of /trunk/3rdparty/liba52/downmix.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 8 - (hide annotations) (download)
Mon Sep 6 11:19:43 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 16423 byte(s)
Exported ./upsream/trunk @r3730 from http://pcsx2.googlecode.com/svn/trunk/
1 william 8 /*
2     * downmix.c
3     * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
4     * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
5     *
6     * This file is part of a52dec, a free ATSC A-52 stream decoder.
7     * See http://liba52.sourceforge.net/ for updates.
8     *
9     * a52dec is free software; you can redistribute it and/or modify
10     * it under the terms of the GNU General Public License as published by
11     * the Free Software Foundation; either version 2 of the License, or
12     * (at your option) any later version.
13     *
14     * a52dec is distributed in the hope that it will be useful,
15     * but WITHOUT ANY WARRANTY; without even the implied warranty of
16     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17     * GNU General Public License for more details.
18     *
19     * You should have received a copy of the GNU General Public License
20     * along with this program; if not, write to the Free Software
21     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22     */
23     #pragma warning(disable:4244)
24     #include "config.h"
25    
26     #include <string.h>
27     #include "inttypes.h"
28    
29     #include "a52.h"
30     #include "a52_internal.h"
31    
32     #define CONVERT(acmod,output) (((output) << 3) + (acmod))
33    
34     int a52_downmix_init (int input, int flags, sample_t * level,
35     sample_t clev, sample_t slev)
36     {
37     static uint8_t table[11][8] = {
38     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
39     A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO},
40     {A52_MONO, A52_MONO, A52_MONO, A52_MONO,
41     A52_MONO, A52_MONO, A52_MONO, A52_MONO},
42     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
43     A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO},
44     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F,
45     A52_STEREO, A52_3F, A52_STEREO, A52_3F},
46     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
47     A52_2F1R, A52_2F1R, A52_2F1R, A52_2F1R},
48     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
49     A52_2F1R, A52_3F1R, A52_2F1R, A52_3F1R},
50     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F,
51     A52_2F2R, A52_2F2R, A52_2F2R, A52_2F2R},
52     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F,
53     A52_2F2R, A52_3F2R, A52_2F2R, A52_3F2R},
54     {A52_CHANNEL1, A52_MONO, A52_MONO, A52_MONO,
55     A52_MONO, A52_MONO, A52_MONO, A52_MONO},
56     {A52_CHANNEL2, A52_MONO, A52_MONO, A52_MONO,
57     A52_MONO, A52_MONO, A52_MONO, A52_MONO},
58     {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_DOLBY,
59     A52_DOLBY, A52_DOLBY, A52_DOLBY, A52_DOLBY}
60     };
61     int output;
62    
63     output = flags & A52_CHANNEL_MASK;
64     if (output > A52_DOLBY)
65     return -1;
66    
67     output = table[output][input & 7];
68    
69     if ((output == A52_STEREO) &&
70     ((input == A52_DOLBY) || ((input == A52_3F) && (clev == LEVEL_3DB))))
71     output = A52_DOLBY;
72    
73     if (flags & A52_ADJUST_LEVEL)
74     switch (CONVERT (input & 7, output)) {
75    
76     case CONVERT (A52_3F, A52_MONO):
77     *level *= LEVEL_3DB / (1 + clev);
78     break;
79    
80     case CONVERT (A52_STEREO, A52_MONO):
81     case CONVERT (A52_2F2R, A52_2F1R):
82     case CONVERT (A52_3F2R, A52_3F1R):
83     level_3db:
84     *level *= LEVEL_3DB;
85     break;
86    
87     case CONVERT (A52_3F2R, A52_2F1R):
88     if (clev < LEVEL_PLUS3DB - 1)
89     goto level_3db;
90     /* break thru */
91     case CONVERT (A52_3F, A52_STEREO):
92     case CONVERT (A52_3F1R, A52_2F1R):
93     case CONVERT (A52_3F1R, A52_2F2R):
94     case CONVERT (A52_3F2R, A52_2F2R):
95     *level /= 1 + clev;
96     break;
97    
98     case CONVERT (A52_2F1R, A52_MONO):
99     *level *= LEVEL_PLUS3DB / (2 + slev);
100     break;
101    
102     case CONVERT (A52_2F1R, A52_STEREO):
103     case CONVERT (A52_3F1R, A52_3F):
104     *level /= 1 + slev * LEVEL_3DB;
105     break;
106    
107     case CONVERT (A52_3F1R, A52_MONO):
108     *level *= LEVEL_3DB / (1 + clev + 0.5 * slev);
109     break;
110    
111     case CONVERT (A52_3F1R, A52_STEREO):
112     *level /= 1 + clev + slev * LEVEL_3DB;
113     break;
114    
115     case CONVERT (A52_2F2R, A52_MONO):
116     *level *= LEVEL_3DB / (1 + slev);
117     break;
118    
119     case CONVERT (A52_2F2R, A52_STEREO):
120     case CONVERT (A52_3F2R, A52_3F):
121     *level /= 1 + slev;
122     break;
123    
124     case CONVERT (A52_3F2R, A52_MONO):
125     *level *= LEVEL_3DB / (1 + clev + slev);
126     break;
127    
128     case CONVERT (A52_3F2R, A52_STEREO):
129     *level /= 1 + clev + slev;
130     break;
131    
132     case CONVERT (A52_MONO, A52_DOLBY):
133     *level *= LEVEL_PLUS3DB;
134     break;
135    
136     case CONVERT (A52_3F, A52_DOLBY):
137     case CONVERT (A52_2F1R, A52_DOLBY):
138     *level *= 1 / (1 + LEVEL_3DB);
139     break;
140    
141     case CONVERT (A52_3F1R, A52_DOLBY):
142     case CONVERT (A52_2F2R, A52_DOLBY):
143     *level *= 1 / (1 + 2 * LEVEL_3DB);
144     break;
145    
146     case CONVERT (A52_3F2R, A52_DOLBY):
147     *level *= 1 / (1 + 3 * LEVEL_3DB);
148     break;
149     }
150    
151     return output;
152     }
153    
154     int a52_downmix_coeff (sample_t * coeff, int acmod, int output, sample_t level,
155     sample_t clev, sample_t slev)
156     {
157     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
158    
159     case CONVERT (A52_CHANNEL, A52_CHANNEL):
160     case CONVERT (A52_MONO, A52_MONO):
161     case CONVERT (A52_STEREO, A52_STEREO):
162     case CONVERT (A52_3F, A52_3F):
163     case CONVERT (A52_2F1R, A52_2F1R):
164     case CONVERT (A52_3F1R, A52_3F1R):
165     case CONVERT (A52_2F2R, A52_2F2R):
166     case CONVERT (A52_3F2R, A52_3F2R):
167     case CONVERT (A52_STEREO, A52_DOLBY):
168     coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
169     return 0;
170    
171     case CONVERT (A52_CHANNEL, A52_MONO):
172     coeff[0] = coeff[1] = level * LEVEL_6DB;
173     return 3;
174    
175     case CONVERT (A52_STEREO, A52_MONO):
176     coeff[0] = coeff[1] = level * LEVEL_3DB;
177     return 3;
178    
179     case CONVERT (A52_3F, A52_MONO):
180     coeff[0] = coeff[2] = level * LEVEL_3DB;
181     coeff[1] = level * clev * LEVEL_PLUS3DB;
182     return 7;
183    
184     case CONVERT (A52_2F1R, A52_MONO):
185     coeff[0] = coeff[1] = level * LEVEL_3DB;
186     coeff[2] = level * slev * LEVEL_3DB;
187     return 7;
188    
189     case CONVERT (A52_2F2R, A52_MONO):
190     coeff[0] = coeff[1] = level * LEVEL_3DB;
191     coeff[2] = coeff[3] = level * slev * LEVEL_3DB;
192     return 15;
193    
194     case CONVERT (A52_3F1R, A52_MONO):
195     coeff[0] = coeff[2] = level * LEVEL_3DB;
196     coeff[1] = level * clev * LEVEL_PLUS3DB;
197     coeff[3] = level * slev * LEVEL_3DB;
198     return 15;
199    
200     case CONVERT (A52_3F2R, A52_MONO):
201     coeff[0] = coeff[2] = level * LEVEL_3DB;
202     coeff[1] = level * clev * LEVEL_PLUS3DB;
203     coeff[3] = coeff[4] = level * slev * LEVEL_3DB;
204     return 31;
205    
206     case CONVERT (A52_MONO, A52_DOLBY):
207     coeff[0] = level * LEVEL_3DB;
208     return 0;
209    
210     case CONVERT (A52_3F, A52_DOLBY):
211     clev = LEVEL_3DB;
212     case CONVERT (A52_3F, A52_STEREO):
213     case CONVERT (A52_3F1R, A52_2F1R):
214     case CONVERT (A52_3F2R, A52_2F2R):
215     coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
216     coeff[1] = level * clev;
217     return 7;
218    
219     case CONVERT (A52_2F1R, A52_DOLBY):
220     slev = 1;
221     case CONVERT (A52_2F1R, A52_STEREO):
222     coeff[0] = coeff[1] = level;
223     coeff[2] = level * slev * LEVEL_3DB;
224     return 7;
225    
226     case CONVERT (A52_3F1R, A52_DOLBY):
227     clev = LEVEL_3DB;
228     slev = 1;
229     case CONVERT (A52_3F1R, A52_STEREO):
230     coeff[0] = coeff[2] = level;
231     coeff[1] = level * clev;
232     coeff[3] = level * slev * LEVEL_3DB;
233     return 15;
234    
235     case CONVERT (A52_2F2R, A52_DOLBY):
236     slev = LEVEL_3DB;
237     case CONVERT (A52_2F2R, A52_STEREO):
238     coeff[0] = coeff[1] = level;
239     coeff[2] = coeff[3] = level * slev;
240     return 15;
241    
242     case CONVERT (A52_3F2R, A52_DOLBY):
243     clev = LEVEL_3DB;
244     case CONVERT (A52_3F2R, A52_2F1R):
245     slev = LEVEL_3DB;
246     case CONVERT (A52_3F2R, A52_STEREO):
247     coeff[0] = coeff[2] = level;
248     coeff[1] = level * clev;
249     coeff[3] = coeff[4] = level * slev;
250     return 31;
251    
252     case CONVERT (A52_3F1R, A52_3F):
253     coeff[0] = coeff[1] = coeff[2] = level;
254     coeff[3] = level * slev * LEVEL_3DB;
255     return 13;
256    
257     case CONVERT (A52_3F2R, A52_3F):
258     coeff[0] = coeff[1] = coeff[2] = level;
259     coeff[3] = coeff[4] = level * slev;
260     return 29;
261    
262     case CONVERT (A52_2F2R, A52_2F1R):
263     coeff[0] = coeff[1] = level;
264     coeff[2] = coeff[3] = level * LEVEL_3DB;
265     return 12;
266    
267     case CONVERT (A52_3F2R, A52_3F1R):
268     coeff[0] = coeff[1] = coeff[2] = level;
269     coeff[3] = coeff[4] = level * LEVEL_3DB;
270     return 24;
271    
272     case CONVERT (A52_2F1R, A52_2F2R):
273     coeff[0] = coeff[1] = level;
274     coeff[2] = level * LEVEL_3DB;
275     return 0;
276    
277     case CONVERT (A52_3F1R, A52_2F2R):
278     coeff[0] = coeff[2] = level;
279     coeff[1] = level * clev;
280     coeff[3] = level * LEVEL_3DB;
281     return 7;
282    
283     case CONVERT (A52_3F1R, A52_3F2R):
284     coeff[0] = coeff[1] = coeff[2] = level;
285     coeff[3] = level * LEVEL_3DB;
286     return 0;
287    
288     case CONVERT (A52_CHANNEL, A52_CHANNEL1):
289     coeff[0] = level;
290     coeff[1] = 0;
291     return 0;
292    
293     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
294     coeff[0] = 0;
295     coeff[1] = level;
296     return 0;
297     }
298    
299     return -1; /* NOTREACHED */
300     }
301    
302     static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
303     {
304     int i;
305    
306     for (i = 0; i < 256; i++)
307     dest[i] += src[i] + bias;
308     }
309    
310     static void mix3to1 (sample_t * samples, sample_t bias)
311     {
312     int i;
313    
314     for (i = 0; i < 256; i++)
315     samples[i] += samples[i + 256] + samples[i + 512] + bias;
316     }
317    
318     static void mix4to1 (sample_t * samples, sample_t bias)
319     {
320     int i;
321    
322     for (i = 0; i < 256; i++)
323     samples[i] += (samples[i + 256] + samples[i + 512] +
324     samples[i + 768] + bias);
325     }
326    
327     static void mix5to1 (sample_t * samples, sample_t bias)
328     {
329     int i;
330    
331     for (i = 0; i < 256; i++)
332     samples[i] += (samples[i + 256] + samples[i + 512] +
333     samples[i + 768] + samples[i + 1024] + bias);
334     }
335    
336     static void mix3to2 (sample_t * samples, sample_t bias)
337     {
338     int i;
339     sample_t common;
340    
341     for (i = 0; i < 256; i++) {
342     common = samples[i + 256] + bias;
343     samples[i] += common;
344     samples[i + 256] = samples[i + 512] + common;
345     }
346     }
347    
348     static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
349     {
350     int i;
351     sample_t common;
352    
353     for (i = 0; i < 256; i++) {
354     common = right[i + 256] + bias;
355     left[i] += common;
356     right[i] += common;
357     }
358     }
359    
360     static void mix21toS (sample_t * samples, sample_t bias)
361     {
362     int i;
363     sample_t surround;
364    
365     for (i = 0; i < 256; i++) {
366     surround = samples[i + 512];
367     samples[i] += bias - surround;
368     samples[i + 256] += bias + surround;
369     }
370     }
371    
372     static void mix31to2 (sample_t * samples, sample_t bias)
373     {
374     int i;
375     sample_t common;
376    
377     for (i = 0; i < 256; i++) {
378     common = samples[i + 256] + samples[i + 768] + bias;
379     samples[i] += common;
380     samples[i + 256] = samples[i + 512] + common;
381     }
382     }
383    
384     static void mix31toS (sample_t * samples, sample_t bias)
385     {
386     int i;
387     sample_t common, surround;
388    
389     for (i = 0; i < 256; i++) {
390     common = samples[i + 256] + bias;
391     surround = samples[i + 768];
392     samples[i] += common - surround;
393     samples[i + 256] = samples[i + 512] + common + surround;
394     }
395     }
396    
397     static void mix22toS (sample_t * samples, sample_t bias)
398     {
399     int i;
400     sample_t surround;
401    
402     for (i = 0; i < 256; i++) {
403     surround = samples[i + 512] + samples[i + 768];
404     samples[i] += bias - surround;
405     samples[i + 256] += bias + surround;
406     }
407     }
408    
409     static void mix32to2 (sample_t * samples, sample_t bias)
410     {
411     int i;
412     sample_t common;
413    
414     for (i = 0; i < 256; i++) {
415     common = samples[i + 256] + bias;
416     samples[i] += common + samples[i + 768];
417     samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
418     }
419     }
420    
421     static void mix32toS (sample_t * samples, sample_t bias)
422     {
423     int i;
424     sample_t common, surround;
425    
426     for (i = 0; i < 256; i++) {
427     common = samples[i + 256] + bias;
428     surround = samples[i + 768] + samples[i + 1024];
429     samples[i] += common - surround;
430     samples[i + 256] = samples[i + 512] + common + surround;
431     }
432     }
433    
434     static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
435     {
436     int i;
437    
438     for (i = 0; i < 256; i++)
439     dest[i] = src[i] + src[i + 256] + bias;
440     }
441    
442     static void zero (sample_t * samples)
443     {
444     int i;
445    
446     for (i = 0; i < 256; i++)
447     samples[i] = 0;
448     }
449    
450     void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
451     sample_t clev, sample_t slev)
452     {
453     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
454    
455     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
456     memcpy (samples, samples + 256, 256 * sizeof (sample_t));
457     break;
458    
459     case CONVERT (A52_CHANNEL, A52_MONO):
460     case CONVERT (A52_STEREO, A52_MONO):
461     mix_2to1:
462     mix2to1 (samples, samples + 256, bias);
463     break;
464    
465     case CONVERT (A52_2F1R, A52_MONO):
466     if (slev == 0)
467     goto mix_2to1;
468     case CONVERT (A52_3F, A52_MONO):
469     mix_3to1:
470     mix3to1 (samples, bias);
471     break;
472    
473     case CONVERT (A52_3F1R, A52_MONO):
474     if (slev == 0)
475     goto mix_3to1;
476     case CONVERT (A52_2F2R, A52_MONO):
477     if (slev == 0)
478     goto mix_2to1;
479     mix4to1 (samples, bias);
480     break;
481    
482     case CONVERT (A52_3F2R, A52_MONO):
483     if (slev == 0)
484     goto mix_3to1;
485     mix5to1 (samples, bias);
486     break;
487    
488     case CONVERT (A52_MONO, A52_DOLBY):
489     memcpy (samples + 256, samples, 256 * sizeof (sample_t));
490     break;
491    
492     case CONVERT (A52_3F, A52_STEREO):
493     case CONVERT (A52_3F, A52_DOLBY):
494     mix_3to2:
495     mix3to2 (samples, bias);
496     break;
497    
498     case CONVERT (A52_2F1R, A52_STEREO):
499     if (slev == 0)
500     break;
501     mix21to2 (samples, samples + 256, bias);
502     break;
503    
504     case CONVERT (A52_2F1R, A52_DOLBY):
505     mix21toS (samples, bias);
506     break;
507    
508     case CONVERT (A52_3F1R, A52_STEREO):
509     if (slev == 0)
510     goto mix_3to2;
511     mix31to2 (samples, bias);
512     break;
513    
514     case CONVERT (A52_3F1R, A52_DOLBY):
515     mix31toS (samples, bias);
516     break;
517    
518     case CONVERT (A52_2F2R, A52_STEREO):
519     if (slev == 0)
520     break;
521     mix2to1 (samples, samples + 512, bias);
522     mix2to1 (samples + 256, samples + 768, bias);
523     break;
524    
525     case CONVERT (A52_2F2R, A52_DOLBY):
526     mix22toS (samples, bias);
527     break;
528    
529     case CONVERT (A52_3F2R, A52_STEREO):
530     if (slev == 0)
531     goto mix_3to2;
532     mix32to2 (samples, bias);
533     break;
534    
535     case CONVERT (A52_3F2R, A52_DOLBY):
536     mix32toS (samples, bias);
537     break;
538    
539     case CONVERT (A52_3F1R, A52_3F):
540     if (slev == 0)
541     break;
542     mix21to2 (samples, samples + 512, bias);
543     break;
544    
545     case CONVERT (A52_3F2R, A52_3F):
546     if (slev == 0)
547     break;
548     mix2to1 (samples, samples + 768, bias);
549     mix2to1 (samples + 512, samples + 1024, bias);
550     break;
551    
552     case CONVERT (A52_3F1R, A52_2F1R):
553     mix3to2 (samples, bias);
554     memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
555     break;
556    
557     case CONVERT (A52_2F2R, A52_2F1R):
558     mix2to1 (samples + 512, samples + 768, bias);
559     break;
560    
561     case CONVERT (A52_3F2R, A52_2F1R):
562     mix3to2 (samples, bias);
563     move2to1 (samples + 768, samples + 512, bias);
564     break;
565    
566     case CONVERT (A52_3F2R, A52_3F1R):
567     mix2to1 (samples + 768, samples + 1024, bias);
568     break;
569    
570     case CONVERT (A52_2F1R, A52_2F2R):
571     memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
572     break;
573    
574     case CONVERT (A52_3F1R, A52_2F2R):
575     mix3to2 (samples, bias);
576     memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
577     break;
578    
579     case CONVERT (A52_3F2R, A52_2F2R):
580     mix3to2 (samples, bias);
581     memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
582     memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
583     break;
584    
585     case CONVERT (A52_3F1R, A52_3F2R):
586     memcpy (samples + 1027, samples + 768, 256 * sizeof (sample_t));
587     break;
588     }
589     }
590    
591     void a52_upmix (sample_t * samples, int acmod, int output)
592     {
593     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
594    
595     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
596     memcpy (samples + 256, samples, 256 * sizeof (sample_t));
597     break;
598    
599     case CONVERT (A52_3F2R, A52_MONO):
600     zero (samples + 1024);
601     case CONVERT (A52_3F1R, A52_MONO):
602     case CONVERT (A52_2F2R, A52_MONO):
603     zero (samples + 768);
604     case CONVERT (A52_3F, A52_MONO):
605     case CONVERT (A52_2F1R, A52_MONO):
606     zero (samples + 512);
607     case CONVERT (A52_CHANNEL, A52_MONO):
608     case CONVERT (A52_STEREO, A52_MONO):
609     zero (samples + 256);
610     break;
611    
612     case CONVERT (A52_3F2R, A52_STEREO):
613     case CONVERT (A52_3F2R, A52_DOLBY):
614     zero (samples + 1024);
615     case CONVERT (A52_3F1R, A52_STEREO):
616     case CONVERT (A52_3F1R, A52_DOLBY):
617     zero (samples + 768);
618     case CONVERT (A52_3F, A52_STEREO):
619     case CONVERT (A52_3F, A52_DOLBY):
620     mix_3to2:
621     memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
622     zero (samples + 256);
623     break;
624    
625     case CONVERT (A52_2F2R, A52_STEREO):
626     case CONVERT (A52_2F2R, A52_DOLBY):
627     zero (samples + 768);
628     case CONVERT (A52_2F1R, A52_STEREO):
629     case CONVERT (A52_2F1R, A52_DOLBY):
630     zero (samples + 512);
631     break;
632    
633     case CONVERT (A52_3F2R, A52_3F):
634     zero (samples + 1024);
635     case CONVERT (A52_3F1R, A52_3F):
636     case CONVERT (A52_2F2R, A52_2F1R):
637     zero (samples + 768);
638     break;
639    
640     case CONVERT (A52_3F2R, A52_3F1R):
641     zero (samples + 1024);
642     break;
643    
644     case CONVERT (A52_3F2R, A52_2F1R):
645     zero (samples + 1024);
646     case CONVERT (A52_3F1R, A52_2F1R):
647     mix_31to21:
648     memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
649     goto mix_3to2;
650    
651     case CONVERT (A52_3F2R, A52_2F2R):
652     memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
653     goto mix_31to21;
654     }
655     }

  ViewVC Help
Powered by ViewVC 1.1.22