← Back to branch summary

~ubuntu-branches/debian/jessie/libsndfile/jessie

« back to all changes in this revision

Viewing changes to src/double64.c

  • Committer: Bazaar Package Importer
  • Author(s): Samuel Mimram
  • Date: 2009-02-17 19:21:03 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20090217192103-7rhu1n8p79jnbzy3
Tags: 1.0.18-2
Add missing build-dependencies on pkg-config and libvorbis-dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/double64.c
1
1
/*
2
 
** Copyright (C) 1999-2005 Erik de Castro Lopo <erikd@mega-nerd.com>
 
2
** Copyright (C) 1999-2009 Erik de Castro Lopo <erikd@mega-nerd.com>
3
3
**
4
4
** This program is free software; you can redistribute it and/or modify
5
5
** it under the terms of the GNU Lesser General Public License as published by
21
21
#include        <stdio.h>
22
22
#include        <stdlib.h>
23
23
#include        <string.h>
 
24
#include        <limits.h>
 
25
#include        <math.h>
24
26
 
25
27
#include        "sndfile.h"
26
28
#include        "sfendian.h"
27
29
#include        "common.h"
28
 
#include        "float_cast.h"
29
30
 
30
31
#if CPU_IS_LITTLE_ENDIAN
31
32
        #define DOUBLE64_READ   double64_le_read
97
98
        if (psf->mode == SFM_READ || psf->mode == SFM_RDWR)
98
99
        {       switch (psf->endian + double64_caps)
99
100
                {       case (SF_ENDIAN_BIG + DOUBLE_CAN_RW_BE) :
100
 
                                        psf->float_endswap = SF_FALSE ;
 
101
                                        psf->data_endswap = SF_FALSE ;
101
102
                                        psf->read_short         = host_read_d2s ;
102
103
                                        psf->read_int           = host_read_d2i ;
103
104
                                        psf->read_float         = host_read_d2f ;
105
106
                                        break ;
106
107
 
107
108
                        case (SF_ENDIAN_LITTLE + DOUBLE_CAN_RW_LE) :
108
 
                                        psf->float_endswap = SF_FALSE ;
 
109
                                        psf->data_endswap = SF_FALSE ;
109
110
                                        psf->read_short         = host_read_d2s ;
110
111
                                        psf->read_int           = host_read_d2i ;
111
112
                                        psf->read_float         = host_read_d2f ;
113
114
                                        break ;
114
115
 
115
116
                        case (SF_ENDIAN_BIG + DOUBLE_CAN_RW_LE) :
116
 
                                        psf->float_endswap = SF_TRUE ;
 
117
                                        psf->data_endswap = SF_TRUE ;
117
118
                                        psf->read_short         = host_read_d2s ;
118
119
                                        psf->read_int           = host_read_d2i ;
119
120
                                        psf->read_float         = host_read_d2f ;
121
122
                                        break ;
122
123
 
123
124
                        case (SF_ENDIAN_LITTLE + DOUBLE_CAN_RW_BE) :
124
 
                                        psf->float_endswap = SF_TRUE ;
 
125
                                        psf->data_endswap = SF_TRUE ;
125
126
                                        psf->read_short         = host_read_d2s ;
126
127
                                        psf->read_int           = host_read_d2i ;
127
128
                                        psf->read_float         = host_read_d2f ;
130
131
 
131
132
                        /* When the CPU is not IEEE compatible. */
132
133
                        case (SF_ENDIAN_BIG + DOUBLE_BROKEN_BE) :
133
 
                                        psf->float_endswap = SF_FALSE ;
 
134
                                        psf->data_endswap = SF_FALSE ;
134
135
                                        psf->read_short         = replace_read_d2s ;
135
136
                                        psf->read_int           = replace_read_d2i ;
136
137
                                        psf->read_float         = replace_read_d2f ;
138
139
                                        break ;
139
140
 
