ReactOS  0.4.15-dev-488-gc7a1924
mpg123 advanced parameter API

Typedefs

typedef struct mpg123_pars_struct mpg123_pars
 

Functions

MPG123_EXPORT mpg123_handlempg123_parnew (mpg123_pars *mp, const char *decoder, int *error)
 
MPG123_EXPORT mpg123_parsmpg123_new_pars (int *error)
 
MPG123_EXPORT void mpg123_delete_pars (mpg123_pars *mp)
 
MPG123_EXPORT int mpg123_fmt_none (mpg123_pars *mp)
 
MPG123_EXPORT int mpg123_fmt_all (mpg123_pars *mp)
 
MPG123_EXPORT int mpg123_fmt (mpg123_pars *mp, long rate, int channels, int encodings)
 
MPG123_EXPORT int mpg123_fmt2 (mpg123_pars *mp, long rate, int channels, int encodings)
 
MPG123_EXPORT int mpg123_fmt_support (mpg123_pars *mp, long rate, int encoding)
 
MPG123_EXPORT int mpg123_par (mpg123_pars *mp, enum mpg123_parms type, long value, double fvalue)
 
MPG123_EXPORT int mpg123_getpar (mpg123_pars *mp, enum mpg123_parms type, long *value, double *fvalue)
 

Detailed Description

Direct access to a parameter set without full handle around it. Possible uses:

The functions for handling mpg123_pars (mpg123_par() and mpg123_fmt() family) directly return a fully qualified mpg123 error code, the ones operating on full handles normally MPG123_OK or MPG123_ERR, storing the specific error code itseld inside the handle.

Typedef Documentation

◆ mpg123_pars

Opaque structure for the libmpg123 decoder parameters.

Definition at line 1538 of file mpg123.h.

Function Documentation

◆ mpg123_delete_pars()

MPG123_EXPORT void mpg123_delete_pars ( mpg123_pars mp)

Delete and free up memory used by a mpg123_pars data structure

Parameters
mpparameter handle

Definition at line 167 of file frame.c.

168 {
169  if(mp != NULL) free(mp);
170 }
#define free
Definition: debug_ros.c:5
smooth NULL
Definition: ftsmooth.c:416

◆ mpg123_fmt()

MPG123_EXPORT int mpg123_fmt ( mpg123_pars mp,
long  rate,
int  channels,
int  encodings 
)

Set the audio format support of a mpg123_pars in detail:

Parameters
mpparameter handle
rateThe sample rate value (in Hertz).
channelsA combination of MPG123_STEREO and MPG123_MONO.
encodingsA combination of accepted encodings for rate and channels, p.ex MPG123_ENC_SIGNED16|MPG123_ENC_ULAW_8 (or 0 for no support).
Returns
MPG123_OK on success

Definition at line 524 of file format.c.

525 {
526  return (rate == 0)
528  : mpg123_fmt2(mp, rate, channels, encodings);
529 }
int This channels
Definition: rdpsnd_libao.c:37
int rate
Definition: pcmconverter.c:97
int attribute_align_arg mpg123_fmt2(mpg123_pars *mp, long rate, int channels, int encodings)
Definition: format.c:485

Referenced by mpg123_format().

◆ mpg123_fmt2()

MPG123_EXPORT int mpg123_fmt2 ( mpg123_pars mp,
long  rate,
int  channels,
int  encodings 
)

Set the audio format support of a mpg123_pars in detail:

Parameters
mpparameter handle
rateThe sample rate value (in Hertz). Special value 0 means all rates (reason for this variant of mpg123_fmt).
channelsA combination of MPG123_STEREO and MPG123_MONO.
encodingsA combination of accepted encodings for rate and channels, p.ex MPG123_ENC_SIGNED16|MPG123_ENC_ULAW_8 (or 0 for no support).
Returns
MPG123_OK on success

Definition at line 485 of file format.c.

