ReactOS 0.4.15-dev-5669-g09dde2c
ntom.c File Reference
#include "mpg123lib_intern.h"
#include "debug.h"
Include dependency graph for ntom.c:

Go to the source code of this file.

Macros

#define SAFE_NTOM   /* Do not depend on off_t*off_t with big values still being in the range... */
 

Functions

int synth_ntom_set_step (mpg123_handle *fr)
 
unsigned long ntom_val (mpg123_handle *fr, off_t frame)
 
void ntom_set_ntom (mpg123_handle *fr, off_t num)
 
off_t ntom_frame_outsamples (mpg123_handle *fr)
 
off_t ntom_frmouts (mpg123_handle *fr, off_t frame)
 
off_t ntom_ins2outs (mpg123_handle *fr, off_t ins)
 
off_t ntom_frameoff (mpg123_handle *fr, off_t soff)
 

Macro Definition Documentation

◆ SAFE_NTOM

#define SAFE_NTOM   /* Do not depend on off_t*off_t with big values still being in the range... */

Definition at line 9 of file ntom.c.

Function Documentation

◆ ntom_frame_outsamples()

off_t ntom_frame_outsamples ( mpg123_handle fr)

Definition at line 73 of file ntom.c.

74{
75 /* The do this before decoding the separate channels, so there is only one common ntom value. */
76 int ntm = fr->ntom_val[0];
77 ntm += fr->spf*fr->ntom_step;
78 return ntm/NTOM_MUL;
79}
#define NTOM_MUL
Definition: decode.h:32
unsigned long ntom_step
Definition: frame.h:150
unsigned long ntom_val[2]
Definition: frame.h:149

◆ ntom_frameoff()

off_t ntom_frameoff ( mpg123_handle fr,
off_t  soff 
)

Definition at line 130 of file ntom.c.

131{
132 off_t ioff = 0; /* frames or samples */
133 off_t ntm = ntom_val(fr,0);
134#ifdef SAFE_NTOM
135 if(soff <= 0) return 0;
136 for(ioff=0; 1; ++ioff)
137 {
138 ntm += fr->spf*fr->ntom_step;
139 if(ntm/NTOM_MUL > soff) break;
140 soff -= ntm/NTOM_MUL;
141 ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
142 }
143 return ioff;
144#else
145 ioff = (soff*(off_t)NTOM_MUL-ntm)/(off_t)fr->ntom_step;
146 return ioff/(off_t)fr->spf;
147#endif
148}
#define off_t
Definition: dosfsck.h:5
__kernel_off_t off_t
Definition: linux.h:201
#define ntom_val
Definition: intsym.h:155

◆ ntom_frmouts()

off_t ntom_frmouts ( mpg123_handle fr,
off_t  frame 
)

Definition at line 82 of file ntom.c.

83{
84#ifdef SAFE_NTOM
85 off_t f;
86#endif
87 off_t soff = 0;
88 off_t ntm = ntom_val(fr,0);
89#ifdef SAFE_NTOM
90 if(frame <= 0) return 0;
91 for(f=0; f<frame; ++f)
92 {
93 ntm += fr->spf*fr->ntom_step;
94 soff += ntm/NTOM_MUL;
95 ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
96 }
97#else
98 soff = (ntm + frame*(off_t)fr->spf*(off_t)fr->ntom_step)/(off_t)NTOM_MUL;
99#endif
100 return soff;
101}
GLfloat f
Definition: glext.h:7540
#define f
Definition: ke_i.h:83

◆ ntom_ins2outs()

off_t ntom_ins2outs ( mpg123_handle fr,
off_t  ins 
)

Definition at line 104 of file ntom.c.

105{
106 off_t soff = 0;
107 off_t ntm = ntom_val(fr,0);
108#ifdef SAFE_NTOM
109 {
110 off_t block = fr->spf;
111 if(ins <= 0) return 0;
112 do
113 {
114 off_t nowblock = ins > block ? block : ins;
115 ntm += nowblock*fr->ntom_step;
116 soff += ntm/NTOM_MUL;
117 ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
118 ins -= nowblock;
119 } while(ins > 0);
120 }
121#else
122 /* Beware of overflows: when off_t is 32bits, the multiplication blows too easily.
123 Of course, it blows for 64bits, too, in theory, but that's for _really_ large files. */
124 soff = ((off_t)ntm + (off_t)ins*(off_t)fr->ntom_step)/(off_t)NTOM_MUL;
125#endif
126 return soff;
127}
static unsigned int block
Definition: xmlmemory.c:101

◆ ntom_set_ntom()

void ntom_set_ntom ( mpg123_handle fr,
off_t  num 
)

Definition at line 66 of file ntom.c.

67{
68 fr->ntom_val[1] = fr->ntom_val[0] = ntom_val(fr, num);
69}
GLuint GLuint num
Definition: glext.h:9618

◆ ntom_val()

unsigned long ntom_val ( mpg123_handle fr,
off_t  frame 
)

Definition at line 46 of file ntom.c.

47{
48 off_t ntm;
49#ifdef SAFE_NTOM /* Carry out the loop, without the threatening integer overflow. */
50 off_t f;
51 ntm = NTOM_MUL>>1; /* for frame 0 */
52 for(f=0; f<frame; ++f) /* for frame > 0 */
53 {
54 ntm += fr->spf*fr->ntom_step;
55 ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
56 }
57#else /* Just make one computation with overall sample offset. */
58 ntm = (NTOM_MUL>>1) + fr->spf*frame*fr->ntom_step;
59 ntm -= (ntm/NTOM_MUL)*NTOM_MUL;
60#endif
61 return (unsigned long) ntm;
62}

◆ synth_ntom_set_step()

int synth_ntom_set_step ( mpg123_handle fr)

Definition at line 13 of file ntom.c.

14{
15 long m,n;
16 m = frame_freq(fr);
17 n = fr->af.rate;
18 if(VERBOSE2)
19 fprintf(stderr,"Init rate converter: %ld->%ld\n",m,n);
20
21 if(n > NTOM_MAX_FREQ || m > NTOM_MAX_FREQ || m <= 0 || n <= 0) {
22 if(NOQUIET) error("NtoM converter: illegal rates");
23 fr->err = MPG123_BAD_RATE;
24 return -1;
25 }
26
27 n *= NTOM_MUL;
28 fr->ntom_step = (unsigned long) n / m;
29
30 if(fr->ntom_step > (unsigned long)NTOM_MAX*NTOM_MUL) {
31 if(NOQUIET) error3("max. 1:%i conversion allowed (%lu vs %lu)!", NTOM_MAX, fr->ntom_step, (unsigned long)8*NTOM_MUL);
32 fr->err = MPG123_BAD_RATE;
33 return -1;
34 }
35
36 fr->ntom_val[0] = fr->ntom_val[1] = ntom_val(fr, fr->num);
37 return 0;
38}
#define NTOM_MAX_FREQ
Definition: decode.h:31
#define NTOM_MAX
Definition: decode.h:30
GLdouble n
Definition: glext.h:7729
const GLfloat * m
Definition: glext.h:10848
@ MPG123_BAD_RATE
Definition: mpg123.h:386
#define stderr
Definition: stdio.h:100
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define frame_freq
Definition: intsym.h:239
#define error(str)
Definition: mkdosfs.c:1605
#define VERBOSE2
#define NOQUIET
#define long
Definition: qsort.c:33
#define error3(s, a, b, c)
Definition: debug.h:127
struct audioformat af
Definition: frame.h:268