140
141
                        case (SF_ENDIAN_LITTLE + DOUBLE_BROKEN_LE) :
141
 
                                        psf->float_endswap = SF_FALSE ;
 
142
                                        psf->data_endswap = SF_FALSE ;
142
143
                                        psf->read_short         = replace_read_d2s ;
143
144
                                        psf->read_int           = replace_read_d2i ;
144
145
                                        psf->read_float         = replace_read_d2f ;
146
147
                                        break ;
147
148
 
148
149
                        case (SF_ENDIAN_BIG + DOUBLE_BROKEN_LE) :
149
 
                                        psf->float_endswap = SF_TRUE ;
 
150
                                        psf->data_endswap = SF_TRUE ;
150
151
                                        psf->read_short         = replace_read_d2s ;
151
152
                                        psf->read_int           = replace_read_d2i ;
152
153
                                        psf->read_float         = replace_read_d2f ;
154
155
                                        break ;
155
156
 
156
157
                        case (SF_ENDIAN_LITTLE + DOUBLE_BROKEN_BE) :
157
 
                                        psf->float_endswap = SF_TRUE ;
 
158
                                        psf->data_endswap = SF_TRUE ;
158
159
                                        psf->read_short         = replace_read_d2s ;
159
160
                                        psf->read_int           = replace_read_d2i ;
160
161
                                        psf->read_float         = replace_read_d2f ;
168
169
        if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
169
170
        {       switch (psf->endian + double64_caps)
170
171
                {       case (SF_ENDIAN_LITTLE + DOUBLE_CAN_RW_LE) :
171
 
                                        psf->float_endswap = SF_FALSE ;
 
172
                                        psf->data_endswap = SF_FALSE ;
172
173
                                        psf->write_short        = host_write_s2d ;
173
174
                                        psf->write_int          = host_write_i2d ;
174
175
                                        psf->write_float        = host_write_f2d ;
176
177
                                        break ;
177
178
 
178
179
                        case (SF_ENDIAN_BIG + DOUBLE_CAN_RW_BE) :
179
 
                                        psf->float_endswap = SF_FALSE ;
 
180
                                        psf->data_endswap = SF_FALSE ;
180
181
                                        psf->write_short        = host_write_s2d ;
181
182
                                        psf->write_int          = host_write_i2d ;
182
183
                                        psf->write_float        = host_write_f2d ;
184
185
                                        break ;
185
186
 
186
187
                        case (SF_ENDIAN_BIG + DOUBLE_CAN_RW_LE) :
187
 
                                        psf->float_endswap = SF_TRUE ;
 
188
                                        psf->data_endswap = SF_TRUE ;
188
189
                                        psf->write_short        = host_write_s2d ;
189
190
                                        psf->write_int          = host_write_i2d ;
190
191
                                        psf->write_float        = host_write_f2d ;
192
193
                                        break ;
193
194
 
194
195
                        case (SF_ENDIAN_LITTLE + DOUBLE_CAN_RW_BE) :
195
 
                                        psf->float_endswap = SF_TRUE ;
 
196
                                        psf->data_endswap = SF_TRUE ;
196
197
                                        psf->write_short        = host_write_s2d ;
197
198
                                        psf->write_int          = host_write_i2d ;
198
199
                                        psf->write_float        = host_write_f2d ;
201
202
 
202
203
                        /* When the CPU is not IEEE compatible. */
203
204
                        case (SF_ENDIAN_LITTLE + DOUBLE_BROKEN_LE) :
204
 
                                        psf->float_endswap = SF_FALSE ;
 
205
                                        psf->data_endswap = SF_FALSE ;
205
206
                                        psf->write_short        = replace_write_s2d ;
206
207
                                        psf->write_int          = replace_write_i2d ;
207
208
                                        psf->write_float        = replace_write_f2d ;
209
210
                                        break ;
210
211
 
211
212
                        case (SF_ENDIAN_BIG + DOUBLE_BROKEN_BE) :
212
 
                                        psf->float_endswap = SF_FALSE ;
 
213
                                        psf->data_endswap = SF_FALSE ;
213
214
                                        psf->write_short        = replace_write_s2d ;
214
215
                                        psf->write_int          = replace_write_i2d ;
215
216
                                        psf->write_float        = replace_write_f2d ;
217
218
                                        break ;
218
219
 
219
220
                        case (SF_ENDIAN_BIG + DOUBLE_BROKEN_LE) :
220
 
                                        psf->float_endswap = SF_TRUE ;
 
221
                                        psf->data_endswap = SF_TRUE ;
221
222
                                        psf->write_short        = replace_write_s2d ;
222
223
                                        psf->write_int          = replace_write_i2d ;
223
224
                                        psf->write_float        = replace_write_f2d ;
225
226
                                        break ;
226
227
 
227
228
                        case (SF_ENDIAN_LITTLE + DOUBLE_BROKEN_BE) :
228
 
                                        psf->float_endswap = SF_TRUE ;
 
229
                                        psf->data_endswap = SF_TRUE ;
229
230
                                        psf->write_short        = replace_write_s2d ;
230
231
                                        psf->write_int          = replace_write_i2d ;
231
232
                                        psf->write_float        = replace_write_f2d ;
300
301
                dvalue *= -1 ;
301
302
 
302
303
        if (exponent > 0)
303
 
                dvalue *= (1 << exponent) ;
 
304
                dvalue *= pow (2.0, exponent) ;
304
305
        else if (exponent < 0)
305
 
                dvalue /= (1 << abs (exponent)) ;
 
306
                dvalue /= pow (2.0, abs (exponent)) ;
306
307
 
307
308
        return dvalue ;
308
309
} /* double64_be_read */
333
334
                dvalue *= -1 ;
334
335
 
335
336
        if (exponent > 0)
336
 
                dvalue *= (1 << exponent) ;
 
337
                dvalue *= pow (2.0, exponent) ;
337
338
        else if (exponent < 0)
338
 
                dvalue /= (1 << abs (exponent)) ;
 
339
                dvalue /= pow (2.0, abs (exponent)) ;
339
340
 
340
341
        return dvalue ;
341
342
} /* double64_le_read */
478
479
/*=======================================================================================
479
480
*/
480
481
 
