+28 -25

audio/alsaaudio.c

··· 87 87 88 88 struct alsa_params_obt { 89 89 int freq; 90 90 - audfmt_e fmt; 90 90 + AudioFormat fmt; 91 91 int endianness; 92 92 int nchannels; 93 93 snd_pcm_uframes_t samples; ··· 294 294 return audio_pcm_sw_write (sw, buf, len); 295 295 } 296 296 297 297 - static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt, int endianness) 297 297 + static snd_pcm_format_t aud_to_alsafmt (AudioFormat fmt, int endianness) 298 298 { 299 299 switch (fmt) { 300 300 - case AUD_FMT_S8: 300 300 + case AUDIO_FORMAT_S8: 301 301 return SND_PCM_FORMAT_S8; 302 302 303 303 - case AUD_FMT_U8: 303 303 + case AUDIO_FORMAT_U8: 304 304 return SND_PCM_FORMAT_U8; 305 305 306 306 - case AUD_FMT_S16: 306 306 + case AUDIO_FORMAT_S16: 307 307 if (endianness) { 308 308 return SND_PCM_FORMAT_S16_BE; 309 309 } ··· 311 311 return SND_PCM_FORMAT_S16_LE; 312 312 } 313 313 314 314 - case AUD_FMT_U16: 314 314 + case AUDIO_FORMAT_U16: 315 315 if (endianness) { 316 316 return SND_PCM_FORMAT_U16_BE; 317 317 } ··· 319 319 return SND_PCM_FORMAT_U16_LE; 320 320 } 321 321 322 322 - case AUD_FMT_S32: 322 322 + case AUDIO_FORMAT_S32: 323 323 if (endianness) { 324 324 return SND_PCM_FORMAT_S32_BE; 325 325 } ··· 327 327 return SND_PCM_FORMAT_S32_LE; 328 328 } 329 329 330 330 - case AUD_FMT_U32: 330 330 + case AUDIO_FORMAT_U32: 331 331 if (endianness) { 332 332 return SND_PCM_FORMAT_U32_BE; 333 333 } ··· 344 344 } 345 345 } 346 346 347 347 - static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt, 347 347 + static int alsa_to_audfmt (snd_pcm_format_t alsafmt, AudioFormat *fmt, 348 348 int *endianness) 349 349 { 350 350 switch (alsafmt) { 351 351 case SND_PCM_FORMAT_S8: 352 352 *endianness = 0; 353 353 - *fmt = AUD_FMT_S8; 353 353 + *fmt = AUDIO_FORMAT_S8; 354 354 break; 355 355 356 356 case SND_PCM_FORMAT_U8: 357 357 *endianness = 0; 358 358 - *fmt = AUD_FMT_U8; 358 358 + *fmt = AUDIO_FORMAT_U8; 359 359 break; 360 360 361 361 case SND_PCM_FORMAT_S16_LE: 362 362 *endianness = 0; 363 363 - *fmt = AUD_FMT_S16; 363 363 + *fmt = AUDIO_FORMAT_S16; 364 364 break; 365 365 366 366 case SND_PCM_FORMAT_U16_LE: 367 367 *endianness = 0; 368 368 - *fmt = AUD_FMT_U16; 368 368 + *fmt = AUDIO_FORMAT_U16; 369 369 break; 370 370 371 371 case SND_PCM_FORMAT_S16_BE: 372 372 *endianness = 1; 373 373 - *fmt = AUD_FMT_S16; 373 373 + *fmt = AUDIO_FORMAT_S16; 374 374 break; 375 375 376 376 case SND_PCM_FORMAT_U16_BE: 377 377 *endianness = 1; 378 378 - *fmt = AUD_FMT_U16; 378 378 + *fmt = AUDIO_FORMAT_U16; 379 379 break; 380 380 381 381 case SND_PCM_FORMAT_S32_LE: 382 382 *endianness = 0; 383 383 - *fmt = AUD_FMT_S32; 383 383 + *fmt = AUDIO_FORMAT_S32; 384 384 break; 385 385 386 386 case SND_PCM_FORMAT_U32_LE: 387 387 *endianness = 0; 388 388 - *fmt = AUD_FMT_U32; 388 388 + *fmt = AUDIO_FORMAT_U32; 389 389 break; 390 390 391 391 case SND_PCM_FORMAT_S32_BE: 392 392 *endianness = 1; 393 393 - *fmt = AUD_FMT_S32; 393 393 + *fmt = AUDIO_FORMAT_S32; 394 394 break; 395 395 396 396 case SND_PCM_FORMAT_U32_BE: 397 397 *endianness = 1; 398 398 - *fmt = AUD_FMT_U32; 398 398 + *fmt = AUDIO_FORMAT_U32; 399 399 break; 400 400 401 401 default: ··· 638 638 bytes_per_sec = freq << (nchannels == 2); 639 639 640 640 switch (obt->fmt) { 641 641 - case AUD_FMT_S8: 642 642 - case AUD_FMT_U8: 641 641 + case AUDIO_FORMAT_S8: 642 642 + case AUDIO_FORMAT_U8: 643 643 break; 644 644 645 645 - case AUD_FMT_S16: 646 646 - case AUD_FMT_U16: 645 645 + case AUDIO_FORMAT_S16: 646 646 + case AUDIO_FORMAT_U16: 647 647 bytes_per_sec <<= 1; 648 648 break; 649 649 650 650 - case AUD_FMT_S32: 651 651 - case AUD_FMT_U32: 650 650 + case AUDIO_FORMAT_S32: 651 651 + case AUDIO_FORMAT_U32: 652 652 bytes_per_sec <<= 2; 653 653 break; 654 654 + 655 655 + default: 656 656 + abort(); 654 657 } 655 658 656 659 threshold = (conf->threshold * bytes_per_sec) / 1000;

+53 -44

audio/audio.c

··· 113 113 .settings = { 114 114 .freq = 44100, 115 115 .nchannels = 2, 116 116 - .fmt = AUD_FMT_S16, 116 116 + .fmt = AUDIO_FORMAT_S16, 117 117 .endianness = AUDIO_HOST_ENDIANNESS, 118 118 } 119 119 }, ··· 125 125 .settings = { 126 126 .freq = 44100, 127 127 .nchannels = 2, 128 128 - .fmt = AUD_FMT_S16, 128 128 + .fmt = AUDIO_FORMAT_S16, 129 129 .endianness = AUDIO_HOST_ENDIANNESS, 130 130 } 131 131 }, ··· 257 257 return r; 258 258 } 259 259 260 260 - static const char *audio_audfmt_to_string (audfmt_e fmt) 260 260 + static const char *audio_audfmt_to_string (AudioFormat fmt) 261 261 { 262 262 switch (fmt) { 263 263 - case AUD_FMT_U8: 263 263 + case AUDIO_FORMAT_U8: 264 264 return "U8"; 265 265 266 266 - case AUD_FMT_U16: 266 266 + case AUDIO_FORMAT_U16: 267 267 return "U16"; 268 268 269 269 - case AUD_FMT_S8: 269 269 + case AUDIO_FORMAT_S8: 270 270 return "S8"; 271 271 272 272 - case AUD_FMT_S16: 272 272 + case AUDIO_FORMAT_S16: 273 273 return "S16"; 274 274 275 275 - case AUD_FMT_U32: 275 275 + case AUDIO_FORMAT_U32: 276 276 return "U32"; 277 277 278 278 - case AUD_FMT_S32: 278 278 + case AUDIO_FORMAT_S32: 279 279 return "S32"; 280 280 + 281 281 + default: 282 282 + abort(); 280 283 } 281 284 282 285 dolog ("Bogus audfmt %d returning S16\n", fmt); 283 286 return "S16"; 284 287 } 285 288 286 286 - static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval, 289 289 + static AudioFormat audio_string_to_audfmt (const char *s, AudioFormat defval, 287 290 int *defaultp) 288 291 { 289 292 if (!strcasecmp (s, "u8")) { 290 293 *defaultp = 0; 291 291 - return AUD_FMT_U8; 294 294 + return AUDIO_FORMAT_U8; 292 295 } 293 296 else if (!strcasecmp (s, "u16")) { 294 297 *defaultp = 0; 295 295 - return AUD_FMT_U16; 298 298 + return AUDIO_FORMAT_U16; 296 299 } 297 300 else if (!strcasecmp (s, "u32")) { 298 301 *defaultp = 0; 299 299 - return AUD_FMT_U32; 302 302 + return AUDIO_FORMAT_U32; 300 303 } 301 304 else if (!strcasecmp (s, "s8")) { 302 305 *defaultp = 0; 303 303 - return AUD_FMT_S8; 306 306 + return AUDIO_FORMAT_S8; 304 307 } 305 308 else if (!strcasecmp (s, "s16")) { 306 309 *defaultp = 0; 307 307 - return AUD_FMT_S16; 310 310 + return AUDIO_FORMAT_S16; 308 311 } 309 312 else if (!strcasecmp (s, "s32")) { 310 313 *defaultp = 0; 311 311 - return AUD_FMT_S32; 314 314 + return AUDIO_FORMAT_S32; 312 315 } 313 316 else { 314 317 dolog ("Bogus audio format `%s' using %s\n", ··· 318 321 } 319 322 } 320 323 321 321 - static audfmt_e audio_get_conf_fmt (const char *envname, 322 322 - audfmt_e defval, 324 324 + static AudioFormat audio_get_conf_fmt (const char *envname, 325 325 + AudioFormat defval, 323 326 int *defaultp) 324 327 { 325 328 const char *var = getenv (envname); ··· 421 424 422 425 case AUD_OPT_FMT: 423 426 { 424 424 - audfmt_e *fmtp = opt->valp; 427 427 + AudioFormat *fmtp = opt->valp; 425 428 printf ( 426 429 "format, %s = %s, (one of: U8 S8 U16 S16 U32 S32)\n", 427 430 state, ··· 492 495 493 496 case AUD_OPT_FMT: 494 497 { 495 495 - audfmt_e *fmtp = opt->valp; 498 498 + AudioFormat *fmtp = opt->valp; 496 499 *fmtp = audio_get_conf_fmt (optname, *fmtp, &def); 497 500 } 498 501 break; ··· 524 527 dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels); 525 528 526 529 switch (as->fmt) { 527 527 - case AUD_FMT_S8: 530 530 + case AUDIO_FORMAT_S8: 528 531 AUD_log (NULL, "S8"); 529 532 break; 530 530 - case AUD_FMT_U8: 533 533 + case AUDIO_FORMAT_U8: 531 534 AUD_log (NULL, "U8"); 532 535 break; 533 533 - case AUD_FMT_S16: 536 536 + case AUDIO_FORMAT_S16: 534 537 AUD_log (NULL, "S16"); 535 538 break; 536 536 - case AUD_FMT_U16: 539 539 + case AUDIO_FORMAT_U16: 537 540 AUD_log (NULL, "U16"); 538 541 break; 539 539 - case AUD_FMT_S32: 542 542 + case AUDIO_FORMAT_S32: 540 543 AUD_log (NULL, "S32"); 541 544 break; 542 542 - case AUD_FMT_U32: 545 545 + case AUDIO_FORMAT_U32: 543 546 AUD_log (NULL, "U32"); 544 547 break; 545 548 default: ··· 570 573 invalid |= as->endianness != 0 && as->endianness != 1; 571 574 572 575 switch (as->fmt) { 573 573 - case AUD_FMT_S8: 574 574 - case AUD_FMT_U8: 575 575 - case AUD_FMT_S16: 576 576 - case AUD_FMT_U16: 577 577 - case AUD_FMT_S32: 578 578 - case AUD_FMT_U32: 576 576 + case AUDIO_FORMAT_S8: 577 577 + case AUDIO_FORMAT_U8: 578 578 + case AUDIO_FORMAT_S16: 579 579 + case AUDIO_FORMAT_U16: 580 580 + case AUDIO_FORMAT_S32: 581 581 + case AUDIO_FORMAT_U32: 579 582 break; 580 583 default: 581 584 invalid = 1; ··· 591 594 int bits = 8, sign = 0; 592 595 593 596 switch (as->fmt) { 594 594 - case AUD_FMT_S8: 597 597 + case AUDIO_FORMAT_S8: 595 598 sign = 1; 596 599 /* fall through */ 597 597 - case AUD_FMT_U8: 600 600 + case AUDIO_FORMAT_U8: 598 601 break; 599 602 600 600 - case AUD_FMT_S16: 603 603 + case AUDIO_FORMAT_S16: 601 604 sign = 1; 602 605 /* fall through */ 603 603 - case AUD_FMT_U16: 606 606 + case AUDIO_FORMAT_U16: 604 607 bits = 16; 605 608 break; 606 609 607 607 - case AUD_FMT_S32: 610 610 + case AUDIO_FORMAT_S32: 608 611 sign = 1; 609 612 /* fall through */ 610 610 - case AUD_FMT_U32: 613 613 + case AUDIO_FORMAT_U32: 611 614 bits = 32; 612 615 break; 616 616 + 617 617 + default: 618 618 + abort(); 613 619 } 614 620 return info->freq == as->freq 615 621 && info->nchannels == as->nchannels ··· 623 629 int bits = 8, sign = 0, shift = 0; 624 630 625 631 switch (as->fmt) { 626 626 - case AUD_FMT_S8: 632 632 + case AUDIO_FORMAT_S8: 627 633 sign = 1; 628 628 - case AUD_FMT_U8: 634 634 + case AUDIO_FORMAT_U8: 629 635 break; 630 636 631 631 - case AUD_FMT_S16: 637 637 + case AUDIO_FORMAT_S16: 632 638 sign = 1; 633 633 - case AUD_FMT_U16: 639 639 + case AUDIO_FORMAT_U16: 634 640 bits = 16; 635 641 shift = 1; 636 642 break; 637 643 638 638 - case AUD_FMT_S32: 644 644 + case AUDIO_FORMAT_S32: 639 645 sign = 1; 640 640 - case AUD_FMT_U32: 646 646 + case AUDIO_FORMAT_U32: 641 647 bits = 32; 642 648 shift = 2; 643 649 break; 650 650 + 651 651 + default: 652 652 + abort(); 644 653 } 645 654 646 655 info->freq = as->freq;

+2 -10

audio/audio.h

··· 26 26 #define QEMU_AUDIO_H 27 27 28 28 #include "qemu/queue.h" 29 29 + #include "qapi/qapi-types-audio.h" 29 30 30 31 typedef void (*audio_callback_fn) (void *opaque, int avail); 31 32 32 32 - typedef enum { 33 33 - AUD_FMT_U8, 34 34 - AUD_FMT_S8, 35 35 - AUD_FMT_U16, 36 36 - AUD_FMT_S16, 37 37 - AUD_FMT_U32, 38 38 - AUD_FMT_S32 39 39 - } audfmt_e; 40 40 - 41 33 #ifdef HOST_WORDS_BIGENDIAN 42 34 #define AUDIO_HOST_ENDIANNESS 1 43 35 #else ··· 47 39 struct audsettings { 48 40 int freq; 49 41 int nchannels; 50 50 - audfmt_e fmt; 42 42 + AudioFormat fmt; 51 43 int endianness; 52 44 }; 53 45

+9 -9

audio/audio_win_int.c

··· 24 24 wfx->cbSize = 0; 25 25 26 26 switch (as->fmt) { 27 27 - case AUD_FMT_S8: 28 28 - case AUD_FMT_U8: 27 27 + case AUDIO_FORMAT_S8: 28 28 + case AUDIO_FORMAT_U8: 29 29 wfx->wBitsPerSample = 8; 30 30 break; 31 31 32 32 - case AUD_FMT_S16: 33 33 - case AUD_FMT_U16: 32 32 + case AUDIO_FORMAT_S16: 33 33 + case AUDIO_FORMAT_U16: 34 34 wfx->wBitsPerSample = 16; 35 35 wfx->nAvgBytesPerSec <<= 1; 36 36 wfx->nBlockAlign <<= 1; 37 37 break; 38 38 39 39 - case AUD_FMT_S32: 40 40 - case AUD_FMT_U32: 39 39 + case AUDIO_FORMAT_S32: 40 40 + case AUDIO_FORMAT_U32: 41 41 wfx->wBitsPerSample = 32; 42 42 wfx->nAvgBytesPerSec <<= 2; 43 43 wfx->nBlockAlign <<= 2; ··· 85 85 86 86 switch (wfx->wBitsPerSample) { 87 87 case 8: 88 88 - as->fmt = AUD_FMT_U8; 88 88 + as->fmt = AUDIO_FORMAT_U8; 89 89 break; 90 90 91 91 case 16: 92 92 - as->fmt = AUD_FMT_S16; 92 92 + as->fmt = AUDIO_FORMAT_S16; 93 93 break; 94 94 95 95 case 32: 96 96 - as->fmt = AUD_FMT_S32; 96 96 + as->fmt = AUDIO_FORMAT_S32; 97 97 break; 98 98 99 99 default:

+15 -15

audio/ossaudio.c

··· 70 70 71 71 struct oss_params { 72 72 int freq; 73 73 - audfmt_e fmt; 73 73 + AudioFormat fmt; 74 74 int nchannels; 75 75 int nfrags; 76 76 int fragsize; ··· 148 148 return audio_pcm_sw_write (sw, buf, len); 149 149 } 150 150 151 151 - static int aud_to_ossfmt (audfmt_e fmt, int endianness) 151 151 + static int aud_to_ossfmt (AudioFormat fmt, int endianness) 152 152 { 153 153 switch (fmt) { 154 154 - case AUD_FMT_S8: 154 154 + case AUDIO_FORMAT_S8: 155 155 return AFMT_S8; 156 156 157 157 - case AUD_FMT_U8: 157 157 + case AUDIO_FORMAT_U8: 158 158 return AFMT_U8; 159 159 160 160 - case AUD_FMT_S16: 160 160 + case AUDIO_FORMAT_S16: 161 161 if (endianness) { 162 162 return AFMT_S16_BE; 163 163 } ··· 165 165 return AFMT_S16_LE; 166 166 } 167 167 168 168 - case AUD_FMT_U16: 168 168 + case AUDIO_FORMAT_U16: 169 169 if (endianness) { 170 170 return AFMT_U16_BE; 171 171 } ··· 182 182 } 183 183 } 184 184 185 185 - static int oss_to_audfmt (int ossfmt, audfmt_e *fmt, int *endianness) 185 185 + static int oss_to_audfmt (int ossfmt, AudioFormat *fmt, int *endianness) 186 186 { 187 187 switch (ossfmt) { 188 188 case AFMT_S8: 189 189 *endianness = 0; 190 190 - *fmt = AUD_FMT_S8; 190 190 + *fmt = AUDIO_FORMAT_S8; 191 191 break; 192 192 193 193 case AFMT_U8: 194 194 *endianness = 0; 195 195 - *fmt = AUD_FMT_U8; 195 195 + *fmt = AUDIO_FORMAT_U8; 196 196 break; 197 197 198 198 case AFMT_S16_LE: 199 199 *endianness = 0; 200 200 - *fmt = AUD_FMT_S16; 200 200 + *fmt = AUDIO_FORMAT_S16; 201 201 break; 202 202 203 203 case AFMT_U16_LE: 204 204 *endianness = 0; 205 205 - *fmt = AUD_FMT_U16; 205 205 + *fmt = AUDIO_FORMAT_U16; 206 206 break; 207 207 208 208 case AFMT_S16_BE: 209 209 *endianness = 1; 210 210 - *fmt = AUD_FMT_S16; 210 210 + *fmt = AUDIO_FORMAT_S16; 211 211 break; 212 212 213 213 case AFMT_U16_BE: 214 214 *endianness = 1; 215 215 - *fmt = AUD_FMT_U16; 215 215 + *fmt = AUDIO_FORMAT_U16; 216 216 break; 217 217 218 218 default: ··· 500 500 int endianness; 501 501 int err; 502 502 int fd; 503 503 - audfmt_e effective_fmt; 503 503 + AudioFormat effective_fmt; 504 504 struct audsettings obt_as; 505 505 OSSConf *conf = drv_opaque; 506 506 ··· 667 667 int endianness; 668 668 int err; 669 669 int fd; 670 670 - audfmt_e effective_fmt; 670 670 + AudioFormat effective_fmt; 671 671 struct audsettings obt_as; 672 672 OSSConf *conf = drv_opaque; 673 673

+14 -14

audio/paaudio.c

··· 385 385 return audio_pcm_sw_read (sw, buf, len); 386 386 } 387 387 388 388 - static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness) 388 388 + static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness) 389 389 { 390 390 int format; 391 391 392 392 switch (afmt) { 393 393 - case AUD_FMT_S8: 394 394 - case AUD_FMT_U8: 393 393 + case AUDIO_FORMAT_S8: 394 394 + case AUDIO_FORMAT_U8: 395 395 format = PA_SAMPLE_U8; 396 396 break; 397 397 - case AUD_FMT_S16: 398 398 - case AUD_FMT_U16: 397 397 + case AUDIO_FORMAT_S16: 398 398 + case AUDIO_FORMAT_U16: 399 399 format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE; 400 400 break; 401 401 - case AUD_FMT_S32: 402 402 - case AUD_FMT_U32: 401 401 + case AUDIO_FORMAT_S32: 402 402 + case AUDIO_FORMAT_U32: 403 403 format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE; 404 404 break; 405 405 default: ··· 410 410 return format; 411 411 } 412 412 413 413 - static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness) 413 413 + static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness) 414 414 { 415 415 switch (fmt) { 416 416 case PA_SAMPLE_U8: 417 417 - return AUD_FMT_U8; 417 417 + return AUDIO_FORMAT_U8; 418 418 case PA_SAMPLE_S16BE: 419 419 *endianness = 1; 420 420 - return AUD_FMT_S16; 420 420 + return AUDIO_FORMAT_S16; 421 421 case PA_SAMPLE_S16LE: 422 422 *endianness = 0; 423 423 - return AUD_FMT_S16; 423 423 + return AUDIO_FORMAT_S16; 424 424 case PA_SAMPLE_S32BE: 425 425 *endianness = 1; 426 426 - return AUD_FMT_S32; 426 426 + return AUDIO_FORMAT_S32; 427 427 case PA_SAMPLE_S32LE: 428 428 *endianness = 0; 429 429 - return AUD_FMT_S32; 429 429 + return AUDIO_FORMAT_S32; 430 430 default: 431 431 dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt); 432 432 - return AUD_FMT_U8; 432 432 + return AUDIO_FORMAT_U8; 433 433 } 434 434 } 435 435

+13 -13

audio/sdlaudio.c

··· 68 68 AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ()); 69 69 } 70 70 71 71 - static int aud_to_sdlfmt (audfmt_e fmt) 71 71 + static int aud_to_sdlfmt (AudioFormat fmt) 72 72 { 73 73 switch (fmt) { 74 74 - case AUD_FMT_S8: 74 74 + case AUDIO_FORMAT_S8: 75 75 return AUDIO_S8; 76 76 77 77 - case AUD_FMT_U8: 77 77 + case AUDIO_FORMAT_U8: 78 78 return AUDIO_U8; 79 79 80 80 - case AUD_FMT_S16: 80 80 + case AUDIO_FORMAT_S16: 81 81 return AUDIO_S16LSB; 82 82 83 83 - case AUD_FMT_U16: 83 83 + case AUDIO_FORMAT_U16: 84 84 return AUDIO_U16LSB; 85 85 86 86 default: ··· 92 92 } 93 93 } 94 94 95 95 - static int sdl_to_audfmt(int sdlfmt, audfmt_e *fmt, int *endianness) 95 95 + static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness) 96 96 { 97 97 switch (sdlfmt) { 98 98 case AUDIO_S8: 99 99 *endianness = 0; 100 100 - *fmt = AUD_FMT_S8; 100 100 + *fmt = AUDIO_FORMAT_S8; 101 101 break; 102 102 103 103 case AUDIO_U8: 104 104 *endianness = 0; 105 105 - *fmt = AUD_FMT_U8; 105 105 + *fmt = AUDIO_FORMAT_U8; 106 106 break; 107 107 108 108 case AUDIO_S16LSB: 109 109 *endianness = 0; 110 110 - *fmt = AUD_FMT_S16; 110 110 + *fmt = AUDIO_FORMAT_S16; 111 111 break; 112 112 113 113 case AUDIO_U16LSB: 114 114 *endianness = 0; 115 115 - *fmt = AUD_FMT_U16; 115 115 + *fmt = AUDIO_FORMAT_U16; 116 116 break; 117 117 118 118 case AUDIO_S16MSB: 119 119 *endianness = 1; 120 120 - *fmt = AUD_FMT_S16; 120 120 + *fmt = AUDIO_FORMAT_S16; 121 121 break; 122 122 123 123 case AUDIO_U16MSB: 124 124 *endianness = 1; 125 125 - *fmt = AUD_FMT_U16; 125 125 + *fmt = AUDIO_FORMAT_U16; 126 126 break; 127 127 128 128 default: ··· 265 265 SDL_AudioSpec req, obt; 266 266 int endianness; 267 267 int err; 268 268 - audfmt_e effective_fmt; 268 268 + AudioFormat effective_fmt; 269 269 struct audsettings obt_as; 270 270 271 271 req.freq = as->freq;

+2 -2

audio/spiceaudio.c

··· 130 130 settings.freq = SPICE_INTERFACE_PLAYBACK_FREQ; 131 131 #endif 132 132 settings.nchannels = SPICE_INTERFACE_PLAYBACK_CHAN; 133 133 - settings.fmt = AUD_FMT_S16; 133 133 + settings.fmt = AUDIO_FORMAT_S16; 134 134 settings.endianness = AUDIO_HOST_ENDIANNESS; 135 135 136 136 audio_pcm_init_info (&hw->info, &settings); ··· 258 258 settings.freq = SPICE_INTERFACE_RECORD_FREQ; 259 259 #endif 260 260 settings.nchannels = SPICE_INTERFACE_RECORD_CHAN; 261 261 - settings.fmt = AUD_FMT_S16; 261 261 + settings.fmt = AUDIO_FORMAT_S16; 262 262 settings.endianness = AUDIO_HOST_ENDIANNESS; 263 263 264 264 audio_pcm_init_info (&hw->info, &settings);

+10 -7

audio/wavaudio.c

··· 117 117 118 118 stereo = wav_as.nchannels == 2; 119 119 switch (wav_as.fmt) { 120 120 - case AUD_FMT_S8: 121 121 - case AUD_FMT_U8: 120 120 + case AUDIO_FORMAT_S8: 121 121 + case AUDIO_FORMAT_U8: 122 122 bits16 = 0; 123 123 break; 124 124 125 125 - case AUD_FMT_S16: 126 126 - case AUD_FMT_U16: 125 125 + case AUDIO_FORMAT_S16: 126 126 + case AUDIO_FORMAT_U16: 127 127 bits16 = 1; 128 128 break; 129 129 130 130 - case AUD_FMT_S32: 131 131 - case AUD_FMT_U32: 130 130 + case AUDIO_FORMAT_S32: 131 131 + case AUDIO_FORMAT_U32: 132 132 dolog ("WAVE files can not handle 32bit formats\n"); 133 133 return -1; 134 134 + 135 135 + default: 136 136 + abort(); 134 137 } 135 138 136 139 hdr[34] = bits16 ? 0x10 : 0x08; ··· 225 228 static WAVConf glob_conf = { 226 229 .settings.freq = 44100, 227 230 .settings.nchannels = 2, 228 228 - .settings.fmt = AUD_FMT_S16, 231 231 + .settings.fmt = AUDIO_FORMAT_S16, 229 232 .wav_path = "qemu.wav" 230 233 }; 231 234

+1 -1

audio/wavcapture.c

··· 136 136 137 137 as.freq = freq; 138 138 as.nchannels = 1 << stereo; 139 139 - as.fmt = bits16 ? AUD_FMT_S16 : AUD_FMT_U8; 139 139 + as.fmt = bits16 ? AUDIO_FORMAT_S16 : AUDIO_FORMAT_U8; 140 140 as.endianness = 0; 141 141 142 142 ops.notify = wav_notify;

+1 -1

hw/arm/omap2.c

··· 273 273 * does I2S specify it? */ 274 274 /* All register writes are 16 bits so we we store 16-bit samples 275 275 * in the buffers regardless of AGCFR[B8_16] value. */ 276 276 - fmt.fmt = AUD_FMT_U16; 276 276 + fmt.fmt = AUDIO_FORMAT_U16; 277 277 278 278 s->codec.in_voice = AUD_open_in(&s->codec.card, s->codec.in_voice, 279 279 "eac.codec.in", s, omap_eac_in_cb, &fmt);

+1 -1

hw/audio/ac97.c

··· 365 365 366 366 as.freq = freq; 367 367 as.nchannels = 2; 368 368 - as.fmt = AUD_FMT_S16; 368 368 + as.fmt = AUDIO_FORMAT_S16; 369 369 as.endianness = 0; 370 370 371 371 if (freq > 0) {

+1 -1

hw/audio/adlib.c

··· 269 269 270 270 as.freq = s->freq; 271 271 as.nchannels = SHIFT; 272 272 - as.fmt = AUD_FMT_S16; 272 272 + as.fmt = AUDIO_FORMAT_S16; 273 273 as.endianness = AUDIO_HOST_ENDIANNESS; 274 274 275 275 AUD_register_card ("adlib", &s->card);

+3 -3

hw/audio/cs4231a.c

··· 288 288 289 289 switch ((val >> 5) & ((s->dregs[MODE_And_ID] & MODE2) ? 7 : 3)) { 290 290 case 0: 291 291 - as.fmt = AUD_FMT_U8; 291 291 + as.fmt = AUDIO_FORMAT_U8; 292 292 s->shift = as.nchannels == 2; 293 293 break; 294 294 ··· 298 298 case 3: 299 299 s->tab = ALawDecompressTable; 300 300 x_law: 301 301 - as.fmt = AUD_FMT_S16; 301 301 + as.fmt = AUDIO_FORMAT_S16; 302 302 as.endianness = AUDIO_HOST_ENDIANNESS; 303 303 s->shift = as.nchannels == 2; 304 304 break; ··· 307 307 as.endianness = 1; 308 308 /* fall through */ 309 309 case 2: 310 310 - as.fmt = AUD_FMT_S16; 310 310 + as.fmt = AUDIO_FORMAT_S16; 311 311 s->shift = as.nchannels; 312 312 break; 313 313

+2 -2

hw/audio/es1370.c

··· 414 414 i, 415 415 new_freq, 416 416 1 << (new_fmt & 1), 417 417 - (new_fmt & 2) ? AUD_FMT_S16 : AUD_FMT_U8, 417 417 + (new_fmt & 2) ? AUDIO_FORMAT_S16 : AUDIO_FORMAT_U8, 418 418 d->shift); 419 419 if (new_freq) { 420 420 struct audsettings as; 421 421 422 422 as.freq = new_freq; 423 423 as.nchannels = 1 << (new_fmt & 1); 424 424 - as.fmt = (new_fmt & 2) ? AUD_FMT_S16 : AUD_FMT_U8; 424 424 + as.fmt = (new_fmt & 2) ? AUDIO_FORMAT_S16 : AUDIO_FORMAT_U8; 425 425 as.endianness = 0; 426 426 427 427 if (i == ADC_CHANNEL) {

+1 -1

hw/audio/gus.c

··· 251 251 252 252 as.freq = s->freq; 253 253 as.nchannels = 2; 254 254 - as.fmt = AUD_FMT_S16; 254 254 + as.fmt = AUDIO_FORMAT_S16; 255 255 as.endianness = GUS_ENDIANNESS; 256 256 257 257 s->voice = AUD_open_out (

+9 -9

hw/audio/hda-codec.c

··· 99 99 } 100 100 101 101 switch (format & AC_FMT_BITS_MASK) { 102 102 - case AC_FMT_BITS_8: as->fmt = AUD_FMT_S8; break; 103 103 - case AC_FMT_BITS_16: as->fmt = AUD_FMT_S16; break; 104 104 - case AC_FMT_BITS_32: as->fmt = AUD_FMT_S32; break; 102 102 + case AC_FMT_BITS_8: as->fmt = AUDIO_FORMAT_S8; break; 103 103 + case AC_FMT_BITS_16: as->fmt = AUDIO_FORMAT_S16; break; 104 104 + case AC_FMT_BITS_32: as->fmt = AUDIO_FORMAT_S32; break; 105 105 } 106 106 107 107 as->nchannels = ((format & AC_FMT_CHAN_MASK) >> AC_FMT_CHAN_SHIFT) + 1; ··· 134 134 /* -------------------------------------------------------------------------- */ 135 135 136 136 static const char *fmt2name[] = { 137 137 - [ AUD_FMT_U8 ] = "PCM-U8", 138 138 - [ AUD_FMT_S8 ] = "PCM-S8", 139 139 - [ AUD_FMT_U16 ] = "PCM-U16", 140 140 - [ AUD_FMT_S16 ] = "PCM-S16", 141 141 - [ AUD_FMT_U32 ] = "PCM-U32", 142 142 - [ AUD_FMT_S32 ] = "PCM-S32", 137 137 + [ AUDIO_FORMAT_U8 ] = "PCM-U8", 138 138 + [ AUDIO_FORMAT_S8 ] = "PCM-S8", 139 139 + [ AUDIO_FORMAT_U16 ] = "PCM-U16", 140 140 + [ AUDIO_FORMAT_S16 ] = "PCM-S16", 141 141 + [ AUDIO_FORMAT_U32 ] = "PCM-U32", 142 142 + [ AUDIO_FORMAT_S32 ] = "PCM-S32", 143 143 }; 144 144 145 145 typedef struct HDAAudioState HDAAudioState;

+3 -3

hw/audio/lm4549.c

··· 185 185 struct audsettings as; 186 186 as.freq = value; 187 187 as.nchannels = 2; 188 188 - as.fmt = AUD_FMT_S16; 188 188 + as.fmt = AUDIO_FORMAT_S16; 189 189 as.endianness = 0; 190 190 191 191 s->voice = AUD_open_out( ··· 255 255 struct audsettings as; 256 256 as.freq = freq; 257 257 as.nchannels = 2; 258 258 - as.fmt = AUD_FMT_S16; 258 258 + as.fmt = AUDIO_FORMAT_S16; 259 259 as.endianness = 0; 260 260 261 261 s->voice = AUD_open_out( ··· 292 292 /* Open a default voice */ 293 293 as.freq = 48000; 294 294 as.nchannels = 2; 295 295 - as.fmt = AUD_FMT_S16; 295 295 + as.fmt = AUDIO_FORMAT_S16; 296 296 as.endianness = 0; 297 297 298 298 s->voice = AUD_open_out(

+1 -1

hw/audio/milkymist-ac97.c

··· 308 308 309 309 as.freq = 48000; 310 310 as.nchannels = 2; 311 311 - as.fmt = AUD_FMT_S16; 311 311 + as.fmt = AUDIO_FORMAT_S16; 312 312 as.endianness = 1; 313 313 314 314 s->voice_in = AUD_open_in(&s->card, s->voice_in,

+1 -1

hw/audio/pcspk.c

··· 162 162 163 163 static void pcspk_realizefn(DeviceState *dev, Error **errp) 164 164 { 165 165 - struct audsettings as = {PCSPK_SAMPLE_RATE, 1, AUD_FMT_U8, 0}; 165 165 + struct audsettings as = {PCSPK_SAMPLE_RATE, 1, AUDIO_FORMAT_U8, 0}; 166 166 ISADevice *isadev = ISA_DEVICE(dev); 167 167 PCSpkState *s = PC_SPEAKER(dev); 168 168

+7 -7

hw/audio/sb16.c

··· 66 66 int fmt_stereo; 67 67 int fmt_signed; 68 68 int fmt_bits; 69 69 - audfmt_e fmt; 69 69 + AudioFormat fmt; 70 70 int dma_auto; 71 71 int block_size; 72 72 int fifo; ··· 224 224 225 225 static void dma_cmd8 (SB16State *s, int mask, int dma_len) 226 226 { 227 227 - s->fmt = AUD_FMT_U8; 227 227 + s->fmt = AUDIO_FORMAT_U8; 228 228 s->use_hdma = 0; 229 229 s->fmt_bits = 8; 230 230 s->fmt_signed = 0; ··· 319 319 320 320 if (16 == s->fmt_bits) { 321 321 if (s->fmt_signed) { 322 322 - s->fmt = AUD_FMT_S16; 322 322 + s->fmt = AUDIO_FORMAT_S16; 323 323 } 324 324 else { 325 325 - s->fmt = AUD_FMT_U16; 325 325 + s->fmt = AUDIO_FORMAT_U16; 326 326 } 327 327 } 328 328 else { 329 329 if (s->fmt_signed) { 330 330 - s->fmt = AUD_FMT_S8; 330 330 + s->fmt = AUDIO_FORMAT_S8; 331 331 } 332 332 else { 333 333 - s->fmt = AUD_FMT_U8; 333 333 + s->fmt = AUDIO_FORMAT_U8; 334 334 } 335 335 } 336 336 ··· 852 852 853 853 as.freq = s->freq; 854 854 as.nchannels = 1; 855 855 - as.fmt = AUD_FMT_U8; 855 855 + as.fmt = AUDIO_FORMAT_U8; 856 856 as.endianness = 0; 857 857 858 858 s->voice = AUD_open_out (

+3 -3

hw/audio/wm8750.c

··· 201 201 in_fmt.endianness = 0; 202 202 in_fmt.nchannels = 2; 203 203 in_fmt.freq = s->adc_hz; 204 204 - in_fmt.fmt = AUD_FMT_S16; 204 204 + in_fmt.fmt = AUDIO_FORMAT_S16; 205 205 206 206 s->adc_voice[0] = AUD_open_in(&s->card, s->adc_voice[0], 207 207 CODEC ".input1", s, wm8750_audio_in_cb, &in_fmt); ··· 214 214 out_fmt.endianness = 0; 215 215 out_fmt.nchannels = 2; 216 216 out_fmt.freq = s->dac_hz; 217 217 - out_fmt.fmt = AUD_FMT_S16; 217 217 + out_fmt.fmt = AUDIO_FORMAT_S16; 218 218 219 219 s->dac_voice[0] = AUD_open_out(&s->card, s->dac_voice[0], 220 220 CODEC ".speaker", s, wm8750_audio_out_cb, &out_fmt); ··· 681 681 if (s->idx_in >= sizeof(s->data_in)) { 682 682 wm8750_in_load(s); 683 683 if (s->idx_in >= sizeof(s->data_in)) { 684 684 - return 0x80008000; /* silence in AUD_FMT_S16 sample format */ 684 684 + return 0x80008000; /* silence in AUDIO_FORMAT_S16 sample format */ 685 685 } 686 686 } 687 687

+1 -1

hw/display/xlnx_dp.c

··· 1260 1260 1261 1261 as.freq = 44100; 1262 1262 as.nchannels = 2; 1263 1263 - as.fmt = AUD_FMT_S16; 1263 1263 + as.fmt = AUDIO_FORMAT_S16; 1264 1264 as.endianness = 0; 1265 1265 1266 1266 AUD_register_card("xlnx_dp.audio", &s->aud_card);

+1 -1

hw/input/tsc210x.c

··· 318 318 fmt.endianness = 0; 319 319 fmt.nchannels = 2; 320 320 fmt.freq = s->codec.tx_rate; 321 321 - fmt.fmt = AUD_FMT_S16; 321 321 + fmt.fmt = AUDIO_FORMAT_S16; 322 322 323 323 s->dac_voice[0] = AUD_open_out(&s->card, s->dac_voice[0], 324 324 "tsc2102.sink", s, (void *) tsc210x_audio_out_cb, &fmt);

+1 -1

hw/usb/dev-audio.c

··· 650 650 s->out.vol[1] = 240; /* 0 dB */ 651 651 s->out.as.freq = USBAUDIO_SAMPLE_RATE; 652 652 s->out.as.nchannels = 2; 653 653 - s->out.as.fmt = AUD_FMT_S16; 653 653 + s->out.as.fmt = AUDIO_FORMAT_S16; 654 654 s->out.as.endianness = 0; 655 655 streambuf_init(&s->out.buf, s->buffer); 656 656

+13 -13

ui/vnc.c

··· 1013 1013 int bps; 1014 1014 switch (vs->as.fmt) { 1015 1015 default: 1016 1016 - case AUD_FMT_U8: 1017 1017 - case AUD_FMT_S8: 1016 1016 + case AUDIO_FORMAT_U8: 1017 1017 + case AUDIO_FORMAT_S8: 1018 1018 bps = 1; 1019 1019 break; 1020 1020 - case AUD_FMT_U16: 1021 1021 - case AUD_FMT_S16: 1020 1020 + case AUDIO_FORMAT_U16: 1021 1021 + case AUDIO_FORMAT_S16: 1022 1022 bps = 2; 1023 1023 break; 1024 1024 - case AUD_FMT_U32: 1025 1025 - case AUD_FMT_S32: 1024 1024 + case AUDIO_FORMAT_U32: 1025 1025 + case AUDIO_FORMAT_S32: 1026 1026 bps = 4; 1027 1027 break; 1028 1028 } ··· 2369 2369 if (len == 4) 2370 2370 return 10; 2371 2371 switch (read_u8(data, 4)) { 2372 2372 - case 0: vs->as.fmt = AUD_FMT_U8; break; 2373 2373 - case 1: vs->as.fmt = AUD_FMT_S8; break; 2374 2374 - case 2: vs->as.fmt = AUD_FMT_U16; break; 2375 2375 - case 3: vs->as.fmt = AUD_FMT_S16; break; 2376 2376 - case 4: vs->as.fmt = AUD_FMT_U32; break; 2377 2377 - case 5: vs->as.fmt = AUD_FMT_S32; break; 2372 2372 + case 0: vs->as.fmt = AUDIO_FORMAT_U8; break; 2373 2373 + case 1: vs->as.fmt = AUDIO_FORMAT_S8; break; 2374 2374 + case 2: vs->as.fmt = AUDIO_FORMAT_U16; break; 2375 2375 + case 3: vs->as.fmt = AUDIO_FORMAT_S16; break; 2376 2376 + case 4: vs->as.fmt = AUDIO_FORMAT_U32; break; 2377 2377 + case 5: vs->as.fmt = AUDIO_FORMAT_S32; break; 2378 2378 default: 2379 2379 VNC_DEBUG("Invalid audio format %d\n", read_u8(data, 4)); 2380 2380 vnc_client_error(vs); ··· 3105 3105 3106 3106 vs->as.freq = 44100; 3107 3107 vs->as.nchannels = 2; 3108 3108 - vs->as.fmt = AUD_FMT_S16; 3108 3108 + vs->as.fmt = AUDIO_FORMAT_S16; 3109 3109 vs->as.endianness = 0; 3110 3110 3111 3111 qemu_mutex_init(&vs->output_mutex);