音频输出设备的选择

最新推荐文章于 2024-06-03 15:12:04 发布
最新推荐文章于 2024-06-03 15:12:04 发布
阅读量995 收藏 3
点赞数
分类专栏： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaopangcame/article/details/128066188
版权

音视频

场景：使用AudioTrack播放一段音频，streamtype是AUDIO_STREAM_MUSIC；

跟踪音频输出设备选择的流程，代码会走到这里：

1.frameworks\av\media\libaudioclient\AudioTrack.cpp
 
status_t AudioTrack::createTrack_l(){
 
    ......
    
    //假设此时播放的是音乐，那这里的streamType是Music类型，所以属性attr为NULL
    audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes : NULL;
    
    ......
 
    //通过属性以及stream的类型获取当前track输出的output设备；
    //传入的audio_attributes_t等参数，带回output
    status = AudioSystem::getOutputForAttr(attr, &output,
                                           mSessionId, &streamType, mClientUid,
                                           &config,
                                           mFlags, &mRoutedDeviceId, &mPortId);
 
    ......
 
}
 
 
2.frameworks\av\media\libaudioclient\AudioSystem.cpp
status_t AudioSystem::getOutputForAttr(const audio_attributes_t *attr,
                                        audio_io_handle_t *output,
                                        audio_session_t session,
                                        audio_stream_type_t *stream,
                                        uid_t uid,
                                        const audio_config_t *config,
                                        audio_output_flags_t flags,
                                        audio_port_handle_t *selectedDeviceId,
                                        audio_port_handle_t *portId)
{
    //实现类是AudioPolicyInterfaceImpl
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    if (aps == 0) return NO_INIT;
    //调用AudioPolicyInterfaceImpl.getOutputForAttr();
    return aps->getOutputForAttr(attr, output, session, stream, uid,
                                 config,
                                 flags, selectedDeviceId, portId);
}
 
3.frameworks\av\services\audiopolicy\service\AudioPolicyInterfaceImpl.cpp
status_t AudioPolicyService::getOutputForAttr(const audio_attributes_t *attr,
                                              audio_io_handle_t *output,
                                              audio_session_t session,
                                              audio_stream_type_t *stream,
                                              uid_t uid,
                                              const audio_config_t *config,
                                              audio_output_flags_t flags,
                                              audio_port_handle_t *selectedDeviceId,
                                              audio_port_handle_t *portId)
{
    if (mAudioPolicyManager == NULL) {
        return NO_INIT;
    }
    ALOGV("getOutput()");
    Mutex::Autolock _l(mLock);
 
    const uid_t callingUid = IPCThreadState::self()->getCallingUid();
    if (!isTrustedCallingUid(callingUid) || uid == (uid_t)-1) {
        ALOGW_IF(uid != (uid_t)-1 && uid != callingUid,
                "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, uid);
        uid = callingUid;
    }
    //进入AudioPolicyManager
    return mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
                                                 config,
                                                 flags, selectedDeviceId, portId);
}
 
 
4.frameworks\av\services\audiopolicy\managerdefault\AudioPolicyManager.cpp
status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
                                              audio_io_handle_t *output,
                                              audio_session_t session,
                                              audio_stream_type_t *stream,
                                              uid_t uid,
                                              const audio_config_t *config,
                                              audio_output_flags_t flags,
                                              audio_port_handle_t *selectedDeviceId,
                                              audio_port_handle_t *portId)
{
    audio_attributes_t attributes;
    //对于当前music的track，传入的attr是NULL,
    if (attr != NULL) {//判断不走
        if (!isValidAttributes(attr)) {
            ALOGE("getOutputForAttr() invalid attributes: usage=%d content=%d flags=0x%x tags=[%s]",
                  attr->usage, attr->content_type, attr->flags,
                  attr->tags);
            return BAD_VALUE;
        }
        attributes = *attr;
    } else {
        if (*stream < AUDIO_STREAM_MIN || *stream >= AUDIO_STREAM_PUBLIC_CNT) {
            ALOGE("getOutputForAttr():  invalid stream type");
            return BAD_VALUE;
        }
        //①将stream保存到attributes的属性中
        /*对于当前music的场景,attributes会被如下赋值
		    attr->content_type = AUDIO_CONTENT_TYPE_MUSIC;
       	    attr->usage = AUDIO_USAGE_MEDIA;
		*/
        stream_type_to_audio_attributes(*stream, &attributes);
    }
 
    ......
 
    *stream = streamTypefromAttributesInt(&attributes);
 
    ......
 
    //②根据当前音频的属性，获取当前track的音频策略，根据attributes选中Strategy
    routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);
 
    //③根据当前track的音频策略，获取当前音频的输出终端，根据Strategy选中device
    audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
 
    if ((attributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
        flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
    }
 
    ALOGV("getOutputForAttr() device 0x%x, samplingRate %d, format %x, channelMask %x, flags %x",
          device, config->sample_rate, config->format, config->channel_mask, flags);
 
    //④根据音频设备，音频输出标识，format等选择输出路径，根据选定的device获取Output
    *output = getOutputForDevice(device, session, *stream,
                                 config->sample_rate, config->format, config->channel_mask,
                                 flags, &config->offload_info);
    ......
 
    return NO_ERROR;
}

