interpretor/lib/src/libsndfile-1.0.25/doc/command.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
   2 <HTML>
   3
   4 <HEAD>
   5         <TITLE>
   6         libsndfile : the sf_command function.
   7         </TITLE>
   8         <META NAME="Author"      CONTENT="Erik de Castro Lopo (erikd AT mega-nerd DOT com)">
   9         <!-- Another version at the bottom of the page.  -->
  10         <META NAME="Description" CONTENT="The libsndfile API.">
  11         <META NAME="Keywords"    CONTENT="WAV AIFF AU libsndfile sound audio dsp Linux">
  12         <LINK REL="stylesheet" HREF="libsndfile.css" TYPE="text/css" MEDIA="all">
  13         <LINK REL="stylesheet" HREF="print.css" TYPE="text/css" MEDIA="print">
  14 </HEAD>
  15
  16 <BODY>
  17
  18 <H1><B>sf_command</B></H1>
  19 <PRE>
  20
  21         int    sf_command (SNDFILE *sndfile, int cmd, void *data, int datasize) ;
  22 </PRE>
  23 <P>
  24         This function allows the caller to retrieve information from or change aspects of the
  25         library behaviour.
  26         Examples include retrieving a string containing the library version or changing the
  27         scaling applied to floating point sample data during read and write.
  28         Most of these operations are performed on a per-file basis.
  29 </P>
  30 <P>
  31         The cmd parameter is an integer identifier which is defined in &lt;sndfile.h&gt;.
  32         All of the valid command identifiers have names beginning with "SFC_".
  33         Data is passed to and returned from the library by use of a void pointer.
  34         The library will not read or write more than datasize bytes from the void pointer.
  35         For some calls no data is required in which case data should be NULL and datasize
  36         may be used for some other purpose.
  37 </P>
  38 <P>
  39         The available commands are as follows:
  40 </P>
  41
  42 <CENTER>
  43 <TABLE BORDER="0" WIDTH="90%" CELLPADDING="4">
  44 <TR>
  45         <TD><A HREF="#SFC_GET_LIB_VERSION">SFC_GET_LIB_VERSION</A></TD>
  46         <TD>Retrieve the version of the library.</TD>
  47 </TR>
  48 <TR>
  49         <TD><A HREF="#SFC_GET_LOG_INFO">SFC_GET_LOG_INFO</A></TD>
  50         <TD>Retrieve the internal per-file operation log.</TD>
  51 </TR>
  52 <TR>
  53         <TD><A HREF="#SFC_CALC_SIGNAL_MAX">SFC_CALC_SIGNAL_MAX</A></TD>
  54         <TD>Calculate the measured maximum signal value.</TD>
  55 </TR>
  56 <TR>
  57         <TD><A HREF="#SFC_CALC_NORM_SIGNAL_MAX">SFC_CALC_NORM_SIGNAL_MAX</A></TD>
  58         <TD>Calculate the measured normalised maximum signal value.</TD>
  59 </TR>
  60 <TR>
  61         <TD><A HREF="#SFC_CALC_MAX_ALL_CHANNELS">SFC_CALC_MAX_ALL_CHANNELS</A></TD>
  62         <TD>Calculate the peak value for each channel.</TD>
  63 </TR>
  64 <TR>
  65         <TD><A HREF="#SFC_CALC_NORM_MAX_ALL_CHANNELS">SFC_CALC_NORM_MAX_ALL_CHANNELS</A></TD>
  66         <TD>Calculate the normalised peak for each channel.</TD>
  67 </TR>
  68
  69 <TR>
  70         <TD><A HREF="#SFC_GET_SIGNAL_MAX">SFC_GET_SIGNAL_MAX</A></TD>
  71         <TD>Retrieve the peak value for the file (as stored in the file header).</TD>
  72 </TR>
  73 <TR>
  74         <TD><A HREF="#SFC_GET_MAX_ALL_CHANNELS">SFC_GET_MAX_ALL_CHANNELS</A></TD>
  75         <TD>Retrieve the peak value for each channel  (as stored in the file header).</TD>
  76 </TR>
  77
  78 <TR>
  79         <TD><A HREF="#SFC_SET_NORM_FLOAT">SFC_SET_NORM_FLOAT</A></TD>
  80         <TD>Modify the normalisation behaviour of the floating point reading and writing functions.</TD>
  81 </TR>
  82 <TR>
  83         <TD><A HREF="#SFC_SET_NORM_DOUBLE">SFC_SET_NORM_DOUBLE</A></TD>
  84         <TD>Modify the normalisation behaviour of the double precision floating point reading and writing functions.</TD>
  85 </TR>
  86 <TR>
  87         <TD><A HREF="#SFC_GET_NORM_FLOAT">SFC_GET_NORM_FLOAT</A></TD>
  88         <TD>Retrieve the current normalisation behaviour of the floating point reading and writing functions.</TD>
  89 </TR>
  90 <TR>
  91         <TD><A HREF="#SFC_GET_NORM_DOUBLE">SFC_GET_NORM_DOUBLE</A></TD>
  92         <TD>Retrieve the current normalisation behaviour of the double precision floating point reading and writing functions.</TD>
  93 </TR>
  94 <TR>
  95         <TD><A HREF="#SFC_SET_SCALE_FLOAT_INT_READ">SFC_SET_SCALE_FLOAT_INT_READ</A></TD>
  96         <TD>Set/clear the scale factor when integer (short/int) data is read from a file
  97         containing floating point data.</TD>
  98 </TR>
  99
 100 <TR>
 101         <TD><A HREF="#SFC_SET_SCALE_INT_FLOAT_WRITE">SFC_SET_SCALE_INT_FLOAT_WRITE</A></TD>
 102         <TD>Set/clear the scale factor when integer (short/int) data is written to a file
 103         as floating point data.</TD>
 104 </TR>
 105
 106 <TR>
 107         <TD><A HREF="#SFC_GET_SIMPLE_FORMAT_COUNT">SFC_GET_SIMPLE_FORMAT_COUNT</A></TD>
 108         <TD>Retrieve the number of simple formats supported by libsndfile.</TD>
 109 </TR>
 110 <TR>
 111         <TD><A HREF="#SFC_GET_SIMPLE_FORMAT">SFC_GET_SIMPLE_FORMAT</A></TD>
 112         <TD>Retrieve information about a simple format.</TD>
 113 </TR>
 114
 115 <TR>
 116         <TD><A HREF="#SFC_GET_FORMAT_INFO">SFC_GET_FORMAT_INFO</A></TD>
 117         <TD>Retrieve information about a major or subtype format.</TD>
 118 </TR>
 119
 120 <TR>
 121         <TD><A HREF="#SFC_GET_FORMAT_MAJOR_COUNT">SFC_GET_FORMAT_MAJOR_COUNT</A></TD>
 122         <TD>Retrieve the number of major formats.</TD>
 123 </TR>
 124 <TR>
 125         <TD><A HREF="#SFC_GET_FORMAT_MAJOR">SFC_GET_FORMAT_MAJOR</A></TD>
 126         <TD>Retrieve information about a major format type.</TD>
 127 </TR>
 128 <TR>
 129         <TD><A HREF="#SFC_GET_FORMAT_SUBTYPE_COUNT">SFC_GET_FORMAT_SUBTYPE_COUNT</A></TD>
 130         <TD>Retrieve the number of subformats.</TD>
 131 </TR>
 132 <TR>
 133         <TD><A HREF="#SFC_GET_FORMAT_SUBTYPE">SFC_GET_FORMAT_SUBTYPE</A></TD>
 134         <TD>Retrieve information about a subformat.</TD>
 135 </TR>
 136
 137 <TR>
 138         <TD><A HREF="#SFC_SET_ADD_PEAK_CHUNK">SFC_SET_ADD_PEAK_CHUNK</A></TD>
 139         <TD>Switch the code for adding the PEAK chunk to WAV and AIFF files on or off.</TD>
 140 </TR>
 141
 142 <TR>
 143         <TD><A HREF="#SFC_UPDATE_HEADER_NOW">SFC_UPDATE_HEADER_NOW</A></TD>
 144         <TD>Used when a file is open for write, this command will update the file
 145                 header to reflect the data written so far.</TD>
 146 </TR>
 147 <TR>
 148         <TD><A HREF="#SFC_SET_UPDATE_HEADER_AUTO">SFC_SET_UPDATE_HEADER_AUTO</A></TD>
 149         <TD>Used when a file is open for write, this command will cause the file header
 150                 to be updated after each write to the file.</TD>
 151 </TR>
 152
 153 <TR>
 154         <TD><A HREF="#SFC_FILE_TRUNCATE">SFC_FILE_TRUNCATE</A></TD>
 155         <TD>Truncate a file open for write or for read/write.</TD>
 156 </TR>
 157
 158 <TR>
 159         <TD><A HREF="#SFC_SET_RAW_START_OFFSET">SFC_SET_RAW_START_OFFSET</A></TD>
 160         <TD>Change the data start offset for files opened up as SF_FORMAT_RAW.</TD>
 161 </TR>
 162
 163 <TR>
 164         <TD><A HREF="#SFC_SET_CLIPPING">SFC_SET_CLIPPING</A></TD>
 165         <TD>Turn on/off automatic clipping when doing floating point to integer
 166                 conversion.</TD>
 167 </TR>
 168
 169 <TR>
 170         <TD><A HREF="#SFC_GET_CLIPPING">SFC_GET_CLIPPING</A></TD>
 171         <TD>Retrieve current clipping setting.</TD>
 172 </TR>
 173
 174 <TR>
 175         <TD><A HREF="#SFC_GET_EMBED_FILE_INFO">SFC_GET_EMBED_FILE_INFO</A></TD>
 176         <TD>Retrieve information about audio files embedded inside other files.</TD>
 177 </TR>
 178
 179 <TR>
 180         <TD><A HREF="#SFC_WAVEX_GET_AMBISONIC">SFC_GET_AMBISONIC</A></TD>
 181         <TD>Test a WAVEX file for Ambisonic format</TD>
 182 </TR>
 183
 184 <TR>
 185         <TD><A HREF="#SFC_WAVEX_SET_AMBISONIC">SFC_SET_AMBISONIC</A></TD>
 186         <TD>Modify a WAVEX header for Ambisonic format</TD>
 187 </TR>
 188
 189 <TR>
 190         <TD><A HREF="#SFC_SET_VBR_ENCODING_QUALITY">SFC_SET_VBR_ENCODING_QUALITY</A></TD>
 191         <TD>Set the the Variable Bit Rate encoding quality</TD>
 192 </TR>
 193
 194 <TR>
 195         <TD><A HREF="#SFC_RAW_NEEDS_ENDSWAP">SFC_RAW_NEEDS_ENDSWAP</a></td>
 196         <TD>Determine if raw data needs endswapping</TD>
 197 </TR>
 198
 199 <TR>
 200         <TD><A HREF="#SFC_GET_BROADCAST_INFO">SFC_GET_BROADCAST_INFO</A></TD>
 201         <TD>Retrieve the Broadcast Chunk info</TD>
 202 </TR>
 203
 204 <TR>
 205         <TD><A HREF="#SFC_SET_BROADCAST_INFO">SFC_SET_BROADCAST_INFO</A></TD>
 206         <TD>Set the Broadcast Chunk info</TD>
 207 </TR>
 208
 209 <TR>
 210         <TD><A HREF="#SFC_GET_LOOP_INFO">SFC_GET_LOOP_INFO</A></TD>
 211         <TD>Get loop info</TD>
 212 </TR>
 213
 214 <TR>
 215         <TD><A HREF="#SFC_GET_INSTRUMENT">SFC_GET_INSTRUMENT</A></TD>
 216         <TD>Get instrument info</TD>
 217 </TR>
 218
 219 <TR>
 220         <TD><A HREF="#SFC_SET_INSTRUMENT">SFC_SET_INSTRUMENT</A></TD>
 221         <TD>Set instrument info</TD>
 222 </TR>
 223
 224 <TR>
 225         <TD><A HREF="#SFC_SET_VBR_ENCODING_QUALITY">SFC_SET_VBR_ENCODING_QUALITY</A></TD>
 226         <TD>Set variable bit rate encoding quality</TD>
 227 </TR>
 228
 229
 230
 231 <!--
 232 <TR>
 233         <TD><A HREF="#add-dither">add dither</A></TD>
 234         <TD>Add dither to output on write.</TD>
 235 </TR>
 236 -->
 237 </TABLE>
 238 </CENTER>
 239
 240 <BR><BR>
 241
 242 <HR>
 243
 244 <!-- ========================================================================= -->
 245 <A NAME="SFC_GET_LIB_VERSION"></A>
 246 <H2><BR><B>SFC_GET_LIB_VERSION</B></H2>
 247 <P>
 248 Retrieve the version of the library as a string.
 249 </P>
 250 <P>
 251 Parameters:
 252 <PRE>
 253         sndfile  : Not used
 254         cmd      : SFC_GET_LIB_VERSION
 255         data     : A pointer to a char buffer
 256         datasize : The size of the the buffer
 257 </PRE>
 258 <P>
 259 Example:
 260 </P>
 261 <PRE>
 262         char  buffer [128] ;
 263         sf_command (NULL, SFC_GET_LIB_VERSION, buffer, sizeof (buffer)) ;
 264 </PRE>
 265
 266 <DL>
 267 <DT>Return value:</DT>
 268         <DD><DD>This call will return the length of the retrieved version string.
 269 </DL>
 270 <DL>
 271 <DT>Notes:</DT>
 272 <DD>
 273 The string returned in the buffer passed to this function will not overflow
 274 the buffer and will always be null terminated .
 275 </DL>
 276
 277 <!-- ========================================================================= -->
 278 <A NAME="SFC_GET_LOG_INFO"></A>
 279 <H2><BR><B>SFC_GET_LOG_INFO</B></H2>
 280 <P>
 281 Retrieve the log buffer generated when opening a file as a string. This log
 282 buffer can often contain a good reason for why libsndfile failed to open a
 283 particular file.
 284 </P>
 285 <P>
 286 Parameters:
 287 <PRE>
 288         sndfile  : A valid SNDFILE* pointer
 289         cmd      : SFC_GET_LOG_INFO
 290         data     : A pointer to a char buffer
 291         datasize : The size of the the buffer
 292 </PRE>
 293 <P>
 294 Example:
 295 </P>
 296 <PRE>
 297         char  buffer [2048] ;
 298         sf_command (sndfile, SFC_GET_LOG_INFO, buffer, sizeof (buffer)) ;
 299 </PRE>
 300
 301 <DL>
 302 <DT>Return value:</DT>
 303         <DD><DD>This call will return the length of the retrieved version string.
 304 </DL>
 305 <DL>
 306 <DT>Notes:</DT>
 307 <DD>
 308 The string returned in the buffer passed to this function will not overflow
 309 the buffer and will always be null terminated .
 310 </DL>
 311
 312 <!-- ========================================================================= -->
 313 <A NAME="SFC_CALC_SIGNAL_MAX"></A>
 314 <H2><BR><B>SFC_CALC_SIGNAL_MAX</B></H2>
 315 <P>
 316 Retrieve the measured maximum signal value. This involves reading through
 317 the whole file which can be slow on large files.
 318 </P>
 319 <P>
 320 Parameters:
 321 <PRE>
 322         sndfile  : A valid SNDFILE* pointer
 323         cmd      : SFC_CALC_SIGNAL_MAX
 324         data     : A pointer to a double
 325         datasize : sizeof (double)
 326 </PRE>
 327 <P>
 328 Example:
 329 </P>
 330 <PRE>
 331         double   max_val ;
 332         sf_command (sndfile, SFC_CALC_SIGNAL_MAX, &amp;max_val, sizeof (max_val)) ;
 333 </PRE>
 334
 335 <DL>
 336 <DT>Return value:</DT>
 337         <DD><DD>Zero on success, non-zero otherwise.
 338 </DL>
 339
 340 <!-- ========================================================================= -->
 341 <A NAME="SFC_CALC_NORM_SIGNAL_MAX"></A>
 342 <H2><BR><B>SFC_CALC_NORM_SIGNAL_MAX</B></H2>
 343 <P>
 344 Retrieve the measured normalised maximum signal value. This involves reading
 345 through the whole file which can be slow on large files.
 346 </P>
 347 <P>
 348 Parameters:
 349 <PRE>
 350         sndfile  : A valid SNDFILE* pointer
 351         cmd      : SFC_CALC_NORM_SIGNAL_MAX
 352         data     : A pointer to a double
 353         datasize : sizeof (double)
 354 </PRE>
 355 <P>
 356 Example:
 357 </P>
 358 <PRE>
 359         double   max_val ;
 360         sf_command (sndfile, SFC_CALC_NORM_SIGNAL_MAX, &amp;max_val, sizeof (max_val)) ;
 361 </PRE>
 362
 363 <DL>
 364 <DT>Return value:</DT>
 365         <DD><DD>Zero on success, non-zero otherwise.
 366 </DL>
 367
 368 <!-- ========================================================================= -->
 369 <A NAME="SFC_CALC_MAX_ALL_CHANNELS"></A>
 370 <H2><BR><B>SFC_CALC_MAX_ALL_CHANNELS</B></H2>
 371 <P>
 372 Calculate the peak value (ie a single number) for each channel.
 373 This involves reading through the whole file which can be slow on large files.
 374 </P>
 375 <P>
 376 Parameters:
 377 <PRE>
 378         sndfile  : A valid SNDFILE* pointer
 379         cmd      : SFC_CALC_MAX_ALL_CHANNELS
 380         data     : A pointer to a double
 381         datasize : sizeof (double) * number_of_channels
 382 </PRE>
 383 <P>
 384 Example:
 385 </P>
 386 <PRE>
 387         double   peaks [number_of_channels] ;
 388         sf_command (sndfile, SFC_CALC_MAX_ALL_CHANNELS, peaks, sizeof (peaks)) ;
 389 </PRE>
 390 <DL>
 391 <DT>Return value:</DT>
 392         <DD>Zero if peaks have been calculated successfully and non-zero otherwise.
 393 </DL>
 394
 395
 396 <!-- ========================================================================= -->
 397 <A NAME="SFC_CALC_NORM_MAX_ALL_CHANNELS"></A>
 398 <H2><BR><B>SFC_CALC_NORM_MAX_ALL_CHANNELS</B></H2>
 399 <P>
 400 Calculate the normalised peak for each channel.
 401 This involves reading through the whole file which can be slow on large files.
 402 </P>
 403 <P>
 404 Parameters:
 405 <PRE>
 406         sndfile  : A valid SNDFILE* pointer
 407         cmd      : SFC_CALC_NORM_MAX_ALL_CHANNELS
 408         data     : A pointer to a double
 409         datasize : sizeof (double) * number_of_channels
 410 </PRE>
 411 <P>
 412 Example:
 413 </P>
 414 <PRE>
 415         double   peaks [number_of_channels] ;
 416         sf_command (sndfile, SFC_CALC_NORM_MAX_ALL_CHANNELS, peaks, sizeof (peaks)) ;
 417 </PRE>
 418 <DL>
 419 <DT>Return value:</DT>
 420         <DD>Zero if peaks have been calculated successfully and non-zero otherwise.
 421 </DL>
 422
 423
 424
 425
 426 <!-- ========================================================================= -->
 427 <A NAME="SFC_GET_SIGNAL_MAX"></A>
 428 <H2><BR><B>SFC_GET_SIGNAL_MAX</B></H2>
 429 <P>
 430 Retrieve the peak value for the file as stored in the file header.
 431 </P>
 432 <P>
 433 Parameters:
 434 <PRE>
 435         sndfile  : A valid SNDFILE* pointer
 436         cmd      : SFC_GET_SIGNAL_MAX
 437         data     : A pointer to a double
 438         datasize : sizeof (double)
 439 </PRE>
 440 <P>
 441 Example:
 442 </P>
 443 <PRE>
 444         double   max_peak ;
 445         sf_command (sndfile, SFC_GET_SIGNAL_MAX, &amp;max_peak, sizeof (max_peak)) ;
 446 </PRE>
 447 <DL>
 448 <DT>Return value:</DT>
 449         <DD>SF_TRUE if the file header contained the peak value. SF_FALSE otherwise.
 450 </DL>
 451
 452 <!-- ========================================================================= -->
 453 <A NAME="SFC_GET_MAX_ALL_CHANNELS"></A>
 454 <H2><BR><B>SFC_GET_MAX_ALL_CHANNELS</B></H2>
 455 <P>
 456 Retrieve the peak value for the file as stored in the file header.
 457 </P>
 458 <P>
 459 Parameters:
 460 <PRE>
 461         sndfile  : A valid SNDFILE* pointer
 462         cmd      : SFC_GET_SIGNAL_MAX
 463         data     : A pointer to an array of doubles
 464         datasize : sizeof (double) * number_of_channels
 465 </PRE>
 466 <P>
 467 Example:
 468 </P>
 469 <PRE>
 470         double   peaks [number_of_channels] ;
 471         sf_command (sndfile, SFC_GET_MAX_ALL_CHANNELS, peaks, sizeof (peaks)) ;
 472 </PRE>
 473 <DL>
 474 <DT>Return value:</DT>
 475         <DD>SF_TRUE if the file header contains per channel peak values for the file.
 476                 SF_FALSE otherwise.
 477 </DL>
 478
 479
 480 <!-- ========================================================================= -->
 481 <A NAME="SFC_SET_NORM_FLOAT"></A>
 482 <H2><BR><B>SFC_SET_NORM_FLOAT</B></H2>
 483 <P>
 484 This command only affects data read from or written to using the floating point functions:
 485 </P>
 486 <PRE>
 487         size_t    <A HREF="api.html#read">sf_read_float</A>    (SNDFILE *sndfile, float *ptr, size_t items) ;
 488         size_t    <A HREF="api.html#readf">sf_readf_float</A>   (SNDFILE *sndfile, float *ptr, size_t frames) ;
 489
 490         size_t    <A HREF="api.html#write">sf_write_float</A>   (SNDFILE *sndfile, float *ptr, size_t items) ;
 491         size_t    <A HREF="api.html#writef">sf_writef_float</A>  (SNDFILE *sndfile, float *ptr, size_t frames) ;
 492 </PRE>
 493 <P>
 494 Parameters:
 495 </P>
 496 <PRE>
 497         sndfile  : A valid SNDFILE* pointer
 498         cmd      : SFC_SET_NORM_FLOAT
 499         data     : NULL
 500         datasize : SF_TRUE or SF_FALSE
 501 </PRE>
 502 <P>
 503 For read operations setting normalisation to SF_TRUE means that the data from all
 504 subsequent reads will be be normalised to the range [-1.0, 1.0].
 505 </P>
 506 <P>
 507 For write operations, setting normalisation to SF_TRUE means than all data supplied
 508 to the float write functions should be in the range [-1.0, 1.0] and will be scaled
 509 for the file format as necessary.
 510 </P>
 511 <P>
 512 For both cases, setting normalisation to SF_FALSE means that no scaling will take place.
 513 </P>
 514 <P>
 515 Example:
 516 </P>
 517 <PRE>
 518         sf_command (sndfile, SFC_SET_NORM_FLOAT, NULL, SF_TRUE) ;
 519
 520         sf_command (sndfile, SFC_SET_NORM_FLOAT, NULL, SF_FALSE) ;
 521 </PRE>
 522 <DL>
 523 <DT>Return value: </DT>
 524         <DD>Returns the previous float normalisation mode.
 525 </DL>
 526
 527 <!-- ========================================================================= -->
 528 <A NAME="SFC_SET_NORM_DOUBLE"></A>
 529 <H2><BR><B>SFC_SET_NORM_DOUBLE</B></H2>
 530 <P>
 531 This command only affects data read from or written to using the double precision
 532 floating point functions:
 533 </P>
 534 <PRE>
 535         size_t    <A HREF="api.html#read">sf_read_double</A>    (SNDFILE *sndfile, double *ptr, size_t items) ;
 536         size_t    <A HREF="api.html#readf">sf_readf_double</A>   (SNDFILE *sndfile, double *ptr, size_t frames) ;
 537
 538         size_t    <A HREF="api.html#write">sf_write_double</A>   (SNDFILE *sndfile, double *ptr, size_t items) ;
 539         size_t    <A HREF="api.html#writef">sf_writef_double</A>  (SNDFILE *sndfile, double *ptr, size_t frames) ;
 540 </PRE>
 541 <P>
 542 Parameters:
 543 </P>
 544 <PRE>
 545         sndfile  : A valid SNDFILE* pointer
 546         cmd      : SFC_SET_NORM_DOUBLE
 547         data     : NULL
 548         datasize : SF_TRUE or SF_FALSE
 549 </PRE>
 550 <P>
 551 For read operations setting normalisation to SF_TRUE means that the data
 552 from all subsequent reads will be be normalised to the range [-1.0, 1.0].
 553 </P>
 554 <P>
 555 For write operations, setting normalisation to SF_TRUE means than all data supplied
 556 to the double write functions should be in the range [-1.0, 1.0] and will be scaled
 557 for the file format as necessary.
 558 </P>
 559 <P>
 560 For both cases, setting normalisation to SF_FALSE means that no scaling will take place.
 561 </P>
 562 <P>
 563 Example:
 564 </P>
 565 <PRE>
 566         sf_command (sndfile, SFC_SET_NORM_DOUBLE, NULL, SF_TRUE) ;
 567
 568         sf_command (sndfile, SFC_SET_NORM_DOUBLE, NULL, SF_FALSE) ;
 569 </PRE>
 570 <DL>
 571 <DT>Return value: </DT>
 572         <DD>Returns the previous double normalisation mode.
 573 </DL>
 574
 575 <!-- ========================================================================= -->
 576 <A NAME="SFC_GET_NORM_FLOAT"></A>
 577 <H2><BR><B>SFC_GET_NORM_FLOAT</B></H2>
 578 <P>
 579 Retrieve the current float normalisation mode.
 580 </P>
 581 <P>
 582 Parameters:
 583 </P>
 584 <PRE>
 585         sndfile  : A valid SNDFILE* pointer
 586         cmd      : SFC_GET_NORM_FLOAT
 587         data     : NULL
 588         datasize : anything
 589 </PRE>
 590 <P>
 591 Example:
 592 </P>
 593 <PRE>
 594         normalisation = sf_command (sndfile, SFC_GET_NORM_FLOAT, NULL, 0) ;
 595 </PRE>
 596 <DL>
 597 <DT>Return value: </DT>
 598         <DD>Returns TRUE if normalisation is on and FALSE otherwise.
 599 </DL>
 600
 601 <!-- ========================================================================= -->
 602 <A NAME="SFC_GET_NORM_DOUBLE"></A>
 603 <H2><BR><B>SFC_GET_NORM_DOUBLE</B></H2>
 604 <P>
 605 Retrieve the current float normalisation mode.
 606 </P>
 607 <P>
 608 Parameters:
 609 </P>
 610 <PRE>
 611         sndfile  : A valid SNDFILE* pointer
 612         cmd      : SFC_GET_NORM_DOUBLE
 613         data     : NULL
 614         datasize : anything
 615 </PRE>
 616 <P>
 617 Example:
 618 </P>
 619 <PRE>
 620         normalisation = sf_command (sndfile, SFC_GET_NORM_DOUBLE, NULL, 0) ;
 621 </PRE>
 622 <DL>
 623 <DT>Return value: </DT>
 624         <DD>Returns TRUE if normalisation is on and FALSE otherwise.
 625 </DL>
 626
 627
 628 <!-- ========================================================================= -->
 629 <A NAME="SFC_SET_SCALE_FLOAT_INT_READ"></A>
 630 <H2><BR><B>SFC_SET_SCALE_FLOAT_INT_READ</B></H2>
 631 <P>
 632 Set/clear the scale factor when integer (short/int) data is read from a file
 633 containing floating point data.
 634 </P>
 635 <P>
 636 Parameters:
 637 </P>
 638 <PRE>
 639         sndfile  : A valid SNDFILE* pointer
 640         cmd      : SFC_SET_SCALE_FLOAT_INT_READ
 641         data     : NULL
 642         datasize : TRUE or FALSE
 643 </PRE>
 644 <P>
 645 Example:
 646 </P>
 647 <PRE>
 648         sf_command (sndfile, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE) ;
 649 </PRE>
 650 <DL>
 651 <DT>Return value: </DT>
 652         <DD>Returns the previous SFC_SET_SCALE_FLOAT_INT_READ setting for this file.
 653 </DL>
 654
 655
 656 <!-- ========================================================================= -->
 657 <A NAME="SFC_SET_SCALE_INT_FLOAT_WRITE"></A>
 658 <H2><BR><B>SFC_SET_SCALE_INT_FLOAT_WRITE</B></H2>
 659 <P>
 660 Set/clear the scale factor when integer (short/int) data is written to a file
 661 as floating point data.
 662 </P>
 663 <P>
 664 Parameters:
 665 </P>
 666 <PRE>
 667         sndfile  : A valid SNDFILE* pointer
 668         cmd      : SFC_SET_SCALE_FLOAT_INT_READ
 669         data     : NULL
 670         datasize : TRUE or FALSE
 671 </PRE>
 672 <P>
 673 Example:
 674 </P>
 675 <PRE>
 676         sf_command (sndfile, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE) ;
 677 </PRE>
 678 <DL>
 679 <DT>Return value: </DT>
 680         <DD>Returns the previous SFC_SET_SCALE_INT_FLOAT_WRITE setting for this file.
 681 </DL>
 682
 683 <!-- ========================================================================= -->
 684 <A NAME="SFC_GET_SIMPLE_FORMAT_COUNT"></A>
 685 <H2><BR><B>SFC_GET_SIMPLE_FORMAT_COUNT</B></H2>
 686 <P>
 687 Retrieve the number of simple formats supported by libsndfile.
 688 </P>
 689 <P>
 690 Parameters:
 691 </P>
 692 <PRE>
 693         sndfile  : Not used.
 694         cmd      : SFC_GET_SIMPLE_FORMAT_COUNT
 695         data     : a pointer to an int
 696         datasize : sizeof (int)
 697 </PRE>
 698 <P>
 699 Example:
 700 </P>
 701 <PRE>
 702         int  count ;
 703         sf_command (sndfile, SFC_GET_SIMPLE_FORMAT_COUNT, &amp;count, sizeof (int)) ;
 704 </PRE>
 705 <DL>
 706 <DT>Return value: </DT>
 707         <DD>0
 708 </DL>
 709
 710 <!-- ========================================================================= -->
 711 <A NAME="SFC_GET_SIMPLE_FORMAT"></A>
 712 <H2><BR><B>SFC_GET_SIMPLE_FORMAT</B></H2>
 713 <P>
 714 Retrieve information about a simple format.
 715 </P>
 716 <P>
 717 Parameters:
 718 </P>
 719 <PRE>
 720         sndfile  : Not used.
 721         cmd      : SFC_GET_SIMPLE_FORMAT
 722         data     : a pointer to an  SF_FORMAT_INFO struct
 723         datasize : sizeof (SF_FORMAT_INFO)
 724 </PRE>
 725 <P>
 726 The SF_FORMAT_INFO struct is defined in &lt;sndfile.h&gt; as:
 727 </P>
 728 <PRE>
 729         typedef struct
 730         {   int         format ;
 731             const char  *name ;
 732             const char  *extension ;
 733         } SF_FORMAT_INFO ;
 734 </PRE>
 735 <P>
 736 When sf_command() is called with SF_GET_SIMPLE_FORMAT, the value of the format
 737 field should be the format number (ie 0 &lt;= format &lt;= count value obtained using
 738 SF_GET_SIMPLE_FORMAT_COUNT).
 739 </P>
 740 <P>
 741 Example:
 742 </P>
 743 <PRE>
 744         SF_FORMAT_INFO  format_info ;
 745         int             k, count ;
 746
 747         sf_command (sndfile, SFC_GET_SIMPLE_FORMAT_COUNT, &amp;count, sizeof (int)) ;
 748
 749         for (k = 0 ; k &lt; count ; k++)
 750         {   format_info.format = k ;
 751             sf_command (sndfile, SFC_GET_SIMPLE_FORMAT, &amp;format_info, sizeof (format_info)) ;
 752             printf ("%08x  %s %s\n", format_info.format, format_info.name, format_info.extension) ;
 753             } ;
 754 </PRE>
 755 <DL>
 756 <DT>Return value: </DT>
 757         <DD>0 on success and non-zero otherwise.
 758         <DD>The value of the format field of the SF_FORMAT_INFO struct will be a value which
 759                 can be placed in the format field of an SF_INFO struct when a file is to be opened
 760                 for write.
 761         <DD>The name field will contain a char* pointer to the name of the string, eg. "WAV (Microsoft 16 bit PCM)".
 762         <DD>The extension field will contain the most commonly used file extension for that file type.
 763 </DL>
 764
 765 <!-- ========================================================================= -->
 766 <A NAME="SFC_GET_FORMAT_INFO"></A>
 767 <H2><BR><B>SFC_GET_FORMAT_INFO</B></H2>
 768 <P>
 769 Retrieve information about a major or subtype format.
 770 </P>
 771 <P>
 772 Parameters:
 773 </P>
 774 <PRE>
 775         sndfile  : Not used.
 776         cmd      : SFC_GET_FORMAT_INFO
 777         data     : a pointer to an SF_FORMAT_INFO struct
 778         datasize : sizeof (SF_FORMAT_INFO)
 779 </PRE>
 780 <P>
 781 The SF_FORMAT_INFO struct is defined in &lt;sndfile.h&gt; as:
 782 </P>
 783 <PRE>
 784         typedef struct
 785         {   int         format ;
 786             const char  *name ;
 787             const char  *extension ;
 788         } SF_FORMAT_INFO ;
 789 </PRE>
 790 <P>
 791 When sf_command() is called with SF_GET_FORMAT_INFO, the format field is
 792 examined and if (format &amp; SF_FORMAT_TYPEMASK) is a valid format then the struct
 793 is filled in with information about the given major type.
 794 If (format &amp; SF_FORMAT_TYPEMASK) is FALSE and (format &amp; SF_FORMAT_SUBMASK) is a
 795 valid subtype format then the struct is filled in with information about the given
 796 subtype.
 797 </P>
 798 <P>
 799 Example:
 800 </P>
 801 <PRE>
 802         SF_FORMAT_INFO  format_info ;
 803
 804         format_info.format = SF_FORMAT_WAV ;
 805         sf_command (sndfile, SFC_GET_FORMAT_INFO, &amp;format_info, sizeof (format_info)) ;
 806         printf ("%08x  %s %s\n", format_info.format, format_info.name, format_info.extension) ;
 807
 808         format_info.format = SF_FORMAT_ULAW ;
 809         sf_command (sndfile, SFC_GET_FORMAT_INFO, &amp;format_info, sizeof (format_info)) ;
 810         printf ("%08x  %s\n", format_info.format, format_info.name) ;
 811 </PRE>
 812 <DL>
 813 <DT>Return value: </DT>
 814         <DD>0 on success and non-zero otherwise.
 815 </DL>
 816 <!-- ========================================================================= -->
 817 <A NAME="SFC_GET_FORMAT_MAJOR_COUNT"></A>
 818 <H2><BR><B>SFC_GET_FORMAT_MAJOR_COUNT</B></H2>
 819 <P>
 820 Retrieve the number of major formats.
 821 </P>
 822 <P>
 823 Parameters:
 824 </P>
 825 <PRE>
 826         sndfile  : Not used.
 827         cmd      : SFC_GET_FORMAT_MAJOR_COUNT
 828         data     : a pointer to an int
 829         datasize : sizeof (int)
 830 </PRE>
 831 <P>
 832 Example:
 833 </P>
 834 <PRE>
 835         int  count ;
 836         sf_command (sndfile, SFC_GET_FORMAT_MAJOR_COUNT, &amp;count, sizeof (int)) ;
 837 </PRE>
 838 <DL>
 839 <DT>Return value: </DT>
 840         <DD>0
 841 </DL>
 842
 843 <!-- ========================================================================= -->
 844 <A NAME="SFC_GET_FORMAT_MAJOR"></A>
 845 <H2><BR><B>SFC_GET_FORMAT_MAJOR</B></H2>
 846 <P>
 847 Retrieve information about a major format type.
 848 </P>
 849 <P>
 850 Parameters:
 851 </P>
 852 <PRE>
 853         sndfile  : Not used.
 854         cmd      : SFC_GET_FORMAT_MAJOR
 855         data     : a pointer to an  SF_FORMAT_INFO struct
 856         datasize : sizeof (SF_FORMAT_INFO)
 857 </PRE>
 858 <P>
 859 Example:
 860 </P>
 861 <PRE>
 862         SF_FORMAT_INFO  format_info ;
 863         int             k, count ;
 864
 865         sf_command (sndfile, SFC_GET_FORMAT_MAJOR_COUNT, &amp;count, sizeof (int)) ;
 866
 867         for (k = 0 ; k &lt; count ; k++)
 868         {   format_info.format = k ;
 869             sf_command (sndfile, SFC_GET_FORMAT_MAJOR, &amp;format_info, sizeof (format_info)) ;
 870             printf ("%08x  %s %s\n", format_info.format, format_info.name, format_info.extension) ;
 871             } ;
 872 </PRE>
 873 <P>
 874 For a more comprehensive example, see the program list_formats.c in the examples/
 875 directory of the libsndfile source code distribution.
 876 </P>
 877 <DL>
 878 <DT>Return value: </DT>
 879         <DD>0 on success and non-zero otherwise.
 880         <DD>The value of the format field will be one of the major format identifiers such as
 881                 SF_FORMAT_WAV or SF_FORMAT_AIFF.
 882         <DD>The name field will contain a char* pointer to the name of the string, eg. "WAV (Microsoft)".
 883         <DD>The extension field will contain the most commonly used file extension for that file type.
 884 </DL>
 885
 886 <!-- ========================================================================= -->
 887 <A NAME="SFC_GET_FORMAT_SUBTYPE_COUNT"></A>
 888 <H2><BR><B>SFC_GET_FORMAT_SUBTYPE_COUNT</B></H2>
 889 <P>
 890 Retrieve the number of subformats.
 891 </P>
 892 <P>
 893 Parameters:
 894 </P>
 895 <PRE>
 896         sndfile  : Not used.
 897         cmd      : SFC_GET_FORMAT_SUBTYPE_COUNT
 898         data     : a pointer to an int
 899         datasize : sizeof (int)
 900 </PRE>
 901 <P>
 902 Example:
 903 </P>
 904 <PRE>
 905         int   count ;
 906         sf_command (sndfile, SFC_GET_FORMAT_SUBTYPE_COUNT, &amp;count, sizeof (int)) ;
 907 </PRE>
 908 <DL>
 909 <DT>Return value: </DT>
 910         <DD>0
 911 </DL>
 912
 913 <!-- ========================================================================= -->
 914 <A NAME="SFC_GET_FORMAT_SUBTYPE"></A>
 915 <H2><BR><B>SFC_GET_FORMAT_SUBTYPE</B></H2>
 916 <P>
 917 Enumerate the subtypes (this function does not translate a subtype into
 918 a string describing that subtype).
 919 A typical use case might be retrieving a string description of all subtypes
 920 so that a dialog box can be filled in.
 921 </P>
 922 <P>
 923
 924 </P>
 925 <P>
 926 Parameters:
 927 </P>
 928 <PRE>
 929         sndfile  : Not used.
 930         cmd      : SFC_GET_FORMAT_SUBTYPE
 931         data     : a pointer to an SF_FORMAT_INFO struct
 932         datasize : sizeof (SF_FORMAT_INFO)
 933 </PRE>
 934 <P>
 935 Example 1: Retrieve all sybtypes supported by the WAV format.
 936 </P>
 937 <PRE>
 938         SF_FORMAT_INFO  format_info ;
 939         int             k, count ;
 940
 941         sf_command (sndfile, SFC_GET_FORMAT_SUBTYPE_COUNT, &amp;count, sizeof (int)) ;
 942
 943         for (k = 0 ; k &lt; count ; k++)
 944         {   format_info.format = k ;
 945             sf_command (sndfile, SFC_GET_FORMAT_SUBTYPE, &amp;format_info, sizeof (format_info)) ;
 946             if (! sf_format_check (format_info.format | SF_FORMAT_WAV))
 947                continue ;
 948             printf ("%08x  %s\n", format_info.format, format_info.name) ;
 949             } ;
 950 </PRE>
 951 <P>
 952 Example 2: Print a string describing the SF_FORMAT_PCM_16 subtype.
 953 </P>
 954 <PRE>
 955         SF_FORMAT_INFO  format_info ;
 956         int             k, count ;
 957
 958         sf_command (sndfile, SFC_GET_FORMAT_SUBTYPE_COUNT, &amp;count, sizeof (int)) ;
 959
 960         for (k = 0 ; k &lt; count ; k++)
 961         {   format_info.format = k ;
 962             sf_command (sndfile, SFC_GET_FORMAT_SUBTYPE, &amp;format_info, sizeof (format_info)) ;
 963             if (format_info.format == SF_FORMAT_PCM_16)
 964             {   printf ("%08x  %s\n", format_info.format, format_info.name) ;
 965                 break ;
 966                 } ;
 967             } ;
 968 </PRE>
 969 <P>
 970 For a more comprehensive example, see the program list_formats.c in the examples/
 971 directory of the libsndfile source code distribution.
 972 </P>
 973 <DL>
 974 <DT>Return value: </DT>
 975         <DD>0 on success and non-zero otherwise.
 976         <DD>The value of the format field will be one of the major format identifiers such as
 977                 SF_FORMAT_WAV or SF_FORMAT_AIFF.
 978         <DD>The name field will contain a char* pointer to the name of the string; for instance
 979                 "WAV (Microsoft)" or "AIFF (Apple/SGI)".
 980         <DD>The extension field will be a NULL pointer.
 981 </DL>
 982
 983 <!-- ========================================================================= -->
 984 <A NAME="SFC_SET_ADD_PEAK_CHUNK"></A>
 985 <H2><BR><B>SFC_SET_ADD_PEAK_CHUNK</B></H2>
 986 <P>
 987 By default, WAV and AIFF files which contain floating point data (subtype SF_FORMAT_FLOAT
 988 or SF_FORMAT_DOUBLE) have a PEAK chunk.
 989 By using this command, the addition of a PEAK chunk can be turned on or off.
 990 </P>
 991 <P>
 992 Note : This call must be made before any data is written to the file.
 993 </P>
 994 <P>
 995 Parameters:
 996 <PRE>
 997         sndfile  : A valid SNDFILE* pointer
 998         cmd      : SFC_SET_ADD_PEAK_CHUNK
 999         data     : Not used (should be NULL)
