Android新增一个音频类型及双音频输出的实现

android定义了很多种音频类型，完整定义在native层如下，system\core\include\system\audio.h文件中：

/* Audio stream types */
typedef enum {
    /* These values must kept in sync with
     * frameworks/base/media/java/android/media/AudioSystem.java
     */
    AUDIO_STREAM_DEFAULT          = -1,
    AUDIO_STREAM_MIN              = 0,
    AUDIO_STREAM_VOICE_CALL       = 0,
    AUDIO_STREAM_SYSTEM           = 1,
    AUDIO_STREAM_RING             = 2,
    AUDIO_STREAM_MUSIC            = 3,
    AUDIO_STREAM_ALARM            = 4,
    AUDIO_STREAM_NOTIFICATION     = 5,
    AUDIO_STREAM_BLUETOOTH_SCO    = 6,
    AUDIO_STREAM_ENFORCED_AUDIBLE = 7, /* Sounds that cannot be muted by user
                                        * and must be routed to speaker
                                        */
    AUDIO_STREAM_DTMF             = 8,
    AUDIO_STREAM_TTS              = 9,  /* Transmitted Through Speaker.
                                         * Plays over speaker only, silent on other devices.
                                         */
    AUDIO_STREAM_USB_HEADSET    = 10, /* For accessibility talk back prompts */
    AUDIO_STREAM_REROUTING        = 11, /* For dynamic policy output mixes */
    AUDIO_STREAM_PATCH            = 12, /* For internal audio flinger tracks. Fixed volume */
    AUDIO_STREAM_USB_MIC = 13,
     AUDIO_STREAM_ACCESSIBILITY = 14,
    AUDIO_STREAM_PUBLIC_CNT       = AUDIO_STREAM_USB_MIC + 1,
    AUDIO_STREAM_CNT              = AUDIO_STREAM_ACCESSIBILITY + 1,
} audio_stream_type_t;

android为不同音频类型设置了不同的路由，根据路由选择不同的输出设备，这便是android的音频管理策略。

比如，应用层传入的音频类型是STREAM_MUSIC，插上耳机时，这种类型的声音会从speaker切换到耳机，如果音频类型是STREAM_RING，则会从耳机和speaker同时传出来。

AudioPolicyManager.h中定义了一下几种路由策略：

 enum routing_strategy {
            STRATEGY_MEDIA,
            STRATEGY_PHONE,
            STRATEGY_SONIFICATION,
            STRATEGY_SONIFICATION_RESPECTFUL,
            STRATEGY_DTMF,
            STRATEGY_ENFORCED_AUDIBLE,
            STRATEGY_TRANSMITTED_THROUGH_SPEAKER,
            STRATEGY_ACCESSIBILITY,
            STRATEGY_REROUTING,
            STRATEGY_USB_HEADST,
            NUM_STRATEGIES
        };

根据路由为不同音频类型选择输出设备主要在AudioPolicyManager的getDeviceForStrategy方法，因此通过增加自定义音频类型和修改getDeviceForStrategy的音频策略，即可以对android的音频管理策略实现自定义。

例如实现这样的一个功能，在android智能电视上配合应用实现双音频输出的功能，即用户在看电视的过程中同时还可以听音乐，电视的声音从扬声器输出，而音乐的声音从耳机中输出，这里我们选择了一个usb 耳机设备。