先看①：stream_type_to_audio_attributes(*stream, &attributes)，将stream保存到attributes的属性中：

frameworks\av\media\libaudioclient\include\media\AudioPolicyHelper.h
static inline
void stream_type_to_audio_attributes(audio_stream_type_t streamType,
                                     audio_attributes_t *attr) {
    memset(attr, 0, sizeof(audio_attributes_t));
 
    switch (streamType) {
    case AUDIO_STREAM_DEFAULT:
    case AUDIO_STREAM_MUSIC:
        attr->content_type = AUDIO_CONTENT_TYPE_MUSIC;
        attr->usage = AUDIO_USAGE_MEDIA;
        break;
    case AUDIO_STREAM_VOICE_CALL:
        attr->content_type = AUDIO_CONTENT_TYPE_SPEECH;
        attr->usage = AUDIO_USAGE_VOICE_COMMUNICATION;
        break;
    case AUDIO_STREAM_ENFORCED_AUDIBLE:
        attr->flags  |= AUDIO_FLAG_AUDIBILITY_ENFORCED;
        // intended fall through, attributes in common with STREAM_SYSTEM
    case AUDIO_STREAM_SYSTEM:
        attr->content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
        attr->usage = AUDIO_USAGE_ASSISTANCE_SONIFICATION;
        break;
    case AUDIO_STREAM_RING:
        attr->content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
        attr->usage = AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE;
        break;
    case AUDIO_STREAM_ALARM:
        attr->content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
        attr->usage = AUDIO_USAGE_ALARM;
        break;
    case AUDIO_STREAM_NOTIFICATION:
        attr->content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
        attr->usage = AUDIO_USAGE_NOTIFICATION;
        break;
    case AUDIO_STREAM_BLUETOOTH_SCO:
        attr->content_type = AUDIO_CONTENT_TYPE_SPEECH;
        attr->usage = AUDIO_USAGE_VOICE_COMMUNICATION;
        attr->flags |= AUDIO_FLAG_SCO;
        break;
    case AUDIO_STREAM_DTMF:
        attr->content_type = AUDIO_CONTENT_TYPE_SONIFICATION;
        attr->usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
        break;
    case AUDIO_STREAM_TTS:
        attr->content_type = AUDIO_CONTENT_TYPE_SPEECH;
        attr->usage = AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
        break;
    default:
        ALOGE("invalid stream type %d when converting to attributes", streamType);
    }
}

content_type:具体输出类型。android当前一共提供了11种stream_type,但一旦进入到Attribute，Android就只将其整理成几种类型。这才是实际的类型。

这里的stream_type，usage定义在audio-base.h中，content_type定义在了audio.h中：
 

1.system\media\audio\include\system\audio-base.h
typedef enum {
    AUDIO_STREAM_DEFAULT = -1, // (-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,
    AUDIO_STREAM_DTMF = 8,
    AUDIO_STREAM_TTS = 9,
    AUDIO_STREAM_ACCESSIBILITY = 10,
    AUDIO_STREAM_REROUTING = 11,
    AUDIO_STREAM_PATCH = 12,
    AUDIO_STREAM_PUBLIC_CNT = 11, // (ACCESSIBILITY + 1)
    AUDIO_STREAM_FOR_POLICY_CNT = 12, // PATCH
    AUDIO_STREAM_CNT = 13, // (PATCH + 1)
} audio_stream_type_t;
 
