Cette page a été traduite par l'API Cloud Translation.

Audio TV

Le gestionnaire TIF (TV Input Framework) fonctionne avec l'API de routage audio pour assurer la flexibilité de l'audio modifications de chemin d'accès. Lorsqu'un système sur puce (SoC) implémente la couche d'abstraction matérielle du téléviseur (HAL), chaque L'entrée TV (HDMI IN, tuner, etc.) fournit des TvInputHardwareInfo qui spécifient les informations AudioPort du type audio et de l'adresse.

Les périphériques d'entrée/sortie audio physiques disposent d'un AudioPort correspondant.
Les flux de sortie/d'entrée audio logiciels sont représentés par AudioMixPort (classe enfant des AudioPort).

Le TIF utilise ensuite les informations AudioPort pour l'API de routage audio.

Framework d'entrée Android TV (TIF)

Figure 1 : TV Input Framework (TIF)

Conditions requises

Un SoC doit implémenter la couche HAL audio avec la compatibilité de l'API de routage audio suivante:

Ports audio	L'entrée audio du téléviseur dispose d'une implémentation correspondante du port source audio. La sortie audio du téléviseur dispose d'une implémentation de port de récepteur audio correspondante. Peut créer un correctif audio entre n'importe quel port audio d'entrée TV et n'importe quel port audio de sortie TV.
Entrée par défaut	AudioRecord (créé avec une source d'entrée DEFAULT) doit saisir une source d'entrée virtuelle nulle pour Acquisition de 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 constitue un mix complet de toutes les sorties audio de toute la sortie TV (11 kHz, 16 bits mono ou 48 kHz, 16 bits mono). Utilisé uniquement pour la capture audio.

Appareils audio TV

Android est compatible avec les appareils audio suivants pour l'entrée/la sortie audio du téléviseur.

`system/media/audio/include/system/audio.h`

Remarque:Sur Android 5.1 et versions antérieures, le chemin d'accès ce fichier est: 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 Audio HAL

L'extension Audio HAL pour l'API de routage audio est définie comme suit:

`system/media/audio/include/system/audio.h`

Remarque:Sur Android 5.1 et versions antérieures, le chemin d'accès ce fichier est: 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 TV, utilisez le code de test suivant. Après avoir exécuté la le contenu 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.");
   }

Localisez le fichier audio capturé dans /sdcard/record_loopback.raw et écoutez-le avec FFmpeg:

adb pull /sdcard/record_loopback.raw
ffmpeg -f s16le -ar 48k -ac 1 -i record_loopback.raw record_loopback.wav
ffplay record_loopback.wav

Cas d'utilisation

Cette section présente des cas d'utilisation courants du contenu audio d'un téléviseur.

Tuner TV avec sortie haut-parleur

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 est mélangée avec software output_stream.

Figure 2. Correctif audio pour le tuner TV avec sortie haut-parleur.

HDMI OUT pendant la télévision en direct

Un utilisateur regarde la télévision en direct, puis passe à la sortie audio HDMI (Intent.ACTION_HDMI_AUDIO_PLUG) pour en savoir plus. Le périphérique de sortie de tous les éléments "output_stream" passe au port HDMI_OUT et le gestionnaire TIF change. le port récepteur du correctif audio du tuner existant vers le port HDMI_OUT.

Figure 3. Correctif audio pour HDMI OUT sur la télévision en direct.