ऑडियो की सुविधाएं

Android TV डिवाइसों से एक साथ कई ऑडियो आउटपुट कनेक्ट किए जा सकते हैं: टीवी स्पीकर, एचडीएमआई से कनेक्ट किया गया होम सिनेमा, ब्लूटूथ हेडफ़ोन वगैरह. ये ऑडियो आउटपुट डिवाइस, ऑडियो की अलग-अलग सुविधाओं के साथ काम कर सकते हैं. जैसे, एन्कोडिंग (Dolby Digital+, DTS, और PCM), सैंपल रेट, और चैनल. उदाहरण के लिए, एचडीएमआई से कनेक्ट किए गए टीवी पर कई तरह की एन्कोडिंग काम करती हैं, जबकि कनेक्ट किए गए ब्लूटूथ हेडफ़ोन पर आम तौर पर सिर्फ़ PCM काम करता है.

उपलब्ध ऑडियो डिवाइसों की सूची और रूट किए गए ऑडियो डिवाइस में भी बदलाव हो सकता है. ऐसा, HDMI डिवाइसों को हॉट प्लग करने, ब्लूटूथ हेडफ़ोन को कनेक्ट या डिसकनेक्ट करने या उपयोगकर्ता के ऑडियो सेटिंग में बदलाव करने पर हो सकता है. ऐप्लिकेशन में मीडिया चलने के दौरान भी, ऑडियो आउटपुट की सुविधाओं में बदलाव हो सकते हैं. इसलिए, ऐप्लिकेशन को इन बदलावों के हिसाब से ढल जाना चाहिए और रूट किए गए नए ऑडियो डिवाइस और उसकी सुविधाओं पर वीडियो चलाना जारी रखना चाहिए. गलत ऑडियो फ़ॉर्मैट आउटपुट करने पर, गड़बड़ियां हो सकती हैं या आवाज़ नहीं चल सकती.

ऐप्लिकेशन में एक ही कॉन्टेंट को कई तरह के कोड में बदलने की सुविधा होती है. इससे, उपयोगकर्ता को ऑडियो डिवाइस की सुविधाओं के हिसाब से बेहतर ऑडियो अनुभव मिलता है. उदाहरण के लिए, अगर टीवी पर Dolby Digital की सुविधा काम करती है, तो Dolby Digital में एन्कोड की गई ऑडियो स्ट्रीम को चलाया जाता है. वहीं, अगर Dolby Digital की सुविधा काम नहीं करती है, तो ज़्यादातर डिवाइसों पर काम करने वाली PCM ऑडियो स्ट्रीम को चुना जाता है. ऑडियो स्ट्रीम को PCM में बदलने के लिए, Android में पहले से मौजूद डिकोडर का इस्तेमाल किया जाता है. इन डिकोडर की सूची, काम करने वाले मीडिया फ़ॉर्मैट में देखी जा सकती है.

वीडियो चलाने के दौरान, स्ट्रीमिंग ऐप्लिकेशन को सबसे बेहतर AudioTrack बनाना चाहिए. यह AudioFormat, आउटपुट ऑडियो डिवाइस के साथ काम करता है.

सही फ़ॉर्मैट में ट्रैक बनाना

ऐप्लिकेशन को AudioTrack बनाना चाहिए, उसे चलाना चाहिए, और उस डिवाइस का पता लगाने के लिए getRoutedDevice() को कॉल करना चाहिए जिस पर ऑडियो चलाना है. उदाहरण के लिए, यह एक छोटा सा सुरक्षित PCM कोड वाला ट्रैक हो सकता है. इसका इस्तेमाल सिर्फ़ रूट किए गए डिवाइस और उसके ऑडियो की क्षमताओं का पता लगाने के लिए किया जाता है.

एन्कोडिंग के काम करने वाले फ़ॉर्मैट के बारे में जानकारी

डिफ़ॉल्ट ऑडियो डिवाइस पर उपलब्ध ऑडियो फ़ॉर्मैट का पता लगाने के लिए, getAudioProfiles() (एपीआई लेवल 31 और उसके बाद के वर्शन) या getEncodings() (एपीआई लेवल 23 और उसके बाद के वर्शन) का इस्तेमाल करें.

इस्तेमाल किए जा सकने वाले ऑडियो प्रोफ़ाइल और फ़ॉर्मैट देखना

फ़ॉर्मैट, चैनल की संख्या, और सैंपल रेट के काम करने वाले कॉम्बिनेशन देखने के लिए, AudioProfile (एपीआई लेवल 31 और उसके बाद के वर्शन) या isDirectPlaybackSupported() (एपीआई लेवल 29 और उसके बाद के वर्शन) का इस्तेमाल करें.

कुछ Android डिवाइसों पर, आउटपुट ऑडियो डिवाइस पर काम करने वाली एन्कोडिंग के अलावा, दूसरी एन्कोडिंग भी काम करती हैं. इन अतिरिक्त फ़ॉर्मैट का पता isDirectPlaybackSupported() की मदद से लगाया जाना चाहिए. ऐसे मामलों में, ऑडियो डेटा को फिर से उस फ़ॉर्मैट में एन्कोड किया जाता है जो आउटपुट ऑडियो डिवाइस पर काम करता है. isDirectPlaybackSupported() का इस्तेमाल करके, अपने पसंदीदा फ़ॉर्मैट के काम करने की जांच करें. भले ही, वह getEncodings() की दी गई सूची में मौजूद न हो.