typedef enum {
    AUDIO_USAGE_UNKNOWN = 0,
    AUDIO_USAGE_MEDIA = 1,
    AUDIO_USAGE_VOICE_COMMUNICATION = 2,
    AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING = 3,
    AUDIO_USAGE_ALARM = 4,
    AUDIO_USAGE_NOTIFICATION = 5,
    AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE = 6,
    AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7,
    AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8,
    AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9,
    AUDIO_USAGE_NOTIFICATION_EVENT = 10,
    AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY = 11,
    AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12,
    AUDIO_USAGE_ASSISTANCE_SONIFICATION = 13,
    AUDIO_USAGE_GAME = 14,
    AUDIO_USAGE_VIRTUAL_SOURCE = 15,
    AUDIO_USAGE_ASSISTANT = 16,
    AUDIO_USAGE_CNT = 17,
    AUDIO_USAGE_MAX = 16, // (CNT - 1)
} audio_usage_t;
 
2.system\media\audio\include\system\audio.h
typedef enum {
    AUDIO_CONTENT_TYPE_UNKNOWN      = 0,
    AUDIO_CONTENT_TYPE_SPEECH       = 1,
    AUDIO_CONTENT_TYPE_MUSIC        = 2,
    AUDIO_CONTENT_TYPE_MOVIE        = 3,
    AUDIO_CONTENT_TYPE_SONIFICATION = 4,
 
    AUDIO_CONTENT_TYPE_CNT,
    AUDIO_CONTENT_TYPE_MAX          = AUDIO_CONTENT_TYPE_CNT - 1,
} audio_content_type_t;

再看②： routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);//根据当前音频的属性，获取当前track的音频策略也就是根据attributes选中Strategy：

uint32_t AudioPolicyManager::getStrategyForAttr(const audio_attributes_t *attr) {
    // flags to strategy mapping
    if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) {
        return (uint32_t) STRATEGY_TRANSMITTED_THROUGH_SPEAKER;
    }
    if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) {
        return (uint32_t) STRATEGY_ENFORCED_AUDIBLE;
    }
    // usage to strategy mapping
    //进入Engine.cpp
    //这里范围音频策略是：STRATEGY_MEDIA
    return static_cast<uint32_t>(mEngine->getStrategyForUsage(attr->usage));
}
 
 
frameworks\av\services\audiopolicy\enginedefault\src\Engine.cpp
routing_strategy Engine::getStrategyForUsage(audio_usage_t usage)
{
    // usage to strategy mapping
    switch (usage) {
    case AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY:
        return STRATEGY_ACCESSIBILITY;
 
    case AUDIO_USAGE_MEDIA:
    case AUDIO_USAGE_GAME:
    case AUDIO_USAGE_ASSISTANT:
    case AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE:
    case AUDIO_USAGE_ASSISTANCE_SONIFICATION:
        return STRATEGY_MEDIA;
 
    case AUDIO_USAGE_VOICE_COMMUNICATION:
        return STRATEGY_PHONE;
 
    case AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING:
        return STRATEGY_DTMF;
 
    case AUDIO_USAGE_ALARM:
    case AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE:
        return STRATEGY_SONIFICATION;
 
    case AUDIO_USAGE_NOTIFICATION:
    case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST:
    case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT:
    case AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED:
    case AUDIO_USAGE_NOTIFICATION_EVENT:
        return STRATEGY_SONIFICATION_RESPECTFUL;
 
    case AUDIO_USAGE_UNKNOWN:
    default:
        return STRATEGY_MEDIA;
    }
}

音频策略strategy定义在RoutingStrategy.h中：

frameworks\av\services\audiopolicy\common\include\RoutingStrategy.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,
    NUM_STRATEGIES
};

   然后看③： audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);//根据当前track的音频策略，获取当前音频的输出终端，也就是根据Strategy选中device：

audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy,
                                                         bool fromCache)
{
    ......
    return mEngine->getDeviceForStrategy(strategy);
}
 
frameworks\av\services\audiopolicy\enginedefault\src\Engine.cpp
audio_devices_t Engine::getDeviceForStrategy(routing_strategy strategy) const
{
    DeviceVector availableOutputDevices = mApmObserver->getAvailableOutputDevices();
    DeviceVector availableInputDevices = mApmObserver->getAvailableInputDevices();
 
    const SwAudioOutputCollection &outputs = mApmObserver->getOutputs();
 
    return getDeviceForStrategyInt(strategy, availableOutputDevices,
                                   availableInputDevices, outputs);
}

策略，USAGE，STREAM对应关系如下：

STRATEGY_ACCESSIBILITY
    AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY  // 11
        AUDIO_STREAM_TTS  //  9

