Le gestionnaire TV Input Framework (TIF) fonctionne avec l'API de routage audio pour permettre des modifications flexibles des chemins audio. Lorsqu'un système sur puce (SoC) implémente la couche d'abstraction matérielle (HAL) du téléviseur, chaque entrée du téléviseur (entrée HDMI, tuner, etc.) fournit TvInputHardwareInfo qui spécifie les informations AudioPort pour le type et l'adresse audio.
- Les périphériques d'entrée/sortie audio physiques disposent d'un port audio correspondant.
- Les flux de sortie/entrée audio logiciels sont représentés par AudioMixPort (classe enfant d'AudioPort).
Le TIF utilise ensuite les informations AudioPort pour l'API de routage audio.
Figure 1 : TV Input Framework (TIF)
Conditions requises
Un SoC doit implémenter le HAL audio avec la prise en charge des API de routage audio suivantes:
| Ports audio |
|
|---|---|
| Saisie par défaut | AudioRecord (créé avec la source d'entrée par défaut) doit saisir la source d'entrée nulle virtuelle pour l'acquisition AUDIO_DEVICE_IN_DEFAULT sur Android TV. |
| Bouclage de l'appareil | Nécessite la prise en charge d'une entrée AUDIO_DEVICE_IN_LOOPBACK, qui est un mixage complet de toutes les sorties audio de toutes les sorties du téléviseur (11 kHz, mono 16 bits ou 48 kHz, mono 16 bits). Utilisé uniquement pour la capture audio. |
Appareils audio TV
Android est compatible avec les appareils audio suivants pour l'entrée/la sortie audio de la télévision.
system/media/audio/include/system/audio.h
Remarque:Sous Android 5.1 et versions antérieures, le chemin d'accès à ce fichier est le suivant: system/core/include/system/audio.h
/* output devices */ AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400, AUDIO_DEVICE_OUT_HDMI = AUDIO_DEVICE_OUT_AUX_DIGITAL, /* HDMI Audio Return Channel */ AUDIO_DEVICE_OUT_HDMI_ARC = 0x40000, /* S/PDIF out */ AUDIO_DEVICE_OUT_SPDIF = 0x80000, /* input devices */ AUDIO_DEVICE_IN_AUX_DIGITAL = AUDIO_DEVICE_BIT_IN | 0x20, AUDIO_DEVICE_IN_HDMI = AUDIO_DEVICE_IN_AUX_DIGITAL, /* TV tuner input */ AUDIO_DEVICE_IN_TV_TUNER = AUDIO_DEVICE_BIT_IN | 0x4000, /* S/PDIF in */ AUDIO_DEVICE_IN_SPDIF = AUDIO_DEVICE_BIT_IN | 0x10000, AUDIO_DEVICE_IN_LOOPBACK = AUDIO_DEVICE_BIT_IN | 0x40000,
Extension du HAL audio
L'extension HAL audio pour l'API de routage audio est définie comme suit:
system/media/audio/include/system/audio.h
Remarque:Sous Android 5.1 ou version antérieure, le chemin d'accès à ce fichier est le suivant: system/core/include/system/audio.h
/* audio port configuration structure used to specify a particular configuration of an audio port */
struct audio_port_config {
audio_port_handle_t id; /* port unique ID */
audio_port_role_t role; /* sink or source */
audio_port_type_t type; /* device, mix ... */
unsigned int config_mask; /* e.g. AUDIO_PORT_CONFIG_ALL */
unsigned int sample_rate; /* sampling rate in Hz */
audio_channel_mask_t channel_mask; /* channel mask if applicable */
audio_format_t format; /* format if applicable */
struct audio_gain_config gain; /* gain to apply if applicable */
union {
struct audio_port_config_device_ext device; /* device specific info */
struct audio_port_config_mix_ext mix; /* mix specific info */
struct audio_port_config_session_ext session; /* session specific info */
} ext;
};
struct audio_port {
audio_port_handle_t id; /* port unique ID */
audio_port_role_t role; /* sink or source */
audio_port_type_t type; /* device, mix ... */
unsigned int num_sample_rates; /* number of sampling rates in following array */
unsigned int sample_rates[AUDIO_PORT_MAX_SAMPLING_RATES];
unsigned int num_channel_masks; /* number of channel masks in following array */
audio_channel_mask_t channel_masks[AUDIO_PORT_MAX_CHANNEL_MASKS];
unsigned int num_formats; /* number of formats in following array */
audio_format_t formats[AUDIO_PORT_MAX_FORMATS];
unsigned int num_gains; /* number of gains in following array */
struct audio_gain gains[AUDIO_PORT_MAX_GAINS];
struct audio_port_config active_config; /* current audio port configuration */
union {
struct audio_port_device_ext device;
struct audio_port_mix_ext mix;
struct audio_port_session_ext session;
} ext;
};
hardware/libhardware/include/hardware/audio.h
struct audio_hw_device {
:
/**
* Routing control
*/
/* Creates an audio patch between several source and sink ports.
* The handle is allocated by the HAL and should be unique for this
* audio HAL module. */
int (*create_audio_patch)(struct audio_hw_device *dev,
unsigned int num_sources,
const struct audio_port_config *sources,
unsigned int num_sinks,
const struct audio_port_config *sinks,
audio_patch_handle_t *handle);
/* Release an audio patch */
int (*release_audio_patch)(struct audio_hw_device *dev,
audio_patch_handle_t handle);
/* Fills the list of supported attributes for a given audio port.
* As input, "port" contains the information (type, role, address etc...)
* needed by the HAL to identify the port.
* As output, "port" contains possible attributes (sampling rates, formats,
* channel masks, gain controllers...) for this port.
*/
int (*get_audio_port)(struct audio_hw_device *dev,
struct audio_port *port);
/* Set audio port configuration */
int (*set_audio_port_config)(struct audio_hw_device *dev,
const struct audio_port_config *config);
Test de DEVICE_IN_LOOPBACK
Pour tester DEVICE_IN_LOOPBACK pour la surveillance de la télévision, utilisez le code de test suivant. Après avoir exécuté le test, l'audio capturé est enregistré dans /sdcard/record_loopback.raw, où vous pouvez l'écouter à l'aide de FFmpeg.
<uses-permission android:name="android.permission.MODIFY_AUDIO_ROUTING" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
AudioRecord mRecorder;
Handler mHandler = new Handler();
int mMinBufferSize = AudioRecord.getMinBufferSize(RECORD_SAMPLING_RATE,
AudioFormat.CHANNEL_IN_MONO,
AudioFormat.ENCODING_PCM_16BIT);;
static final int RECORD_SAMPLING_RATE = 48000;
public void doCapture() {
mRecorder = new AudioRecord(MediaRecorder.AudioSource.DEFAULT, RECORD_SAMPLING_RATE,
AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, mMinBufferSize * 10);
AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
ArrayList<AudioPort> audioPorts = new ArrayList<AudioPort>();
am.listAudioPorts(audioPorts);
AudioPortConfig srcPortConfig = null;
AudioPortConfig sinkPortConfig = null;
for (AudioPort audioPort : audioPorts) {
if (srcPortConfig == null
&& audioPort.role() == AudioPort.ROLE_SOURCE
&& audioPort instanceof AudioDevicePort) {
AudioDevicePort audioDevicePort = (AudioDevicePort) audioPort;
if (audioDevicePort.type() == AudioManager.DEVICE_IN_LOOPBACK) {
srcPortConfig = audioPort.buildConfig(48000, AudioFormat.CHANNEL_IN_DEFAULT,
AudioFormat.ENCODING_DEFAULT, null);
Log.d(LOG_TAG, "Found loopback audio source port : " + audioPort);
}
}
else if (sinkPortConfig == null
&& audioPort.role() == AudioPort.ROLE_SINK
&& audioPort instanceof AudioMixPort) {
sinkPortConfig = audioPort.buildConfig(48000, AudioFormat.CHANNEL_OUT_DEFAULT,
AudioFormat.ENCODING_DEFAULT, null);
Log.d(LOG_TAG, "Found recorder audio mix port : " + audioPort);
}
}
if (srcPortConfig != null && sinkPortConfig != null) {
AudioPatch[] patches = new AudioPatch[] { null };
int status = am.createAudioPatch(
patches,
new AudioPortConfig[] { srcPortConfig },
new AudioPortConfig[] { sinkPortConfig });
Log.d(LOG_TAG, "Result of createAudioPatch(): " + status);
}
mRecorder.startRecording();
processAudioData();
mRecorder.stop();
mRecorder.release();
}
private void processAudioData() {
OutputStream rawFileStream = null;
byte data[] = new byte[mMinBufferSize];
try {
rawFileStream = new BufferedOutputStream(
new FileOutputStream(new File("/sdcard/record_loopback.raw")));
} catch (FileNotFoundException e) {
Log.d(LOG_TAG, "Can't open file.", e);
}
long startTimeMs = System.currentTimeMillis();
while (System.currentTimeMillis() - startTimeMs < 5000) {
int nbytes = mRecorder.read(data, 0, mMinBufferSize);
if (nbytes <= 0) {
continue;
}
try {
rawFileStream.write(data);
} catch (IOException e) {
Log.e(LOG_TAG, "Error on writing raw file.", e);
}
}
try {
rawFileStream.close();
} catch (IOException e) {
}
Log.d(LOG_TAG, "Exit audio recording.");
}
Recherchez le fichier audio capturé dans /sdcard/record_loopback.raw et écoutez-le à l'aide de FFmpeg:
adb pull /sdcard/record_loopback.rawffmpeg -f s16le -ar 48k -ac 1 -i record_loopback.raw record_loopback.wavffplay record_loopback.wav
Cas d'utilisation
Cette section inclut des cas d'utilisation courants de l'audio TV.
Tuner TV avec sortie pour haut-parleurs
Lorsqu'un tuner TV devient actif, l'API de routage audio crée un correctif audio entre le tuner et la sortie par défaut (par exemple, le haut-parleur). La sortie du tuner ne nécessite pas de décodage, mais la sortie audio finale est mélangée avec le logiciel output_stream.
Figure 2. Correction audio pour le tuner TV avec sortie vers les haut-parleurs.
Sortie HDMI pendant la diffusion d'une émission en direct
Un utilisateur regarde la télévision en direct, puis passe à la sortie audio HDMI (Intent.ACTION_HDMI_AUDIO_PLUG). Le périphérique de sortie de tous les flux de sortie est remplacé par le port HDMI_OUT, et le gestionnaire TIF remplace le port de destination du patch audio du tuner existant par le port HDMI_OUT.
Figure 3. Patch audio pour la sortie HDMI de la télévision en direct.