ऑडियो रूट के लिए अनुमान लगाना

Android 13 (एपीआई लेवल 33) में, ऑडियो रूट की सुविधा को पहले से तय किया जा सकता है. डिवाइस के ऑडियो एट्रिब्यूट के साथ काम करने की सुविधा का अनुमान लगाया जा सकता है. साथ ही, चालू ऑडियो डिवाइस के लिए ट्रैक तैयार किए जा सकते हैं. getDirectPlaybackSupport() का इस्तेमाल करके, यह पता लगाया जा सकता है कि किसी फ़ॉर्मैट और एट्रिब्यूट के लिए, फ़िलहाल रूट किए गए ऑडियो डिवाइस पर सीधे तौर पर वीडियो चलाने की सुविधा काम करती है या नहीं:

val format = AudioFormat.Builder()
    .setEncoding(AudioFormat.ENCODING_E_AC3)
    .setChannelMask(AudioFormat.CHANNEL_OUT_5POINT1)
    .setSampleRate(48000)
    .build()
val attributes = AudioAttributes.Builder()
    .setUsage(AudioAttributes.USAGE_MEDIA)
    .build()

if (AudioManager.getDirectPlaybackSupport(format, attributes) !=
    AudioManager.DIRECT_PLAYBACK_NOT_SUPPORTED
) {
    // The format and attributes are supported for direct playback
    // on the currently active routed audio path
} else {
    // The format and attributes are NOT supported for direct playback
    // on the currently active routed audio path
}

AudioFormat format = new AudioFormat.Builder()
        .setEncoding(AudioFormat.ENCODING_E_AC3)
        .setChannelMask(AudioFormat.CHANNEL_OUT_5POINT1)
        .setSampleRate(48000)
        .build();
AudioAttributes attributes = new AudioAttributes.Builder()
        .setUsage(AudioAttributes.USAGE_MEDIA)
        .build();

if (AudioManager.getDirectPlaybackSupport(format, attributes) !=
        AudioManager.DIRECT_PLAYBACK_NOT_SUPPORTED) {
    // The format and attributes are supported for direct playback
    // on the currently active routed audio path
} else {
    // The format and attributes are NOT supported for direct playback
    // on the currently active routed audio path
}

इसके अलावा, यह भी पता लगाया जा सकता है कि फ़िलहाल रूट किए गए ऑडियो डिवाइस से, सीधे मीडिया चलाने के लिए कौनसी प्रोफ़ाइलें काम करती हैं. इसमें ऐसी प्रोफ़ाइलें शामिल नहीं हैं जो काम नहीं करती हैं या जिन्हें Android फ़्रेमवर्क से ट्रांसकोड किया जाएगा. उदाहरण के लिए:

private fun findBestAudioFormat(audioAttributes: AudioAttributes): AudioFormat {
    val preferredFormats = listOf(
        AudioFormat.ENCODING_E_AC3,
        AudioFormat.ENCODING_AC3,
        AudioFormat.ENCODING_PCM_16BIT,
        AudioFormat.ENCODING_DEFAULT
    )
    val audioProfiles = audioManager.getDirectProfilesForAttributes(audioAttributes)
    val bestAudioProfile = preferredFormats.firstNotNullOf { format ->
        audioProfiles.firstOrNull { it.format == format }
    }
    val sampleRate = findBestSampleRate(bestAudioProfile)
    val channelMask = findBestChannelMask(bestAudioProfile)
    return AudioFormat.Builder()
        .setEncoding(bestAudioProfile.format)
        .setSampleRate(sampleRate)
        .setChannelMask(channelMask)
        .build()
}

private AudioFormat findBestAudioFormat(AudioAttributes audioAttributes) {
    Stream<Integer> preferredFormats = Stream.<Integer>builder()
            .add(AudioFormat.ENCODING_E_AC3)
            .add(AudioFormat.ENCODING_AC3)
            .add(AudioFormat.ENCODING_PCM_16BIT)
            .add(AudioFormat.ENCODING_DEFAULT)
            .build();
    Stream<AudioProfile> audioProfiles =
            audioManager.getDirectProfilesForAttributes(audioAttributes).stream();
    AudioProfile bestAudioProfile = (AudioProfile) preferredFormats.map(format ->
            audioProfiles.filter(profile -> profile.getFormat() == format)
                    .findFirst()
                    .orElseThrow(NoSuchElementException::new)
    );
    Integer sampleRate = findBestSampleRate(bestAudioProfile);
    Integer channelMask = findBestChannelMask(bestAudioProfile);
    return new AudioFormat.Builder()
            .setEncoding(bestAudioProfile.getFormat())
            .setSampleRate(sampleRate)
            .setChannelMask(channelMask)
            .build();
}