486 {
487  int ie, ic, ratei, r1, r2;
488  int ch[2] = {0, 1};
489  if(mp == NULL) return MPG123_BAD_PARS;
491 
492  if(PVERB(mp,3)) fprintf(stderr, "Note: Want to enable format %li/%i for encodings 0x%x.\n", rate, channels, encodings);
493 
494  if(!(channels & MPG123_STEREO)) ch[1] = 0; /* {0,0} */
495  else if(!(channels & MPG123_MONO)) ch[0] = 1; /* {1,1} */
496  if(rate)
497  {
498  r1 = rate2num(mp, rate);
499  r2 = r1+1;
500  }
501  else
502  {
503  r1 = 0;
504  r2 = MPG123_RATES+1; /* including forced rate */
505  }
506 
507  if(r1 < 0) return MPG123_BAD_RATE;
508 
509  /* now match the encodings */
510  for(ratei = r1; ratei < r2; ++ratei)
511  for(ic = 0; ic < 2; ++ic)
512  {
513  for(ie = 0; ie < MPG123_ENCODINGS; ++ie)
514  if(good_enc(my_encodings[ie]) && ((my_encodings[ie] & encodings) == my_encodings[ie]))
515  mp->audio_caps[ch[ic]][ratei][ie] = 1;
516 
517  if(ch[0] == ch[1]) break; /* no need to do it again */
518  }
519 
520  return MPG123_OK;
521 }
static DNS_RECORDW r1
Definition: record.c:37
#define PVERB(mp, level)
int This channels
Definition: rdpsnd_libao.c:37
char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS]
Definition: frame.h:73
int rate
Definition: pcmconverter.c:97
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
static int good_enc(const int enc)
Definition: format.c:109
static const int my_encodings[MPG123_ENCODINGS]
Definition: format.c:40
static DNS_RECORDW r2
Definition: record.c:38
#define MPG123_RATES
static int rate2num(mpg123_pars *mp, long r)
Definition: format.c:138
FILE * stderr
#define MPG123_ENCODINGS

Referenced by mpg123_fmt(), and mpg123_format2().

◆ mpg123_fmt_all()

MPG123_EXPORT int mpg123_fmt_all ( mpg123_pars mp)

Configure mpg123 parameters to accept all formats (also any custom rate you may set) – this is default.

Parameters
mpparameter handle
Returns
MPG123_OK on success

Definition at line 449 of file format.c.

450 {
451  size_t rate, ch, enc;
452  if(mp == NULL) return MPG123_BAD_PARS;
453 
454  if(PVERB(mp,3)) fprintf(stderr, "Note: Enabling all formats.\n");
455 
456  for(ch=0; ch < NUM_CHANNELS; ++ch)
457  for(rate=0; rate < MPG123_RATES+1; ++rate)
458  for(enc=0; enc < MPG123_ENCODINGS; ++enc)
459  mp->audio_caps[ch][rate][enc] = good_enc(my_encodings[enc]) ? 1 : 0;
460 
461  return MPG123_OK;
462 }
#define PVERB(mp, level)
char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS]
Definition: frame.h:73
int rate
Definition: pcmconverter.c:97
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
static int good_enc(const int enc)
Definition: format.c:109
static const int my_encodings[MPG123_ENCODINGS]
Definition: format.c:40
#define NUM_CHANNELS
Definition: frame.h:72
#define MPG123_RATES
FILE * stderr
#define MPG123_ENCODINGS

Referenced by frame_default_pars(), and mpg123_format_all().

◆ mpg123_fmt_none()

MPG123_EXPORT int mpg123_fmt_none ( mpg123_pars mp)

Configure mpg123 parameters to accept no output format at all, use before specifying supported formats with mpg123_format

Parameters
mpparameter handle
Returns
MPG123_OK on success

Definition at line 428 of file format.c.

429 {
430  if(mp == NULL) return MPG123_BAD_PARS;
431 
432  if(PVERB(mp,3)) fprintf(stderr, "Note: Disabling all formats.\n");
433 
434  memset(mp->audio_caps,0,sizeof(mp->audio_caps));
435  return MPG123_OK;
436 }
#define PVERB(mp, level)
char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS]
Definition: frame.h:73
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
FILE * stderr
#define memset(x, y, z)
Definition: compat.h:39