STRATEGY_MEDIA
    AUDIO_USAGE_MEDIA  //  1
        AUDIO_STREAM_DEFAULT  // -1
        AUDIO_STREAM_MUSIC    //  3
    AUDIO_USAGE_GAME
    AUDIO_USAGE_ASSISTANT
    AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE
    AUDIO_USAGE_ASSISTANCE_SONIFICATION  //  11
        AUDIO_STREAM_ENFORCED_AUDIBLE   //  7
        AUDIO_STREAM_SYSTEM  //  1

STRATEGY_PHONE
    AUDIO_USAGE_VOICE_COMMUNICATION  //  2
        AUDIO_STREAM_VOICE_CALL  //  0
        AUDIO_STREAM_BLUETOOTH_SCO  //  6

STRATEGY_DTMF
    AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING  //  3
        AUDIO_STREAM_DTMF  //  8

STRATEGY_SONIFICATION
    AUDIO_USAGE_ALARM  // 4
        AUDIO_STREAM_ALARM  //  4
    AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE  //  6
        AUDIO_STREAM_RING  //  2

STRATEGY_SONIFICATION_RESPECTFUL
    AUDIO_USAGE_NOTIFICATION  //  5
        AUDIO_STREAM_NOTIFICATION  //  5
    AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST
    AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT
    AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED
    AUDIO_USAGE_NOTIFICATION_EVENT

STRATEGY_MEDIA
    AUDIO_USAGE_UNKNOWN  //  0
    default

