Bytes für WAV Format anpassen

[Devilmarkus]

Hallo,

da ich nun leider nicht "der" Mathematiker bin, hätte ich mal eine Frage.

Ich bin momentan dabei, eine Anwendung zu programmieren, welche mir 2 Bytes aufzeichnet. (Linker und rechter Soundkanal)

Dieses funktioniert soweit auch schon ganz gut, wenn da nicht dieses "aber" wäre.

Folgendes Problem habe ich:

Schreibe ich die Bytes, wie sie ankommen, in die WAV Datei, erhalte ich umgekehrte, negative Amplituden

    public void doCapture(byte a, byte b){
        CPC.tapesample[CPC.recordcount] = a;
        CPC.recordcount++;
        CPC.tapesample[CPC.recordcount] = b;
        CPC.recordcount++;
    }

Ändere ich diesen Code nun etwas, erhalte ich nur positive Amplituden:

    public void doCapture(byte a, byte b){
        CPC.tapesample[CPC.recordcount] = (byte)(a^0x80);
        CPC.recordcount++;
        CPC.tapesample[CPC.recordcount] = (byte)(b^0x80);
        CPC.recordcount++;
    }

Kann mir jemand helfen, und mir sagen, was ich tun muss, damit ich Amplituden so erhalte, dass sie negativ/positiv sind?

Dieses hier ist mein gewünschtes Ziel in der Ausgabe.

MfG
Markus

 

[Marco13]

Von welchem typ ist tapesample?

 

[Devilmarkus]

tapesample ist einfach nur ein byte[] Array.
Ich möchte es in eine WAV Datei einbauen.
Generieren möchte ich die Bytes hier:

  public void writeStereo(int a, int b) {

    if (CPC.showAudioCapture && !capture.showCapture){
        capture.showCapture();
    }
    if (capture.doCapture)
        capture.doCapture(a, b);
    switch(format) {
      case SoundUtil.ULAW:
        data[offset] = SoundUtil.ulawToUPCM8((byte)a);
        data[offset + 1] = SoundUtil.ulawToUPCM8((byte)b);
        break;
      case SoundUtil.UPCM8:
        data[offset] = (byte)a;
        data[offset + 1] = (byte)b;
        break;
    }

    if ((offset += 2) == data.length) {
      line.write(data,0,data.length);
      offset = 0;
    }
    updates++;
  }

Übrigens funktioniert es nicht, wenn ich die Bytes mit
"CPC.tapesample[CPC.recordcount] = (byte)(SoundUtil.ulawToUPCM8((byte)(a)));" setze.
Das ergibt positive Amplituden und die negativen sind falsch. (hört sich an als ob man was rückwärts und vorwärts gleichzeitig spielt)

 

[Devilmarkus]

ulawToUPCM8 wird übrigens hier berechnet:

/*
 * SoundUtil.java
 *
 * Created on 13 June 2006, 12:17
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package jemu.core.device.sound;
import jemu.ui.Switches;

/**
 *
 * @author Markus
 */
public class SoundUtil {
  
  public static final int ULAW   = 0;
  public static final int PCM8   = 1;
  public static final int UPCM8  = 2;
  public static final int PCM16  = 3;
  public static final int UPCM16 = 4;

  public static SoundPlayer getSoundPlayer(int samples, boolean stereo) {
    return new JavaSound(samples,stereo);
  }
  
  public static SoundPlayer getSoundPlayer(boolean stereo) {
    return new JavaSound(44,stereo);
  }
  
  protected static int[] ULAW_TO_PCM16 = new int[128];
  protected static byte[] PCM16_TO_ULAW = new byte[8160];
  protected static int[] PCM16_RANGE = { 0,    32,   96,   224,  480,  992,  2016, 4064, 8160 };
  protected static int[] ULAW_PREFIX = { 0xf0, 0xe0, 0xd0, 0xc0, 0xb0, 0xa0, 0x90, 0x80 };
  static {
    for (int i = 0; i < 8160; i++) {
      for (int j = 0; j < PCM16_RANGE.length - 1; j++) {
        if (i < PCM16_RANGE[j + 1]) {
          PCM16_TO_ULAW[i] = (byte)(ULAW_PREFIX[j] | 15 - (i - PCM16_RANGE[j]) / (2 << j));
          break;
        }
      }
    }
    for (int i = 0; i < 127; i++) {
      int scale = 7 - (i >> 4);
      int base = PCM16_RANGE[scale];
      ULAW_TO_PCM16[i] = base + (((15 - (i & 0x0f)) << 1) + 1) * (1 << scale);
    }
  };

  public static final byte pcm16ToULaw(int value) {
    int mask;
    if (value < 0) {
      value = -value;
      mask = 0xff;
    }
    else
      mask = 0x7f;

    value >>= 3;    // Divide by 8 (65536 / 8160).
    if (value >= 8160)
      value = 8159;
    return (byte)(PCM16_TO_ULAW[value] & mask);
  }
  
  public static final byte upcm16ToULaw(int value) {
    return pcm16ToULaw(value - 32768);
  }
  
  public static final byte pcm8ToULaw(byte value) {
    return pcm16ToULaw(value * 256);
  }
  
  public static final byte upcm8ToULaw(byte value) {
    return pcm16ToULaw((value - 128) * 256);
  }
  
  public static final int ulawToPCM16(byte value) {
    return (value & 0x80) == 0 ? (ULAW_TO_PCM16[value] << 3) : -(ULAW_TO_PCM16[value & 0x7f] << 3);
  }
  
  public static final int ulawToUPCM16(byte value) {
    return ulawToPCM16(value) + 32768;
  }

  public static final byte ulawToPCM8(byte value) {
    return (byte)
     ((value & 0x80) == 0 ? (ULAW_TO_PCM16[value] >> 5) : -(ULAW_TO_PCM16[value & 0x7f] >> 5));
  }

  public static final byte ulawToUPCM8(byte value) {
    return (byte)(ulawToPCM8(value) + 128);
  }
  
}

 

[Marco13]

Ja, so ganz steig' ich nicht durch (und werde sicher nicht versuchen, das nachzuvollziehen) aber ... capture.doCapture(a, b); wird da mit zwei ints aufgerufen, erwartet aber eigentlich bytes ... Was das mit dem ^0x80 sollte weiß ich auch nicht ... naja, Tipps die über das Einfügen von debug-Ausgaben hinausgehen hätte ich da jetzt nicht.

 

[Devilmarkus]

Nun.
Das Problem ist:

public void doCapture(byte a, byte b){
        CPC.tapesample[CPC.recordcount] = (byte)(a^0x80);
        CPC.recordcount++;
        CPC.tapesample[CPC.recordcount] = (byte)(b^0x80);
        CPC.recordcount++;
    }

Diese Methode ist völlig korrekt.
Das Ding ist aber, dass ich hier Signale eines AY-3-8910 Soundchips (emuliert natürlich) aufzeichnen möchte.
Dieser Chip sendet natürlich nur positive Signale aus. Die Bytes, welche ich schreiben möchte, kommen direkt vom Soundchip an.
Es hört sich auch völlig normal an.
Allerdings sähe es schöner aus, wenn die WAV Datei auch negative Amplituden besitzen würde.