Referenced by mpg123_format_none().

◆ mpg123_fmt_support()

MPG123_EXPORT int mpg123_fmt_support ( mpg123_pars mp,
long  rate,
int  encoding 
)

Check to see if a specific format at a specific rate is supported by mpg123_pars.

Parameters
mpparameter handle
ratesampling rate
encodingencoding
Returns
0 for no support (that includes invalid parameters), MPG123_STEREO, MPG123_MONO or MPG123_STEREO|MPG123_MONO.

Definition at line 537 of file format.c.

538 {
539  int ch = 0;
540  int ratei, enci;
541  ratei = rate2num(mp, rate);
542  enci = enc2num(encoding);
543  if(mp == NULL || ratei < 0 || enci < 0) return 0;
544  if(mp->audio_caps[0][ratei][enci]) ch |= MPG123_MONO;
545  if(mp->audio_caps[1][ratei][enci]) ch |= MPG123_STEREO;
546  return ch;
547 }
static int enc2num(int encoding)
Definition: format.c:149
char audio_caps[NUM_CHANNELS][MPG123_RATES+1][MPG123_ENCODINGS]
Definition: frame.h:73
int rate
Definition: pcmconverter.c:97
smooth NULL
Definition: ftsmooth.c:416
ed encoding
Definition: write.c:2825
static int rate2num(mpg123_pars *mp, long r)
Definition: format.c:138

Referenced by mpg123_format_support().

◆ mpg123_getpar()

MPG123_EXPORT int mpg123_getpar ( mpg123_pars mp,
enum mpg123_parms  type,
long value,
double fvalue 
)

Get a specific parameter, for a specific mpg123_pars. See the mpg123_parms enumeration for a list of available parameters.

Parameters
mpparameter handle
typeparameter choice
valueinteger value return address
fvaluefloating point value return address
Returns
MPG123_OK on success

Definition at line 278 of file libmpg123.c.

279 {
280  int ret = 0;
281 
282  if(mp == NULL) return MPG123_BAD_PARS;
283  switch(key)
284  {
285  case MPG123_VERBOSE:
286  if(val) *val = mp->verbose;
287  break;
288  case MPG123_FLAGS:
289  case MPG123_ADD_FLAGS:
290  if(val) *val = mp->flags;
291  break;
292  case MPG123_FORCE_RATE:
293  if(val)
294 #ifdef NO_NTOM
295  *val = 0;
296 #else
297  *val = mp->force_rate;
298 #endif
299  break;
300  case MPG123_DOWN_SAMPLE:
301  if(val) *val = mp->down_sample;
302  break;
303  case MPG123_RVA:
304  if(val) *val = mp->rva;
305  break;
306  case MPG123_DOWNSPEED:
307  if(val) *val = mp->halfspeed;
308  break;
309  case MPG123_UPSPEED:
310  if(val) *val = mp->doublespeed;
311  break;
312  case MPG123_ICY_INTERVAL:
313 #ifndef NO_ICY
314  if(val) *val = (long)mp->icy_interval;
315 #else
316  if(val) *val = 0;
317 #endif
318  break;
319  case MPG123_OUTSCALE:
320  if(fval) *fval = mp->outscale;
321  if(val) *val = (long)(mp->outscale*SHORT_SCALE);
322  break;
323  case MPG123_RESYNC_LIMIT:
324  if(val) *val = mp->resync_limit;
325  break;
326  case MPG123_INDEX_SIZE:
327  if(val)
328 #ifdef FRAME_INDEX
329  *val = mp->index_size;
330 #else
331  *val = 0; /* graceful fallback: no index is index of zero size */
332 #endif
333  break;
334  case MPG123_PREFRAMES:
335  *val = mp->preframes;
336  break;
337  case MPG123_FEEDPOOL:
338 #ifndef NO_FEEDER
339  *val = mp->feedpool;
340 #else
342 #endif
343  break;
344  case MPG123_FEEDBUFFER:
345 #ifndef NO_FEEDER
346  *val = mp->feedbuffer;
347 #else
349 #endif
350  break;
352  *val = mp->freeformat_framesize;
353  break;
354  default:
356  }
357  return ret;
358 }
long index_size
Definition: frame.h:81
long preframes
Definition: frame.h:82
long feedbuffer
Definition: frame.h:85
long icy_interval
Definition: frame.h:77
long doublespeed
Definition: frame.h:70
long halfspeed
Definition: frame.h:69
smooth NULL
Definition: ftsmooth.c:416
GLuint GLfloat * val
Definition: glext.h:7180
long force_rate
Definition: frame.h:65
int ret
long freeformat_framesize
Definition: frame.h:87
#define SHORT_SCALE
long resync_limit
Definition: frame.h:80
#define long
Definition: qsort.c:33
double outscale
Definition: frame.h:79
Definition: path.c:41