xiaopangcame
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android11以上 Audio音频调试方法
我其实什么都不会
07-21 5638
本文将介绍一些常用的音频调试方法，可以帮助发现和解决音频系统的问题，提高音频质量和性能。音频调试的方法有很多，不同的方法适用于不同的场景和目的。以及它们的优缺点和使用场景。这些方法都是基于命令行工具的，可以在adb shell中执行。这些工具可以让我们获取或修改音频系统的状态、设置、参数和功能，方便我们分析和诊断音频问题。
Q：AudioPolicyManager里面的音频策略是怎么选择设备的
Good Good Study Day Day Up!!!
01-15 2650
A：AudioPolicyManager里面的音频策略是怎么选择设备的
audiopolicy
wangbuji的博客
07-04 1819
audiopolicy audioflinger audiohal
Android11 AudioTrack 创建过程
最新发布
littleyards的博客
06-03 481
首先，通过声音属性，从mProductStrategies中找到strategy，然后根据strategy，找到对应的device。mOutputs中，支持该device的output可能有多个，通过getOutputsForDevices把它们找出来，然后调用selectOutput从中选择一个最符合的。综上，找到output的流程为： audio_attributes_t >>> strategy >>> device >>> output。2，根据device，找到output。
Android8 新增加音频流类型
weixin_45613008的博客
05-18 550
old mode100644new mode100755index@@-55,6 +55,9 @@staticdefault:@@-107,6 +110,9 @@staticbreak;default:ALOGE(old mode100644new mode100755old mode100644。
易语言-BASS 音频输出设备自动切换
06-25
在IT领域，音频输出设备的自动切换是一项实用且高级的功能，尤其对于音乐播放软件来说，能够根据用户系统的声音设置变化而动态调整音频输出是提升用户体验的重要一环。在这个"易语言-BASS 音频输出设备自动切换"项目...
通过C++代码实现切换默认音频输出设备(MFC)
05-05
在本文中，我们将深入探讨如何使用C++编程语言和Microsoft Foundation Classes (MFC)库来实现音频输出设备的切换功能。MFC是微软提供的一种面向对象的C++库，用于构建Windows应用程序，它封装了许多Windows API，...
C++修改默认音频输出设备
08-03
在C++编程中，改变默认的音频输出设备是一项涉及到操作系统底层接口和音频处理技术的任务。在Windows操作系统中，这项功能通常需要使用特定的API或库来实现，如本例中提到的`PolicyConfig.h`库。`PolicyConfig.h`是...
C#控制windows音频输出设备
01-17
要选择系统中的特定音频输出设备，我们可以使用winmm.dll中的`mciSendString`函数。这个函数允许我们控制多媒体控制接口（MCI），它可以操作多种多媒体设备，包括声卡。例如，我们可以发送一个字符串命令来打开特定...
BASS 音频输出设备自动切换
05-28
在这个特定的场景中，我们讨论的是BASS音频输出设备的自动切换功能，这是一个在易语言环境中实现的创新特性。 易语言是一种中国本土开发的编程语言，它以简洁明了的语法设计，使得编程更加易于理解和学习。在易语言...
音频输出设备是如何决定的
zhuyong006的博客
03-05 6985
1. 既然是分析音频输出设备，我们首先需要知道当前手机支持的音频输出设备有哪些 adb shell dumpsys media.audio_policy &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; /home/jon/audio_policy.txt 我们关注如下字段： - Available output devices: Device 1: - id: 1 - tag name: Earpiece
Android Audio 音频路由
DengCaixiang2021的博客
06-21 3047
一、在 AudioPolicyService 中，选择音频路由时会从当前音频流的类型获取音频的路由策略：/frameworks/av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp /frameworks/av/services/audiopolicy/enginedefault/src/Engine.cpp 音频策略枚举： 二、获取到音频路由策略类型后，通过调用 getDeviceForStrategy() 选择最终的输出
Android 源码分析 - 声音 - HAL层
luansxx的专栏
10-21 3122
audio.h 声音的类型和枚举值定义在：system/core/include/system/audio.h。 输入输出端口（audio_io_handle_t） typedef int audio_io_handle_t; 流类型audio_stream_type_t（AUDIO_STREAM_*） 流类型在策略计算的主要依据。 编号 枚举 名称 说明 ...
Android Audio播放音频之数据传递
jackzhouyu的专栏
02-10 8551
AudioTrack之数据传递 简介 接上一篇AudioTrack播放音频之建立通道找到了通道的唯一句柄值output，这个output实质就是在AudioFlinger创建PlaybackThread后，以key-value形式上保存(output, PlaybackThread)的key值，通过output就可以找到播放音频将从哪个PlaybackThread线程传递数据，这个线程相当于一个中间角色，应用层进程将音频数据以匿名共享内存方式传递给PlaybackThread，而PlaybackThrea
音频策略 AudioPolicy
WhuSkypiea的博客
06-15 4670
AudioPolicy是什么 手机本身有听筒和扬声器作为音频输出，手机本身可能有底部（双）Mic、顶部Mic、背部Mic作为音频输入。 手机可能连接有线耳机、多个蓝牙耳机、多个WiFi音频外设，或者车载设备、VR设备、投屏设备等。 AudioPolicy提供了一个音频输入、输出管理的中心，当然它还有一些其他的作用。 分析AudioPolicy的方法 最直接的方法还是去看Google的官网文档，在Android Developer和Androidxref上都能看到相应的文档。 本文使用Log的方法来
Android音频子系统，音频流的回放（四）
lin20080410的专栏
11-15 1092
Audiotrack被用于音频流的回放，用来传输数据。AudioTrack支持两种数据模式：一种是Static，静态就是指数据一次性交付给对方，简单高效，一次完成所有数据的传递。适用于铃声、系统提醒等对内存要求小的播放操作。一种是streaming，流模式和基于网络的音频流回放类似，音频数据严格按照要求不断地传递给接收方，直到结束。通常适用于音频文件较大时；音频属性要求高，如采样率高、深度大的数据...
Android 录制手机内部声音（screen recorder）framework层问题分析
Death
07-05 4628
这篇文章只讨论三点： 先播放声音，再打开录屏工具，是如果保证正常录制的？ 对于secondary output，他的输出设备是怎么选择的？ 数据流是如何正常工作的？ 背景： Android的screen recorder应用层中对于手机内部声音录制部分的实现是通过AudioPlaybackCaptureConfiguration来进行录制系统声音，实现如下： 连接：ScreenInternalAudioRecorder.java - Android Code Search 88
08.音频系统:第004课_Android音频系统详解:第006节_AudioTrack创建过程
江南才尽江南山，年少无知年少狂！
04-24 1416
上面的是C++的测试函数，现在我们来看看Java的测试程序frameworks\base\media\tests\MediaFrameworkTest\src\com\android\mediaframeworktest\functional\audio\MediaAudioTrackTest.java,在使用java编写的程序之前，我们应该知道，其也存在同名的AudioTrack类。所以APP的AudioTrack和playbackThread的mTracks中的track之间需要建立共享内存。...
electron 设置音频输出设备
03-27
在 Electron 应用程序中，你可以使用 Node.js 的 `child_process` 模块来执行系统命令来设置音频输出设备。以下是一个示例代码： ```javascript const { exec } = require('child_process'); // 设置音频输出设备 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值