sonido de televisión

El administrador de TV Input Framework (TIF) funciona con la API de enrutamiento de audio para admitir cambios flexibles de ruta de audio. Cuando un System on Chip (SoC) implementa la capa de abstracción de hardware de TV (HAL), cada entrada de TV (HDMI IN, sintonizador, etc.) proporciona TvInputHardwareInfo que especifica información de AudioPort para el tipo y la dirección de audio.

  • Los dispositivos físicos de entrada/salida de audio tienen un AudioPort correspondiente.
  • Los flujos de entrada/salida de audio del software se representan como AudioMixPort (clase secundaria de AudioPort).

Luego, el TIF utiliza la información de AudioPort para la API de enrutamiento de audio.

Marco de entrada de Android TV (TIF)

Figura 1. Marco de entrada de TV (TIF)

Requisitos

Un SoC debe implementar el HAL de audio con la siguiente compatibilidad con API de enrutamiento de audio:

Puertos de audio
  • La entrada de audio del televisor tiene una implementación de puerto de fuente de audio correspondiente.
  • La salida de audio del televisor tiene una implementación de puerto receptor de audio correspondiente.
  • Puede crear un parche de audio entre cualquier puerto de audio de entrada de TV y cualquier puerto de salida de audio de TV.
Entrada predeterminada AudioRecord (creado con la fuente de entrada DEFAULT) debe aprovechar la fuente de entrada nula virtual para la adquisición de AUDIO_DEVICE_IN_DEFAULT en Android TV.
Bucle invertido del dispositivo Requiere admitir una entrada AUDIO_DEVICE_IN_LOOPBACK que sea una mezcla completa de todas las salidas de audio de todas las salidas de TV (11 Khz, 16 bits mono o 48 Khz, 16 bits mono). Se utiliza sólo para captura de audio.

dispositivos de audio de televisión

Android admite los siguientes dispositivos de audio para entrada/salida de audio de TV.

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

Nota: En Android 5.1 y versiones anteriores, la ruta a este archivo es: 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,

Extensión de audio HAL

La extensión Audio HAL para la API de enrutamiento de audio se define de la siguiente manera:

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

Nota: En Android 5.1 y versiones anteriores, la ruta a este archivo es: 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);

Probando DEVICE_IN_LOOPBACK

Para probar DEVICE_IN_LOOPBACK para monitoreo de TV, use el siguiente código de prueba. Después de ejecutar la prueba, el audio capturado se guarda en /sdcard/record_loopback.raw , donde puedes escucharlo usando 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.");
   }

Localice el archivo de audio capturado en /sdcard/record_loopback.raw y escúchelo usando 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

Casos de uso

Esta sección incluye casos de uso comunes para el audio de TV.

Sintonizador de TV con salida de altavoz

Cuando un sintonizador de TV se activa, la API de enrutamiento de audio crea un parche de audio entre el sintonizador y la salida predeterminada (por ejemplo, el altavoz). La salida del sintonizador no requiere decodificación, pero la salida de audio final se mezcla con el software output_stream.

Parche de audio del sintonizador de TV Android

Figura 2. Patch de audio para sintonizador de TV con salida de altavoz.

SALIDA HDMI durante la TV en vivo

Un usuario está viendo televisión en vivo y luego cambia a la salida de audio HDMI (Intent.ACTION_HDMI_AUDIO_PLUG). El dispositivo de salida de todos los output_streams cambia al puerto HDMI_OUT y el administrador TIF cambia el puerto receptor del parche de audio del sintonizador existente al puerto HDMI_OUT.

Parche de audio con salida HDMI para Android TV

Figura 3. Parche de audio para HDMI OUT desde TV en vivo.