1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
**
** Copyright 2015, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#define LOG_TAG "AudioFlinger"
//#define LOG_NDEBUG 0
#include <hardware/audio.h>
#include <utils/Log.h>
#include <audio_utils/spdif/SPDIFEncoder.h>
#include "AudioHwDevice.h"
#include "AudioStreamOut.h"
#include "SpdifStreamOut.h"
namespace android {
/**
* If the AudioFlinger is processing encoded data and the HAL expects
* PCM then we need to wrap the data in an SPDIF wrapper.
*/
SpdifStreamOut::SpdifStreamOut(AudioHwDevice *dev,
audio_output_flags_t flags,
audio_format_t format)
// Tell the HAL that the data will be compressed audio wrapped in a data burst.
: AudioStreamOut(dev, (audio_output_flags_t) (flags | AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO))
, mSpdifEncoder(this, format)
, mApplicationFormat(AUDIO_FORMAT_DEFAULT)
, mApplicationSampleRate(0)
, mApplicationChannelMask(0)
{
}
status_t SpdifStreamOut::open(
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
const char *address)
{
struct audio_config customConfig = *config;
mApplicationFormat = config->format;
mApplicationSampleRate = config->sample_rate;
mApplicationChannelMask = config->channel_mask;
// Some data bursts run at a higher sample rate.
// TODO Move this into the audio_utils as a static method.
switch(config->format) {
case AUDIO_FORMAT_E_AC3:
mRateMultiplier = 4;
break;
case AUDIO_FORMAT_AC3:
case AUDIO_FORMAT_DTS:
case AUDIO_FORMAT_DTS_HD:
mRateMultiplier = 1;
break;
default:
ALOGE("ERROR SpdifStreamOut::open() unrecognized format 0x%08X\n",
config->format);
return BAD_VALUE;
}
customConfig.sample_rate = config->sample_rate * mRateMultiplier;
customConfig.format = AUDIO_FORMAT_PCM_16_BIT;
customConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
// Always print this because otherwise it could be very confusing if the
// HAL and AudioFlinger are using different formats.
// Print before open() because HAL may modify customConfig.
ALOGI("SpdifStreamOut::open() AudioFlinger requested"
" sampleRate %d, format %#x, channelMask %#x",
config->sample_rate,
config->format,
config->channel_mask);
ALOGI("SpdifStreamOut::open() HAL configured for"
" sampleRate %d, format %#x, channelMask %#x",
customConfig.sample_rate,
customConfig.format,
customConfig.channel_mask);
status_t status = AudioStreamOut::open(
handle,
devices,
&customConfig,
address);
ALOGI("SpdifStreamOut::open() status = %d", status);
return status;
}
int SpdifStreamOut::flush()
{
mSpdifEncoder.reset();
return AudioStreamOut::flush();
}
int SpdifStreamOut::standby()
{
mSpdifEncoder.reset();
return AudioStreamOut::standby();
}
ssize_t SpdifStreamOut::writeDataBurst(const void* buffer, size_t bytes)
{
return AudioStreamOut::write(buffer, bytes);
}
ssize_t SpdifStreamOut::write(const void* buffer, size_t numBytes)
{
// Write to SPDIF wrapper. It will call back to writeDataBurst().
return mSpdifEncoder.write(buffer, numBytes);
}
} // namespace android
|