Referenced by mpg123_getparam().

◆ mpg123_new_pars()

MPG123_EXPORT mpg123_pars* mpg123_new_pars ( int error)

Allocate memory for and return a pointer to a new mpg123_pars

Parameters
errorerror code return address
Returns
new parameter handle

Definition at line 159 of file frame.c.

160 {
161  mpg123_pars *mp = malloc(sizeof(struct mpg123_pars_struct));
162  if(mp != NULL){ frame_default_pars(mp); if(error != NULL) *error = MPG123_OK; }
163  else if(error != NULL) *error = MPG123_OUT_OF_MEM;
164  return mp;
165 }
#define error(str)
Definition: mkdosfs.c:1605
static void frame_default_pars(mpg123_pars *mp)
Definition: frame.c:36
smooth NULL
Definition: ftsmooth.c:416
#define malloc
Definition: debug_ros.c:4

◆ mpg123_par()

MPG123_EXPORT int mpg123_par ( mpg123_pars mp,
enum mpg123_parms  type,
long  value,
double  fvalue 
)

Set a specific parameter, for a specific mpg123_pars, using a parameter type key chosen from the mpg123_parms enumeration, to the specified value.

Parameters
mpparameter handle
typeparameter choice
valueinteger value
fvaluefloating point value
Returns
MPG123_OK on success

Definition at line 152 of file libmpg123.c.