1000         datasize : TRUE or FALSE.
1001 </PRE>
1002 <P>
1003 Example:
1004 </P>
1005 <PRE>
1006         /* Turn on the PEAK chunk. */
1007         sf_command (sndfile, SFC_SET_ADD_PEAK_CHUNK, NULL, SF_TRUE) ;
1008
1009         /* Turn off the PEAK chunk. */
1010         sf_command (sndfile, SFC_SET_ADD_PEAK_CHUNK, NULL, SF_FALSE) ;
1011 </PRE>
1012 <DL>
1013 <DT>Return value:</DT>
1014 <DD>Returns SF_TRUE if the peak chunk will be written after this call.
1015 <DD>Returns SF_FALSE if the peak chunk will not be written after this call.
1016 </DL>
1017
1018 <!-- ========================================================================= -->
1019 <A NAME="SFC_UPDATE_HEADER_NOW"></A>
1020 <H2><BR><B>SFC_UPDATE_HEADER_NOW</B></H2>
1021 <P>
1022 The header of an audio file is normally written by libsndfile when the file is
1023 closed using <B>sf_close()</B>.
1024 </P>
1025 <P>
1026 There are however situations where large files are being generated and it would
1027 be nice to have valid data in the header before the file is complete.
1028 Using this command will update the file header to reflect the amount of data written
1029 to the file so far.
1030 Other programs opening the file for read (before any more data is written) will
1031 then read a valid sound file header.
1032 </P>
1033 <P>
1034 Parameters:
1035 <PRE>
1036         sndfile  : A valid SNDFILE* pointer
1037         cmd      : SFC_UPDATE_HEADER_NOW
1038         data     : Not used (should be NULL)
1039         datasize : Not used.
1040 </PRE>
1041 <P>
1042 Example:
1043 </P>
1044 <PRE>
1045         /* Update the header now. */
1046         sf_command (sndfile, SFC_UPDATE_HEADER_NOW, NULL, 0) ;
1047 </PRE>
1048 <DL>
1049 <DT>Return value:</DT>
1050 <DD>0
1051 </DL>
1052
1053 <!-- ========================================================================= -->
1054 <A NAME="SFC_SET_UPDATE_HEADER_AUTO"></A>
1055 <H2><BR><B>SFC_SET_UPDATE_HEADER_AUTO</B></H2>
1056 <P>
1057 Similar to SFC_UPDATE_HEADER_NOW but updates the header at the end of every call
1058 to the <B>sf_write*</B> functions.
1059 </P>
1060 <P>
1061 Parameters:
1062 <PRE>
1063         sndfile  : A valid SNDFILE* pointer
1064         cmd      : SFC_UPDATE_HEADER_NOW
1065         data     : Not used (should be NULL)
1066         datasize : SF_TRUE or SF_FALSE
1067 </PRE>
1068 <P>
1069 Example:
1070 </P>
1071 <PRE>
1072         /* Turn on auto header update. */
1073         sf_command (sndfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_TRUE) ;
1074
1075         /* Turn off auto header update. */
1076         sf_command (sndfile, SFC_SET_UPDATE_HEADER_AUTO, NULL, SF_FALSE) ;
1077 </PRE>
1078 <DL>
1079 <DT>Return value:</DT>
1080 <DD>TRUE if auto update header is now on; FALSE otherwise.
1081 </DL>
1082
1083 <!-- ========================================================================= -->
1084 <A NAME="SFC_FILE_TRUNCATE"></A>
1085 <H2><BR><B>SFC_FILE_TRUNCATE</B></H2>
1086 <P>
1087 Truncate a file that was opened for write or read/write.
1088 </P>
1089 <P>
1090 Parameters:
1091 <PRE>
1092         sndfile  : A valid SNDFILE* pointer
1093         cmd      : SFC_FILE_TRUNCATE
1094         data     : A pointer to an sf_count_t.
1095         datasize : sizeof (sf_count_t)
1096 </PRE>
1097
1098 <P>
1099 Truncate the file to the number of frames specified by the sf_count_t pointed
1100 to by data.
1101 After this command, both the read and the write pointer will be
1102 at the new end of the file.
1103 This command will fail (returning non-zero) if the requested truncate position
1104 is beyond the end of the file.
1105 </P>
1106 <P>
1107 Example:
1108 </P>
1109 <PRE>
1110         /* Truncate the file to a length of 20 frames. */
1111         sf_count_t  frames = 20 ;
1112         sf_command (sndfile, SFC_FILE_TRUNCATE, &amp;frames, sizeof (frames)) ;
1113 </PRE>
1114 <DL>
1115 <DT>Return value:</DT>
1116         <DD>Zero on sucess, non-zero otherwise.
1117 </DL>
1118
1119 <!-- ========================================================================= -->
1120 <A NAME="SFC_SET_RAW_START_OFFSET"></A>
1121 <H2><BR><B>SFC_SET_RAW_START_OFFSET</B></H2>
1122 <P>
1123 Change the data start offset for files opened up as SF_FORMAT_RAW.
1124 </P>
1125 <P>
1126 Parameters:
1127 <PRE>
1128         sndfile  : A valid SNDFILE* pointer
1129         cmd      : SFC_SET_RAW_START_OFFSET
1130         data     : A pointer to an sf_count_t.
1131         datasize : sizeof (sf_count_t)
1132 </PRE>
1133
1134 <P>
1135 For a file opened as format SF_FORMAT_RAW, set the data offset to the value
1136 given by data.
1137 </P>
1138 <P>
1139 Example:
1140 </P>
1141 <PRE>
1142         /* Reset the data offset to 5 bytes from the start of the file. */
1143         sf_count_t  offset = 5 ;
1144         sf_command (sndfile, SFC_SET_RAW_START_OFFSET, &amp;offset, sizeof (offset)) ;
1145 </PRE>
1146 <DL>
1147 <DT>Return value:</DT>
1148         <DD>Zero on success, non-zero otherwise.
1149 </DL>
1150
1151 <!-- ========================================================================= -->
1152 <A NAME="SFC_SET_CLIPPING"></A>
1153 <H2><BR><B>SFC_SET_CLIPPING</B></H2>
1154 <P>
1155 Turn on/off automatic clipping when doing floating point to integer conversion.
1156 </P>
1157 <P>
1158 Parameters:
1159 <PRE>
1160         sndfile  : A valid SNDFILE* pointer
1161         cmd      : SFC_SET_CLIPPING
1162         data     : NULL
1163         datasize : SF_TRUE or SF_FALSE.
1164 </PRE>
1165
1166 <P>
1167 Turn on (datasize == SF_TRUE) or off (datasize == SF_FALSE) clipping.
1168 </P>
1169 <P>
1170 Example:
1171 </P>
1172 <PRE>
1173         sf_command (sndfile, SFC_SET_CLIPPING, NULL, SF_TRUE) ;
1174 </PRE>
1175 <DL>
1176 <DT>Return value:</DT>
1177         <DD>Clipping mode (SF_TRUE or SF_FALSE).
1178 </DL>
1179
1180
1181 <!-- ========================================================================= -->
1182 <A NAME="SFC_GET_CLIPPING"></A>
1183 <H2><BR><B>SFC_GET_CLIPPING</B></H2>
1184 <P>
1185 Turn on/off automatic clipping when doing floating point to integer conversion.
1186 </P>
1187 <P>
1188 Parameters:
1189 <PRE>
1190         sndfile  : A valid SNDFILE* pointer
1191         cmd      : SFC_GET_CLIPPING
1192         data     : NULL
1193         datasize : 0
1194 </PRE>
1195
1196 <P>
1197 Retrieve the current cliiping setting.
1198 </P>
1199 <P>
1200 Example:
1201 </P>
1202 <PRE>
1203         sf_command (sndfile, SFC_GET_CLIPPING, NULL, 0) ;
1204 </PRE>
1205 <DL>
1206 <DT>Return value:</DT>
1207         <DD>Clipping mode (SF_TRUE or SF_FALSE).
1208 </DL>
1209
1210 <!-- ========================================================================= -->
1211 <A NAME="SFC_GET_EMBED_FILE_INFO"></A>
1212 <H2><BR><B>SFC_GET_EMBED_FILE_INFO</B></H2>
1213 <P>
1214 Get the file offset and file length of a file enbedded within another
1215 larger file.
1216 </P>
1217 <P>
1218 Parameters:
1219 <PRE>
1220         sndfile  : A valid SNDFILE* pointer
1221         cmd      : SFC_GET_CLIPPING
1222         data     : a pointer to an  SF_EMBED_FILE_INFO struct
1223         datasize : sizeof (SF_EMBED_FILE_INFO)
1224 </PRE>
1225 <P>
1226 The SF_EMBED_FILE_INFO struct is defined in &lt;sndfile.h&gt; as:
1227 </P>
1228 <PRE>
1229         typedef struct
1230         {   sf_count_t  offset ;
1231             sf_count_t  length ;
1232         } SF_EMBED_FILE_INFO ;
1233 </PRE>
1234 <DL>
1235 <DT>Return value: </DT>
1236         <DD>0 on success and non-zero otherwise.
1237         <DD>The value of the offset field of the SF_EMBED_FILE_INFO struct will be
1238                 the offsets in bytes from the start of the outer file to the start of
1239                 the audio file.
1240         <DD>The value of the offset field of the SF_EMBED_FILE_INFO struct will be
1241                 the length in bytes of the embedded file.
1242 </DL>
1243
1244
1245
1246 <!-- ========================================================================= -->
1247 <A NAME="SFC_WAVEX_GET_AMBISONIC"></A>
1248 <H2><BR><B>SFC_WAVEX_GET_AMBISONIC</B></H2>
1249 <P>
1250 Test if the current file has the GUID of a WAVEX file for any of the Ambisonic
1251 formats.
1252 </P>
1253 <P>
1254 Parameters:
1255 <PRE>
1256         sndfile  : A valid SNDFILE* pointer
1257         cmd      : SFC_WAVEX_GET_AMBISONIC
1258         data     : NULL
1259         datasize : 0
1260 </PRE>
1261 <P>
1262         The Ambisonic WAVEX formats are defined here :
1263                 <A HREF="http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html">
1264                         http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html</A>.
1265 </P>
1266 <DL>
1267 <DT>Return value: </DT>
1268         <DD>SF_AMBISONIC_NONE or SF_AMBISONIC_B_FORMAT or zero if the file format
1269                 does not support ambisonic formats.
1270 </DL>
1271
1272 <!-- ========================================================================= -->
1273 <A NAME="SFC_WAVEX_SET_AMBISONIC"></A>
1274 <H2><BR><B>SFC_WAVEX_SET_AMBISONIC</B></H2>
1275 <P>
1276 Set the GUID of a new WAVEX file to indicate an Ambisonics format.
1277 </P>
1278 <P>
1279 Parameters:
1280 <PRE>
1281         sndfile  : A valid SNDFILE* pointer
1282         cmd      : SFC_WAVEX_SET_AMBISONIC
1283         data     : NULL
1284         datasize : SF_AMBISONIC_NONE or SF_AMBISONIC_B_FORMAT
1285 </PRE>
1286 <P>
1287 Turn on (SF_AMBISONIC_B_FORMAT) or off (SF_AMBISONIC_NONE) encoding.
1288 This command is currently only supported for files with SF_FORMAT_WAVEX format.
1289 </P>
1290 <P>
1291         The Ambisonic WAVEX formats are defined here :
1292                 <A HREF="http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html">
1293                         http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html</A>.
1294 </P>
1295 <DL>
1296 <DT>Return value: </DT>
1297         <DD>Return the ambisonic value that has just been set or zero if the file
1298                 format does not support ambisonic encoding.
1299 </DL>
1300
1301 <!-- ========================================================================= -->
1302 <A NAME="SFC_SET_VBR_ENCODING_QUALITY"></A>
1303 <H2><BR><B>SFC_SET_VBR_ENCODING_QUALITY</B></H2>
1304 <P>
1305 Set the the Variable Bit Rate encoding quality.
1306 The encoding quality value should be between 0.0 (lowest quality) and 1.0
1307 (highest quality).
1308 </P>
1309 <P>
1310 Parameters:
1311 <PRE>
1312         sndfile  : A valid SNDFILE* pointer
1313         cmd      : SFC_SET_VBR_ENCODING_QUALITY
1314         data     : A pointer to a double value
1315         datasize : sizeof (double)
1316 </PRE>
1317 <P>
1318 The command must be sent before any audio data is written to the file.
1319 </P>
1320 <P>
1321 </P>
1322 <DL>
1323 <DT>Return value: </DT>
1324         <DD>Zero on success, non-zero otherwise.
1325 </DL>
1326
1327 <!-- ========================================================================= -->
1328 <A NAME="SFC_RAW_NEEDS_ENDSWAP"></A>
1329 <H2><BR><B>SFC_RAW_NEEDS_ENDSWAP</B></H2>
1330 <P>
1331 Determine if raw data read using
1332         <a href="api.html#raw">
1333         sf_read_raw</a>
1334 needs to be end swapped on the host CPU.
1335 </P>
1336 <P>
1337 For instance, will return SF_TRUE on when reading WAV containing
1338 SF_FORMAT_PCM_16 data on a big endian machine and SF_FALSE on a little endian
1339 machine.
1340 </P>
1341 <P>
1342 Parameters:
1343 <PRE>
1344         sndfile  : A valid SNDFILE* pointer
1345         cmd      : SFC_RAW_NEEDS_ENDSWAP
1346         data     : NULL
1347         datasize : 0
1348 </PRE>
1349
1350 <DL>
1351 <DT>Return value: </DT>
1352         <DD>SF_TRUE or SF_FALSE
1353 </DL>
1354
1355
1356 <!-- ========================================================================= -->
1357 <A NAME="SFC_GET_BROADCAST_INFO"></A>
1358 <H2><BR><B>SFC_GET_BROADCAST_INFO</B></H2>
1359 <P>
1360 Retrieve the Broadcast Extension Chunk from WAV (and related) files.
1361 </P>
1362 <p>
1363 Parameters:
1364 </p>
1365 <PRE>
1366         sndfile  : A valid SNDFILE* pointer
1367         cmd      : SFC_GET_BROADCAST_INFO
1368         data     : a pointer to an SF_BROADCAST_INFO struct
1369         datasize : sizeof (SF_BROADCAST_INFO)
1370 </PRE>
1371 <P>
1372 The SF_BROADCAST_INFO struct is defined in &lt;sndfile.h&gt; as:
1373 </P>
1374 <PRE>
1375     typedef struct
1376     {   char            description [256] ;
1377         char            originator [32] ;
1378         char            originator_reference [32] ;
1379         char            origination_date [10] ;
1380         char            origination_time [8] ;
1381         unsigned int    time_reference_low ;
1382         unsigned int    time_reference_high ;
1383         short           version ;
1384         char            umid [64] ;
1385         char            reserved [190] ;
1386         unsigned int    coding_history_size ;
1387         char            coding_history [256] ;
1388     } SF_BROADCAST_INFO ;
1389 </PRE>
1390
1391 <DL>
1392 <DT>Return value: </DT>
1393         <DD>SF_TRUE if the file contained a Broadcast Extension chunk or SF_FALSE
1394         otherwise.
1395 </DL>
1396
1397 <!-- ========================================================================= -->
1398 <A NAME="SFC_SET_BROADCAST_INFO"></A>
1399 <H2><BR><B>SFC_SET_BROADCAST_INFO</B></H2>
1400 <P>
1401 Set the Broadcast Extension Chunk for WAV (and related) files.
1402 </P>
1403 <p>
1404 Parameters:
1405 </p>
1406 <PRE>
1407         sndfile  : A valid SNDFILE* pointer
1408         cmd      : SFC_SET_BROADCAST_INFO
1409         data     : a pointer to an SF_BROADCAST_INFO struct
1410         datasize : sizeof (SF_BROADCAST_INFO)
1411 </PRE>
1412
1413 <DL>
1414 <DT>Return value: </DT>
1415         <DD>SF_TRUE if setting the Broadcast Extension chunk was successful and SF_FALSE
1416         otherwise.
1417 </DL>
1418 <!-- ========================================================================= -->
1419
1420 <A NAME="SFC_GET_LOOP_INFO"></A>
1421 <H2><BR><B>SFC_GET_LOOP_INFO</B></H2>
1422 <P>
1423 Retrieve loop information for file including time signature, length in
1424 beats and original MIDI base note
1425 </P>
1426 <p>
1427 Parameters:
1428 </p>
1429 <PRE>
1430          sndfile  : A valid SNDFILE* pointer
1431          cmd      : SFC_GET_LOOP_INFO
1432          data     : a pointer to an SF_LOOP_INFO struct
1433          datasize : sizeof (SF_LOOP_INFO)
1434 </PRE>
1435 <P>
1436 The SF_BROADCAST_INFO struct is defined in &lt;sndfile.h&gt; as:
1437 </P>
1438 <PRE>
1439         typedef struct
1440         {   short    time_sig_num ;   /* any positive integer    > 0  */
1441             short    time_sig_den ;   /* any positive power of 2 > 0  */
1442             int        loop_mode ;    /* see SF_LOOP enum             */
1443
1444             int        num_beats ;    /* this is NOT the amount of quarter notes !!!*/
1445                                       /* a full bar of 4/4 is 4 beats */
1446                                       /* a full bar of 7/8 is 7 beats */
1447
1448             float    bpm ;            /* suggestion, as it can be calculated using other fields:*/
1449                                       /* file's lenght, file's sampleRate and our time_sig_den*/
1450                                       /* -> bpms are always the amount of _quarter notes_ per minute */
1451
1452             int    root_key ;         /* MIDI note, or -1 for None */
1453             int future [6] ;
1454         } SF_LOOP_INFO ;
1455 </PRE>
1456 <P>
1457 Example:
1458 </P>
1459 <PRE>
1460          SF_LOOP_INFO loop;
1461          sf_command (sndfile, SFC_GET_LOOP_INFO, &amp;loop, sizeof (loop)) ;
1462 </PRE>
1463 <DL>
1464 <DT>Return value:</DT>
1465         <DD>SF_TRUE if the file header contains loop information for the file.
1466     SF_FALSE otherwise.
1467 </DL>
1468
1469 <!-- ========================================================================= -->
1470
1471
1472 <A NAME="SFC_GET_INSTRUMENT"></A>
1473 <H2><BR><B>SFC_GET_INSTRUMENT</B></H2>
1474 <P>
1475 Retrieve instrument information from file including MIDI base note,
1476 keyboard mapping and looping informations(start/stop and mode).
1477 </P>
1478 <p>
1479 Parameters:
1480 </p>
1481 <PRE>
1482          sndfile  : A valid SNDFILE* pointer
1483          cmd      : SFC_GET_INSTRUMENT
1484          data     : a pointer to an SF_INSTRUMENT struct
1485          datasize : sizeof (SF_INSTRUMENT)
1486 </PRE>
1487
1488 <P>
1489 The SF_INSTRUMENT struct is defined in &lt;sndfile.h&gt; as:
1490 </P>
1491 <PRE>
1492         enum
1493         {    /*
1494             **    The loop mode field in SF_INSTRUMENT will be one of the following.
1495             */
1496             SF_LOOP_NONE = 800,
1497             SF_LOOP_FORWARD,
1498             SF_LOOP_BACKWARD,
1499             SF_LOOP_ALTERNATING
1500         } ;
1501
1502         typedef struct
1503         {   int gain ;
1504             char basenote, detune ;
1505             char velocity_lo, velocity_hi ;
1506             char key_lo, key_hi ;
1507             int loop_count ;
1508
1509             struct
1510             {   int mode ;
1511                 unsigned int start ;
1512                 unsigned int end ;
1513                 unsigned int count ;
1514             } loops [16] ; /* make variable in a sensible way */
1515         } SF_INSTRUMENT ;
1516 </PRE>
1517
1518 <P>
1519 Example:
1520 </P>
1521 <PRE>
1522          SF_INSTRUMENT inst ;
1523          sf_command (sndfile, SFC_GET_INSTRUMENT, &amp;inst, sizeof (inst)) ;
1524 </PRE>
1525 <DL>
1526 <DT>Return value:</DT>
1527         <dd>SF_TRUE if the file header contains instrument information for the
1528     file. SF_FALSE otherwise.
1529 </DL>
1530
1531 <!-- ========================================================================= -->
1532
1533
1534 <A NAME="SFC_SET_INSTRUMENT"></A>
1535 <H2><BR><B>SFC_SET_INSTRUMENT</B></H2>
1536 <P>
1537 Set the instrument information for the file.
1538 </P>
1539 <p>
1540 Parameters:
1541 </p>
1542 <PRE>
1543          sndfile  : A valid SNDFILE* pointer
1544          cmd      : SFC_GET_INSTRUMENT
1545          data     : a pointer to an SF_INSTRUMENT struct
1546          datasize : sizeof (SF_INSTRUMENT)
1547 </PRE>
1548 <P>
1549 Example:
1550 </P>
1551 <PRE>
1552          SF_INSTRUMENT inst ;
1553          sf_command (sndfile, SFC_SET_INSTRUMENT, &amp;inst, sizeof (inst)) ;
1554 </PRE>
1555 <DL>
1556 <DT>Return value:</DT>
1557         <dd>SF_TRUE if the file header contains instrument information for the
1558     file. SF_FALSE otherwise.
1559 </DL>
1560
1561 <!-- ========================================================================= -->
1562
1563
1564 <A NAME="SFC_SET_VBR_ENCODING_QUALITY"></A>
1565 <H2><BR><B>SFC_SET_VBR_ENCODING_QUALITY</B></H2>
1566 <P>
1567 Set the Variable Bite Rate encoding quality.
1568 Currenly only implemented fro Ogg/Vorbis files.
1569 </P>
1570 <p>
1571 Parameters:
1572 </p>
1573 <PRE>
1574          sndfile  : A valid SNDFILE* pointer
1575          cmd      : SFC_SET_VBR_ENCODING_QUALITY
1576          data     : a pointer to double specifing VBR quality
1577          datasize : sizeof (double)
1578 </PRE>
1579 <P>
1580 Example:
1581 </P>
1582 <PRE>
1583          double quality = 0.5 ;
1584          sf_command (sndfile, SFC_SET_VBR_ENCODING_QUALITY, &amp;quality, sizeof (double)) ;
1585 </PRE>
1586 <DL>
1587 <DT>Return value:</DT>
1588         <dd>SF_TRUE if VBR encoding quality was set.
1589     SF_FALSE otherwise.
1590 </DL>
1591
1592 <!-- ========================================================================= -->
1593
1594
1595 <HR>
1596 <P>
1597         The libsndfile home page is here :
1598                 <A HREF="http://www.mega-nerd.com/libsndfile/">
1599                         http://www.mega-nerd.com/libsndfile/</A>.
1600 <BR>
1601 Version : 1.0.25
1602 </P>
1603
1604 </BODY>
1605 </HTML>