बाइट सरणी को लघु सरणी में और फिर जावा में वापस

Question

मुझे बाइट सरणी में संग्रहीत ऑडियो डेटा लेने में कुछ समस्याएं आ रही हैं, इसे एक बड़े-एंडियन शॉर्ट सरणी में परिवर्तित करने, इसे एन्कोड करने, फिर इसे बाइट सरणी में बदलने के लिए कुछ समस्याएं हैं। यही सब कुछ मेरे पास है। मूल ऑडियो डेटा ऑडियोबाइट 2 में संग्रहीत किया जाता है। मैं इसके बजाय कॉस फ़ंक्शन पर एक ऋण के साथ डीकोड के लिए एक ही प्रारूप का उपयोग कर रहा हूं। दुर्भाग्यवश, बाइट और लघु डेटा प्रकारों को बदलना गैर-विचारणीय है।

short[] audioData = null; 
    int nlengthInSamples = audioBytes2.length/2; 
    audioData = new short[nlengthInSamples]; 

    for (int i = 0; i < nlengthInSamples; i++) { 
     short MSB = (short) audioBytes2[2*i+1]; 
     short LSB = (short) audioBytes2[2*i]; 
     audioData[i] = (short) (MSB << 8 | (255 & LSB)); 
    } 

    int i = 0; 
    while (i < audioData.length) { 
     audioData[i] = (short)(audioData[i] + (short)5*Math.cos(2*Math.PI*i/(((Number)EncodeBox.getValue()).intValue()))); 
     i++; 
    } 

    short x = 0; 
    i = 0; 
    while (i < audioData.length) { 
     x = audioData[i]; 
     audioBytes2[2*i+1] = (byte)(x >>> 0); 
     audioBytes2[2*i] = (byte)(x >>> 8); 
     i++; 
    } 

मैं सब कुछ है कि मैं इस काम करने के लिए के बारे में सोच सकते हैं किया है, लेकिन सबसे करीब मैं आए हैं हर दूसरे एनकोड/डीकोड काम करने के लिए यह हो रही है और मैं पता नहीं क्यों है। किसी भी मदद के लिए धन्यवाद।

Answer 1

आपका कोड छोटे-छोटे शॉर्ट्स कर रहा है, बड़ा नहीं। आपके पास एमएसबी और एलएसबी के लिए इंडेक्सिंग है।

चूंकि आप बड़े-एंडियन शॉर्ट्स का उपयोग कर रहे हैं, तो आप अपने स्वयं के डिकोडिंग करने के बजाए, दूसरी छोर पर बाइटएरे इनपुट इनपुट (और डेटाऑटपुटस्ट्रीम/बाइटएरे ऑटपुटस्ट्रीम) के चारों ओर लिपटे डेटा इनपुटपुट का उपयोग कर सकते हैं।

यदि आप हर दूसरे डिकोड काम कर रहे हैं, तो मुझे लगता है कि आपको बाइट्स की एक विषम संख्या है, या एक-एक-एक त्रुटि कहीं और है जो आपकी गलती को हर दूसरे पास तय करने का कारण बन रही है।

अंत में, मैं आई + = 2 के साथ सरणी के माध्यम से कदम उठाता हूं और 2 से गुणा करने के बजाय एमएसबी = एआर [i] और एलएसबी = एआर [i + 1] का उपयोग करता हूं, लेकिन यह सिर्फ मुझे है।

Answer 2

ऐसा लगता है कि आप बाइट्स को पढ़ने और उन्हें वापस लिखने के बीच बाइट ऑर्डर को स्वैप कर रहे हैं (अनिश्चित है कि यह जानबूझकर है या नहीं)।

Answer 3

कुछ बाइटबफर के बारे में कैसे?

byte[] payload = new byte[]{0x7F,0x1B,0x10,0x11}; 
ByteBuffer bb = ByteBuffer.wrap(payload).order(ByteOrder.BIG_ENDIAN); 
ShortBuffer sb = bb.asShortBuffer(); 
while(sb.hasRemaining()){ 
    System.out.println(sb.get()); 
} 

Answer 4

मैं सुझाव देता हूं कि आप बाइटबफर का प्रयास करें।

byte[] bytes = {}; 
short[] shorts = new short[bytes.length/2]; 
// to turn bytes to shorts as either big endian or little endian. 
ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(shorts); 

// to turn shorts back to bytes. 
byte[] bytes2 = new byte[shortsA.length * 2]; 
ByteBuffer.wrap(bytes2).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().put(shortsA); 

Answer 5

public short bytesToShort(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getShort(); 
} 
public byte[] shortToBytes(short value) { 
    return ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort(value).array(); 
} 

Answer 6

बाइट [2] बाइट्स;

int आर = बाइट्स [1] & 0xFF; आर = (आर < < 8) | (बाइट्स [0] & 0xFF);

लघु एस = (लघु) आर;