इस उदाहरण में, preferredFormats, AudioFormat इंस्टेंस की सूची है. इसमें सबसे ज़्यादा इस्तेमाल किए जाने वाले विकल्प को सबसे पहले और सबसे कम इस्तेमाल किए जाने वाले विकल्प को सबसे आखिर में रखा जाता है. getDirectProfilesForAttributes(), दिए गए AudioAttributes के साथ, फ़िलहाल रूट किए गए ऑडियो डिवाइस के लिए, काम करने वाले AudioProfile ऑब्जेक्ट की सूची दिखाता है. पसंदीदा AudioFormat आइटम की सूची में तब तक बदलाव किया जाता है, जब तक कि काम करने वाला कोई AudioProfile आइटम न मिल जाए. इस AudioProfile को bestAudioProfile के तौर पर सेव किया जाता है. ऑप्टिमम सैंपल रेट और चैनल मास्क, bestAudioProfile से तय किए जाते हैं. आखिर में, AudioFormat का सही इंस्टेंस बन जाता है.

ऑडियो ट्रैक बनाना

ऐप्लिकेशन को इस जानकारी का इस्तेमाल, डिफ़ॉल्ट ऑडियो डिवाइस पर काम करने वाली सबसे अच्छी क्वालिटी के AudioFormat के लिए AudioTrack बनाने के लिए करना चाहिए. यह AudioFormat, चुने गए कॉन्टेंट के लिए उपलब्ध होना चाहिए.

ऑडियो डिवाइस में होने वाले बदलावों को इंटरसेप्ट करना

ऑडियो डिवाइस में होने वाले बदलावों को इंटरसेप्ट करने और उन पर कार्रवाई करने के लिए, ऐप्लिकेशन को ये काम करने चाहिए:

• एपीआई लेवल 24 या उससे ज़्यादा के लिए, ऑडियो डिवाइस में होने वाले बदलावों (एचडीएमआई, ब्लूटूथ वगैरह) को मॉनिटर करने के लिए, OnRoutingChangedListener जोड़ें.
• एपीआई लेवल 23 के लिए, उपलब्ध ऑडियो डिवाइस की सूची में बदलाव पाने के लिए, AudioDeviceCallback रजिस्टर करें.
• एपीआई लेवल 21 और 22 के लिए, HDMI प्लग इवेंट को मॉनिटर करें और ब्रॉडकास्ट से मिले अतिरिक्त डेटा का इस्तेमाल करें.
• एपीआई लेवल 23 से पहले के डिवाइसों के लिए, BluetoothDevice की स्थिति में होने वाले बदलावों को मॉनिटर करने के लिए, एक BroadcastReceiver भी रजिस्टर करें. ऐसा इसलिए, क्योंकि AudioDeviceCallback अभी काम नहीं करता.

जब AudioTrack के लिए ऑडियो डिवाइस में बदलाव का पता चलता है, तो ऐप्लिकेशन को ऑडियो की अपडेट की गई सुविधाओं की जांच करनी चाहिए. साथ ही, ज़रूरत पड़ने पर, किसी दूसरे AudioFormat के साथ AudioTrack को फिर से बनाना चाहिए. ऐसा तब करें, जब अब ज़्यादा क्वालिटी वाली एन्कोडिंग काम करती हो या पहले इस्तेमाल की गई एन्कोडिंग अब काम न करती हो.

नमूना कोड

// audioPlayer is a wrapper around an AudioTrack
// which calls a callback for an AudioTrack write error
audioPlayer.addAudioTrackWriteErrorListener {
    // error code can be checked here,
    // in case of write error try to recreate the audio track
    restartAudioTrack(findDefaultAudioDeviceInfo())
}

audioPlayer.audioTrack.addOnRoutingChangedListener({ audioRouting ->
    audioRouting?.routedDevice?.let { audioDeviceInfo ->
        // use the updated audio routed device to determine
        // what audio format should be used
        if (needsAudioFormatChange(audioDeviceInfo)) {
            restartAudioTrack(audioDeviceInfo)
        }
    }
}, handler)

// audioPlayer is a wrapper around an AudioTrack
// which calls a callback for an AudioTrack write error
audioPlayer.addAudioTrackWriteErrorListener(new AudioTrackPlayer.AudioTrackWriteError() {
    @Override
    public void audioTrackWriteError(int errorCode) {
        // error code can be checked here,
        // in case of write error try to recreate the audio track
        restartAudioTrack(findDefaultAudioDeviceInfo());
    }
});

audioPlayer.getAudioTrack().addOnRoutingChangedListener(new AudioRouting.OnRoutingChangedListener() {
    @Override
    public void onRoutingChanged(AudioRouting audioRouting) {
        if (audioRouting != null && audioRouting.getRoutedDevice() != null) {
            AudioDeviceInfo audioDeviceInfo = audioRouting.getRoutedDevice();
            // use the updated audio routed device to determine
            // what audio format should be used
            if (needsAudioFormatChange(audioDeviceInfo)) {
                restartAudioTrack(audioDeviceInfo);
            }
        }
    }
}, handler);