481
 
static inline void
 
482
static void
482
483
d2s_array (const double *src, int count, short *dest, double scale)
483
484
{       while (--count >= 0)
484
485
        {       dest [count] = lrint (scale * src [count]) ;
485
486
                } ;
486
487
} /* d2s_array */
487
488
 
488
 
static inline void
 
489
static void
 
490
d2s_clip_array (const double *src, int count, short *dest, double scale)
 
491
{       while (--count >= 0)
 
492
        {       double tmp = scale * src [count] ;
 
493
 
 
494
                if (CPU_CLIPS_POSITIVE == 0 && tmp > 32767.0)
 
495
                        dest [count] = SHRT_MAX ;
 
496
                else if (CPU_CLIPS_NEGATIVE == 0 && tmp < -32768.0)
 
497
                        dest [count] = SHRT_MIN ;
 
498
                else
 
499
                        dest [count] = lrint (tmp) ;
 
500
                } ;
 
501
} /* d2s_clip_array */
 
502
 
 
503
static void
489
504
d2i_array (const double *src, int count, int *dest, double scale)
490
505
{       while (--count >= 0)
491
506
        {       dest [count] = lrint (scale * src [count]) ;
492
507
                } ;
493
508
} /* d2i_array */
494
509
 
 
510
static void
 
511
d2i_clip_array (const double *src, int count, int *dest, double scale)
 