实现原理即增加一个音频类型为音乐应用使用，打开双音频输出功能时，该应用传入的音频类型为我们自定义的，为该音频类型选择usb audio设备，同时，普通的tv及第三方应用使用的则是STREAM_MUSIC类型，该音频类型对应路由策略的是STRATEGY_MEDIA类型，我们在双音频功能打开的时候为该策略强制选择speaker设备，这样即实现了我们的双音频功能。

 case STRATEGY_USB_HEADST:
    case STRATEGY_MEDIA: {
	char propDoubOutput[PROPERTY_VALUE_MAX];
	property_get("audio.output.double_output",propDoubOutput,"null");
           if ((strcmp(propDoubOutput,"1") == 0) && strategy == STRATEGY_USB_HEADST)  {
  	    device = mAvailableOutputDevices.types()  &  AUDIO_DEVICE_OUT_USB_DEVICE;
	    if (device != AUDIO_DEVICE_NONE) {
                  device = AUDIO_DEVICE_OUT_USB_DEVICE;
	    }else{
                   ALOGE("getDeviceForStrategy() no device found for STRATEGY_USB_HEADST");
	    }
         } else {
        uint32_t device2 = AUDIO_DEVICE_NONE;
        if (strategy != STRATEGY_SONIFICATION) {
            // no sonification on remote submix (e.g. WFD)
            if (mAvailableOutputDevices.getDevice(AUDIO_DEVICE_OUT_REMOTE_SUBMIX, String8("0")) != 0) {
                device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
            }
        }
 
  
 
  
 
  
 
  
 
  

 STRATEGY_USB_HEADST类型是我们自定义的策略类型，"audio.output.double_output"为我们自己添加的一个属性，作为底层判断是否上层设置了双音频属性，可以看出在非双音频模式下，STRATEGY_USB_HEADST类型与MEDIA类型是完全一样的，在设置了双音频属性时，我们为  STRATEGY_USB_HEADST类型选择了usbaudio设备，device = AUDIO_DEVICE_OUT_USB_DEVICE;而同时我们还要为MEDIA设备选择speaker设备： 
  
 
  
 
  
 property_get("audio.output.double_output",propDoubOutput,"null");
           if (strcmp(propDoubOutput, "1") ==0) {
        		device = AUDIO_DEVICE_OUT_AUX_DIGITAL |AUDIO_DEVICE_OUT_SPEAKER; 
     	   } else {
        		device |= device2;    
     	   }
 
  
 选择设备的工作基本就做完了，但是前提是需要j从ava层到framework层为该音频类型打通过程。实际上这个参照一种音频类型的实现就很容易解决。基本上理清一个audiotrack从java层到native层的调用过程即可，在java层audiomanger与audiosystem中添加我们自定义的音频类型之后来看audiotrack的构造函数，5.1之于4.4多了一个AudioAttributes，这对上层传下来的streamType做了一层封装，看上去是更方便了我们的扩展，通过上层stream_type转化得到  private int mUsage = USAGE_UNKNOWN; 
  
      和   private int mContentType = CONTENT_TYPE_UNKNOWN两种类型，到了native层AudioTrack.cpp的set函数中： 
  
 
  
status_t AudioTrack::set(
        audio_stream_type_t streamType,
        uint32_t sampleRate,
        audio_format_t format,
        audio_channel_mask_t channelMask,
        size_t frameCount,
        audio_output_flags_t flags,
        callback_t cbf,
        void* user,
        uint32_t notificationFrames,
        const sp& sharedBuffer,
        bool threadCanCallJava,
        int sessionId,
        transfer_type transferType,
        const audio_offload_info_t *offloadInfo,
        int uid,
        pid_t pid,
        const audio_attributes_t* pAttributes)
{

    ALOGI("set(): %p streamType %d, sampleRate %u, format %#x, channelMask %#x, frameCount %zu, "
          "flags #%x, notificationFrames %u, sessionId %d, transferType %d",
          this,streamType, sampleRate, format, channelMask, frameCount, flags, notificationFrames,
          sessionId, transferType);


    switch (transferType) {
    case TRANSFER_DEFAULT:
        if (sharedBuffer != 0) {
            transferType = TRANSFER_SHARED;
        } else if (cbf == NULL || threadCanCallJava) {
            transferType = TRANSFER_SYNC;
        } else {
            transferType = TRANSFER_CALLBACK;
        }
        break;
    case TRANSFER_CALLBACK:
        if (cbf == NULL || sharedBuffer != 0) {
            ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL || sharedBuffer != 0");
            return BAD_VALUE;
        }
        break;
    case TRANSFER_OBTAIN:
    case TRANSFER_SYNC:
        if (sharedBuffer != 0) {
            ALOGE("Transfer type TRANSFER_OBTAIN but sharedBuffer != 0");
            return BAD_VALUE;
        }
        break;
    case TRANSFER_SHARED:
        if (sharedBuffer == 0) {
            ALOGE("Transfer type TRANSFER_SHARED but sharedBuffer == 0");
            return BAD_VALUE;
        }
        break;
    default:
        ALOGE("Invalid transfer type %d", transferType);
        return BAD_VALUE;
    }
    mSharedBuffer = sharedBuffer;
    mTransfer = transferType;

    ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(),
            sharedBuffer->size());

    ALOGV("set() streamType %d frameCount %zu flags %04x", streamType, frameCount, flags);

    AutoMutex lock(mLock);

    // invariant that mAudioTrack != 0 is true only after set() returns successfully
    if (mAudioTrack != 0) {
        ALOGE("Track already in use");
        return INVALID_OPERATION;
    }

    // handle default values first.
    if (streamType == AUDIO_STREAM_DEFAULT) {
        streamType = AUDIO_STREAM_MUSIC;
    }
    if (pAttributes == NULL) {
        if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) {
            ALOGE("Invalid stream type %d", streamType);
            return BAD_VALUE;
        }
        mStreamType = streamType;

    } else {
        // stream type shouldn't be looked at, this track has audio attributes
        memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));
        ALOGV("Building AudioTrack with attributes: usage=%d content=%d flags=0x%x tags=[%s]",
                mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags);
    	   mStreamType = AUDIO_STREAM_DEFAULT;
    }

    // these below should probably come from the audioFlinger too...
    if (format == AUDIO_FORMAT_DEFAULT) {
        format = AUDIO_FORMAT_PCM_16_BIT;
    }
......
看到   mStreamType = AUDIO_STREAM_DEFAULT; stream_type已经被设为-1，后面获取设备时不再关心stream_type,而是由audio_attributes_t这个结构体来选择，再来看看这个结构体的定义： 
  
 
  
typedef struct {
    audio_content_type_t content_type;
    audio_usage_t        usage;
    audio_source_t       source;
    audio_flags_mask_t   flags;
    char                 tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE]; /* UTF8 */
} audio_attributes_t;
 
  
 正是前面提到的mUsage 和mContentType 。 
  
再回到AudioPolicyManager，看看getOutputForAttr接口，改接口调用了我们之前修改过的getDeviceForStrategy来获取设备：
 
  
 
  
......
 ALOGV("getOutputForAttr() usage=%d, content=%d, tag=%s flags=%08x",
            attributes.usage, attributes.content_type, attributes.tags, attributes.flags);

    routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);
    audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
......
 
  
 
  
 所以在上层将stream_type 与AudioAttributes的转换做好，这条路就基本打通了，双音频输出的功能就实现了。