153 {
154  int ret = MPG123_OK;
155 
156  if(mp == NULL) return MPG123_BAD_PARS;
157  switch(key)
158  {
159  case MPG123_VERBOSE:
160  mp->verbose = val;
161  break;
162  case MPG123_FLAGS:
163 #ifndef GAPLESS
165 #endif
166  if(ret == MPG123_OK) mp->flags = val;
167  debug1("set flags to 0x%lx", (unsigned long) mp->flags);
168  break;
169  case MPG123_ADD_FLAGS:
170 #ifndef GAPLESS
171  /* Enabling of gapless mode doesn't work when it's not there, but disabling (below) is no problem. */
173  else
174 #endif
175  mp->flags |= val;
176  debug1("set flags to 0x%lx", (unsigned long) mp->flags);
177  break;
178  case MPG123_REMOVE_FLAGS:
179  mp->flags &= ~val;
180  debug1("set flags to 0x%lx", (unsigned long) mp->flags);
181  break;
182  case MPG123_FORCE_RATE: /* should this trigger something? */
183 #ifdef NO_NTOM
184  if(val > 0)
186 #else
187  if(val > 96000) ret = MPG123_BAD_RATE;
188  else mp->force_rate = val < 0 ? 0 : val; /* >0 means enable, 0 disable */
189 #endif
190  break;
191  case MPG123_DOWN_SAMPLE:
192 #ifdef NO_DOWNSAMPLE
193  if(val != 0) ret = MPG123_BAD_RATE;
194 #else
196  else mp->down_sample = (int)val;
197 #endif
198  break;
199  case MPG123_RVA:
201  else mp->rva = (int)val;
202  break;
203  case MPG123_DOWNSPEED:
204  mp->halfspeed = val < 0 ? 0 : val;
205  break;
206  case MPG123_UPSPEED:
207  mp->doublespeed = val < 0 ? 0 : val;
208  break;
209  case MPG123_ICY_INTERVAL:
210 #ifndef NO_ICY
211  mp->icy_interval = val > 0 ? val : 0;
212 #else
213  if(val > 0) ret = MPG123_BAD_PARAM;
214 #endif
215  break;
216  case MPG123_OUTSCALE:
217  /* Choose the value that is non-zero, if any.
218  Downscaling integers to 1.0 . */
219  mp->outscale = val == 0 ? fval : (double)val/SHORT_SCALE;
220  break;
221  case MPG123_TIMEOUT:
222 #ifdef TIMEOUT_READ
223  mp->timeout = val >= 0 ? val : 0;
224 #else
225  if(val > 0) ret = MPG123_NO_TIMEOUT;
226 #endif
227  break;
228  case MPG123_RESYNC_LIMIT:
229  mp->resync_limit = val;
230  break;
231  case MPG123_INDEX_SIZE:
232 #ifdef FRAME_INDEX
233  mp->index_size = val;
234 #else
235  if(val) // It is only an eror if you want to enable the index.
237 #endif
238  break;
239  case MPG123_PREFRAMES:
240  if(val >= 0) mp->preframes = val;
241  else ret = MPG123_BAD_VALUE;
242  break;
243  case MPG123_FEEDPOOL:
244 #ifndef NO_FEEDER
245  if(val >= 0) mp->feedpool = val;
246  else ret = MPG123_BAD_VALUE;
247 #else
249 #endif
250  break;
251  case MPG123_FEEDBUFFER:
252 #ifndef NO_FEEDER
253  if(val > 0) mp->feedbuffer = val;
254  else ret = MPG123_BAD_VALUE;
255 #else
257 #endif
258  break;
261  break;
262  default:
264  }
265  return ret;
266 }
long index_size
Definition: frame.h:81
long preframes
Definition: frame.h:82
long feedbuffer
Definition: frame.h:85
long icy_interval
Definition: frame.h:77
long doublespeed
Definition: frame.h:70
long halfspeed
Definition: frame.h:69
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
smooth NULL
Definition: ftsmooth.c:416
GLuint GLfloat * val
Definition: glext.h:7180
long force_rate
Definition: frame.h:65
int ret
long freeformat_framesize
Definition: frame.h:87
#define SHORT_SCALE
long resync_limit
Definition: frame.h:80
double outscale
Definition: frame.h:79
#define debug1(s, a)
Definition: debug.h:61
Definition: path.c:41
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by mpg123_param().

◆ mpg123_parnew()

MPG123_EXPORT mpg123_handle* mpg123_parnew ( mpg123_pars mp,
const char decoder,
int error 
)

Create a handle with preset parameters.

Parameters
mpparameter handle
decoderdecoder choice
errorerror code return address
Returns
mpg123 handle

Definition at line 63 of file libmpg123.c.

64 {
65  mpg123_handle *fr = NULL;
66  int err = MPG123_OK;
67 
68  if(initialized) fr = (mpg123_handle*) malloc(sizeof(mpg123_handle));
70  if(fr != NULL)
71  {
72  frame_init_par(fr, mp);
73  debug("cpu opt setting");
74  if(frame_cpu_opt(fr, decoder) != 1)
75  {
77  frame_exit(fr);
78  free(fr);
79  fr = NULL;
80  }
81  }
82  if(fr != NULL)
83  {
84  fr->decoder_change = 1;
85  }
86  else if(err == MPG123_OK) err = MPG123_OUT_OF_MEM;
87 
88  if(error != NULL) *error = err;
89  return fr;
90 }
#define frame_init_par
Definition: intsym.h:180
static int initialized
Definition: libmpg123.c:21
#define error(str)
Definition: mkdosfs.c:1605
#define free
Definition: debug_ros.c:5
#define frame_exit
Definition: intsym.h:186
smooth NULL
Definition: ftsmooth.c:416
#define err(...)
#define debug(msg)
Definition: key_call.c:71
#define frame_cpu_opt
Definition: intsym.h:231
#define malloc
Definition: debug_ros.c:4

Referenced by mpg123_new().