512
{       while (--count >= 0)
 
513
        {       float tmp = scale * src [count] ;
 
514
 
 
515
                if (CPU_CLIPS_POSITIVE == 0 && tmp > (1.0 * INT_MAX))
 
516
                        dest [count] = INT_MAX ;
 
517
                else if (CPU_CLIPS_NEGATIVE == 0 && tmp < (-1.0 * INT_MAX))
 
518
                        dest [count] = INT_MIN ;
 
519
                else
 
520
                        dest [count] = lrint (tmp) ;
 
521
                } ;
 
522
} /* d2i_clip_array */
 
523
 
495
524
static inline void
496
525
d2f_array (const double *src, int count, float *dest)
497
526
{       while (--count >= 0)
500
529
} /* d2f_array */
501
530
 
502
531
static inline void
503
 
s2d_array (const short *src, double *dest, int count)
 
532
s2d_array (const short *src, double *dest, int count, double scale)
504
533
{       while (--count >= 0)
505
 
        {       dest [count] = src [count] ;
 
534
        {       dest [count] = scale * src [count] ;
506
535
                } ;
507
536
} /* s2d_array */
508
537
 
509
538
static inline void
510
 
i2d_array (const int *src, double *dest, int count)
 
539
i2d_array (const int *src, double *dest, int count, double scale)
511
540
{       while (--count >= 0)
512
 
        {       dest [count] = src [count] ;
 
541
        {       dest [count] = scale * src [count] ;
513
542
                } ;
514
543
} /* i2d_array */
515
544
 
525
554
 
526
555
static sf_count_t
527
556
host_read_d2s   (SF_PRIVATE *psf, short *ptr, sf_count_t len)
528
 
{       int                     bufferlen, readcount ;
 
557
{       void            (*convert) (const double *, int, short *, double) ;
 
558
        int                     bufferlen, readcount ;
529
559
        sf_count_t      total = 0 ;
530
560
        double          scale ;
531
561
 
 
562
        convert = (psf->add_clipping) ? d2s_clip_array : d2s_array ;
532
563
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
533
564
        scale = (psf->float_int_mult == 0) ? 1.0 : 0x7FFF / psf->float_max ;
534
565
 
537
568
                        bufferlen = (int) len ;
538
569
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
539
570
 
540
 
                if (psf->float_endswap == SF_TRUE)
 
571
                if (psf->data_endswap == SF_TRUE)
541
572
                        endswap_double_array (psf->u.dbuf, readcount) ;
542
573
 
543
 
                d2s_array (psf->u.dbuf, readcount, ptr + total, scale) ;
 
574
                convert (psf->u.dbuf, readcount, ptr + total, scale) ;
544
575
                total += readcount ;
545
576
                len -= readcount ;
546
577
                if (readcount < bufferlen)
552
583
 
553
584
static sf_count_t
554
585
host_read_d2i   (SF_PRIVATE *psf, int *ptr, sf_count_t len)
555
 
{       int                     bufferlen, readcount ;
 
586
{       void            (*convert) (const double *, int, int *, double) ;
 
587
        int                     bufferlen, readcount ;
556
588
        sf_count_t      total = 0 ;
557
589
        double          scale ;
 
590
 
 
591
        convert = (psf->add_clipping) ? d2i_clip_array : d2i_array ;
558
592
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
559
593
        scale = (psf->float_int_mult == 0) ? 1.0 : 0x7FFFFFFF / psf->float_max ;
560
594
 
563
597
                        bufferlen = (int) len ;
564
598
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
565
599
 
566
 
                if (psf->float_endswap == SF_TRUE)
 
600
                if (psf->data_endswap == SF_TRUE)
567
601
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
568
602
 
569
 
                d2i_array (psf->u.dbuf, readcount, ptr + total, scale) ;
 
603
                convert (psf->u.dbuf, readcount, ptr + total, scale) ;
570
604
                total += readcount ;
571
605
                len -= readcount ;
572
606
                if (readcount < bufferlen)
588
622
                        bufferlen = (int) len ;
589
623
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
590
624
 
591
 
                if (psf->float_endswap == SF_TRUE)
 
625
                if (psf->data_endswap == SF_TRUE)
592
626
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
593
627
 
594
628
                d2f_array (psf->u.dbuf, readcount, ptr + total) ;
608
642
 
609
643
        readcount = psf_fread (ptr, sizeof (double), len, psf) ;
610
644
 
611
 
        if (psf->float_endswap != SF_TRUE)
 
645
        if (psf->data_endswap != SF_TRUE)
612
646
                return readcount ;
613
647
 
614
648
        /* If the read length was sensible, endswap output in one go. */
635
669
host_write_s2d  (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
636
670
{       int                     bufferlen, writecount ;
637
671
        sf_count_t      total = 0 ;
 
672
        double          scale ;
638
673
 
 
674
        scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / 0x8000 ;
639
675
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
640
676
 
641
677
        while (len > 0)
642
678
        {       if (len < bufferlen)
643
679
                        bufferlen = (int) len ;
644
680
 
645
 
                s2d_array (ptr + total, psf->u.dbuf, bufferlen) ;
 
681
                s2d_array (ptr + total, psf->u.dbuf, bufferlen, scale) ;
646
682
 
647
683
                if (psf->peak_info)
648
684
                        double64_peak_update (psf, psf->u.dbuf, bufferlen, total / psf->sf.channels) ;
649
685
 
650
 
                if (psf->float_endswap == SF_TRUE)
 
686
                if (psf->data_endswap == SF_TRUE)
651
687
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
652
688
 
653
689
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
664
700
host_write_i2d  (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
665
701
{       int                     bufferlen, writecount ;
666
702
        sf_count_t      total = 0 ;
 
703
        double          scale ;
667
704
 
 
705
        scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / (8.0 * 0x10000000) ;
668
706
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
669
707
 
670
708
        while (len > 0)
671
709
        {       if (len < bufferlen)
672
710
                        bufferlen = (int) len ;
673
 
                i2d_array (ptr + total, psf->u.dbuf, bufferlen) ;
 
711
                i2d_array (ptr + total, psf->u.dbuf, bufferlen, scale) ;
674
712
 
675
713
                if (psf->peak_info)
676
714
                        double64_peak_update (psf, psf->u.dbuf, bufferlen, total / psf->sf.channels) ;
677
715
 
678
 
                if (psf->float_endswap == SF_TRUE)
 
716
                if (psf->data_endswap == SF_TRUE)
679
717
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
680
718
 
681
719
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
703
741
                if (psf->peak_info)
704
742
                        double64_peak_update (psf, psf->u.dbuf, bufferlen, total / psf->sf.channels) ;
705
743
 
706
 
                if (psf->float_endswap == SF_TRUE)
 
744
                if (psf->data_endswap == SF_TRUE)
707
745
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
708
746
 
709
747
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
724
762
        if (psf->peak_info)
725
763
                double64_peak_update (psf, ptr, len, 0) ;
726
764
 
727
 
        if (psf->float_endswap != SF_TRUE)
 
765
        if (psf->data_endswap != SF_TRUE)
728
766
                return psf_fwrite (ptr, sizeof (double), len, psf) ;
729
767
 
730
768
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
762
800
                        bufferlen = (int) len ;
763
801
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
764
802
 
765
 
                if (psf->float_endswap == SF_TRUE)
 
803
                if (psf->data_endswap == SF_TRUE)
766
804
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
767
805
 
768
806
                d2bd_read (psf->u.dbuf, bufferlen) ;
791
829
                        bufferlen = (int) len ;
792
830
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
793
831
 
794
 
                if (psf->float_endswap == SF_TRUE)
 
832
                if (psf->data_endswap == SF_TRUE)
795
833
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
796
834
 
797
835
                d2bd_read (psf->u.dbuf, bufferlen) ;
818
856
                        bufferlen = (int) len ;
819
857
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
820
858
 
821
 
                if (psf->float_endswap == SF_TRUE)
 
859
                if (psf->data_endswap == SF_TRUE)
822
860
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
823
861
 
824
862
                d2bd_read (psf->u.dbuf, bufferlen) ;
847
885
                        bufferlen = (int) len ;
848
886
                readcount = psf_fread (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
849
887
 
850
 
                if (psf->float_endswap == SF_TRUE)
 
888
                if (psf->data_endswap == SF_TRUE)
851
889
                        endswap_double_array (psf->u.dbuf, readcount) ;
852
890
 
853
891
                d2bd_read (psf->u.dbuf, readcount) ;
867
905
replace_write_s2d       (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
868
906
{       int                     bufferlen, writecount ;
869
907
        sf_count_t      total = 0 ;
 
908
        double          scale ;
870
909
 
 
910
        scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / 0x8000 ;
871
911
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
872
912
 
873
913
        while (len > 0)
874
914
        {       if (len < bufferlen)
875
915
                        bufferlen = (int) len ;
876
 
                s2d_array (ptr + total, psf->u.dbuf, bufferlen) ;
 
916
                s2d_array (ptr + total, psf->u.dbuf, bufferlen, scale) ;
877
917
 
878
918
                if (psf->peak_info)
879
919
                        double64_peak_update (psf, psf->u.dbuf, bufferlen, total / psf->sf.channels) ;
880
920
 
881
921
                bd2d_write (psf->u.dbuf, bufferlen) ;
882
922
 
883
 
                if (psf->float_endswap == SF_TRUE)
 
923
                if (psf->data_endswap == SF_TRUE)
884
924
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
885
925
 
886
926
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
897
937
replace_write_i2d       (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
898
938
{       int                     bufferlen, writecount ;
899
939
        sf_count_t      total = 0 ;
 
940
        double          scale ;
900
941
 
 
942
        scale = (psf->scale_int_float == 0) ? 1.0 : 1.0 / (8.0 * 0x10000000) ;
901
943
        bufferlen = ARRAY_LEN (psf->u.dbuf) ;
902
944
 
903
945
        while (len > 0)
904
946
        {       if (len < bufferlen)
905
947
                        bufferlen = (int) len ;
906
 
                i2d_array (ptr + total, psf->u.dbuf, bufferlen) ;
 
948
                i2d_array (ptr + total, psf->u.dbuf, bufferlen, scale) ;
907
949
 
908
950
                if (psf->peak_info)
909
951
                        double64_peak_update (psf, psf->u.dbuf, bufferlen, total / psf->sf.channels) ;
910
952
 
911
953
                bd2d_write (psf->u.dbuf, bufferlen) ;
912
954
 
913
 
                if (psf->float_endswap == SF_TRUE)
 
955
                if (psf->data_endswap == SF_TRUE)
914
956
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
915
957
 
916
958
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
937
979
 
938
980
                bd2d_write (psf->u.dbuf, bufferlen) ;
939
981
 
940
 
                if (psf->float_endswap == SF_TRUE)
 
982
                if (psf->data_endswap == SF_TRUE)
941
983
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
942
984
 
943
985
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
969
1011
 
970
1012
                bd2d_write (psf->u.dbuf, bufferlen) ;
971
1013
 
972
 
                if (psf->float_endswap == SF_TRUE)
 
1014
                if (psf->data_endswap == SF_TRUE)
973
1015
                        endswap_double_array (psf->u.dbuf, bufferlen) ;
974
1016
 
975
1017
                writecount = psf_fwrite (psf->u.dbuf, sizeof (double), bufferlen, psf) ;
999
1041
                } ;
1000
1042
} /* bd2d_write */
1001
1043
 
1002
 
/*
1003
 
** Do not edit or modify anything in this comment block.
1004
 
** The arch-tag line is a file identity tag for the GNU Arch
1005
 
** revision control system.
1006
 
**
1007
 
** arch-tag: 4ee243b7-8c7a-469b-869c-e9aa0ee3b77f
1008
 
*/