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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
package net.ypresto.androidtranscoder.engine;
import android.media.MediaCodec;
import android.media.MediaFormat;
import net.ypresto.androidtranscoder.compat.MediaCodecBufferCompatWrapper;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;
import java.util.ArrayDeque;
import java.util.Queue;
/**
* Channel of raw audio from decoder to encoder.
* Performs the necessary conversion between different input & output audio formats.
*
* We currently support upmixing from mono to stereo & downmixing from stereo to mono.
* Sample rate conversion is not supported yet.
*/
class AudioChannel {
private static class AudioBuffer {
int bufferIndex;
long presentationTimeUs;
ShortBuffer data;
}
public static final int BUFFER_INDEX_END_OF_STREAM = -1;
private static final int BYTES_PER_SHORT = 2;
private static final long MICROSECS_PER_SEC = 1000000;
private final Queue<AudioBuffer> mEmptyBuffers = new ArrayDeque<>();
private final Queue<AudioBuffer> mFilledBuffers = new ArrayDeque<>();
private final MediaCodec mDecoder;
private final MediaCodec mEncoder;
private final MediaFormat mEncodeFormat;
private int mInputSampleRate;
private int mInputChannelCount;
private int mOutputChannelCount;
private AudioRemixer mRemixer;
private final MediaCodecBufferCompatWrapper mDecoderBuffers;
private final MediaCodecBufferCompatWrapper mEncoderBuffers;
private final AudioBuffer mOverflowBuffer = new AudioBuffer();
private MediaFormat mActualDecodedFormat;
public AudioChannel(final MediaCodec decoder,
final MediaCodec encoder, final MediaFormat encodeFormat) {
mDecoder = decoder;
mEncoder = encoder;
mEncodeFormat = encodeFormat;
mDecoderBuffers = new MediaCodecBufferCompatWrapper(mDecoder);
mEncoderBuffers = new MediaCodecBufferCompatWrapper(mEncoder);
}
public void setActualDecodedFormat(final MediaFormat decodedFormat) {
mActualDecodedFormat = decodedFormat;
mInputSampleRate = mActualDecodedFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE);
if (mInputSampleRate != mEncodeFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)) {
throw new UnsupportedOperationException("Audio sample rate conversion not supported yet.");
}
mInputChannelCount = mActualDecodedFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
mOutputChannelCount = mEncodeFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
if (mInputChannelCount != 1 && mInputChannelCount != 2) {
throw new UnsupportedOperationException("Input channel count (" + mInputChannelCount + ") not supported.");
}
if (mOutputChannelCount != 1 && mOutputChannelCount != 2) {
throw new UnsupportedOperationException("Output channel count (" + mOutputChannelCount + ") not supported.");
}
if (mInputChannelCount > mOutputChannelCount) {
mRemixer = AudioRemixer.DOWNMIX;
} else if (mInputChannelCount < mOutputChannelCount) {
mRemixer = AudioRemixer.UPMIX;
} else {
mRemixer = AudioRemixer.PASSTHROUGH;
}
mOverflowBuffer.presentationTimeUs = 0;
}
public void drainDecoderBufferAndQueue(final int bufferIndex, final long presentationTimeUs) {
if (mActualDecodedFormat == null) {
throw new RuntimeException("Buffer received before format!");
}
final ByteBuffer data =
bufferIndex == BUFFER_INDEX_END_OF_STREAM ?
null : mDecoderBuffers.getOutputBuffer(bufferIndex);
AudioBuffer buffer = mEmptyBuffers.poll();
if (buffer == null) {
buffer = new AudioBuffer();
}
buffer.bufferIndex = bufferIndex;
buffer.presentationTimeUs = presentationTimeUs;
buffer.data = data == null ? null : data.asShortBuffer();
if (mOverflowBuffer.data == null) {
mOverflowBuffer.data = ByteBuffer
.allocateDirect(data.capacity())
.order(ByteOrder.nativeOrder())
.asShortBuffer();
mOverflowBuffer.data.clear().flip();
}
mFilledBuffers.add(buffer);
}
public boolean feedEncoder(long timeoutUs) {
final boolean hasOverflow = mOverflowBuffer.data != null && mOverflowBuffer.data.hasRemaining();
if (mFilledBuffers.isEmpty() && !hasOverflow) {
// No audio data - Bail out
return false;
}
final int encoderInBuffIndex = mEncoder.dequeueInputBuffer(timeoutUs);
if (encoderInBuffIndex < 0) {
// Encoder is full - Bail out
return false;
}
// Drain overflow first
final ShortBuffer outBuffer = mEncoderBuffers.getInputBuffer(encoderInBuffIndex).asShortBuffer();
if (hasOverflow) {
final long presentationTimeUs = drainOverflow(outBuffer);
mEncoder.queueInputBuffer(encoderInBuffIndex,
0, outBuffer.position() * BYTES_PER_SHORT,
presentationTimeUs, 0);
return true;
}
final AudioBuffer inBuffer = mFilledBuffers.poll();
if (inBuffer.bufferIndex == BUFFER_INDEX_END_OF_STREAM) {
mEncoder.queueInputBuffer(encoderInBuffIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
return false;
}
final long presentationTimeUs = remixAndMaybeFillOverflow(inBuffer, outBuffer);
mEncoder.queueInputBuffer(encoderInBuffIndex,
0, outBuffer.position() * BYTES_PER_SHORT,
presentationTimeUs, 0);
if (inBuffer != null) {
mDecoder.releaseOutputBuffer(inBuffer.bufferIndex, false);
mEmptyBuffers.add(inBuffer);
}
return true;
}
private static long sampleCountToDurationUs(final int sampleCount,
final int sampleRate,
final int channelCount) {
return (sampleCount / (sampleRate * MICROSECS_PER_SEC)) / channelCount;
}
private long drainOverflow(final ShortBuffer outBuff) {
final ShortBuffer overflowBuff = mOverflowBuffer.data;
final int overflowLimit = overflowBuff.limit();
final int overflowSize = overflowBuff.remaining();
final long beginPresentationTimeUs = mOverflowBuffer.presentationTimeUs +
sampleCountToDurationUs(overflowBuff.position(), mInputSampleRate, mOutputChannelCount);
outBuff.clear();
// Limit overflowBuff to outBuff's capacity
overflowBuff.limit(outBuff.capacity());
// Load overflowBuff onto outBuff
outBuff.put(overflowBuff);
if (overflowSize >= outBuff.capacity()) {
// Overflow fully consumed - Reset
overflowBuff.clear().limit(0);
} else {
// Only partially consumed - Keep position & restore previous limit
overflowBuff.limit(overflowLimit);
}
return beginPresentationTimeUs;
}
private long remixAndMaybeFillOverflow(final AudioBuffer input,
final ShortBuffer outBuff) {
final ShortBuffer inBuff = input.data;
final ShortBuffer overflowBuff = mOverflowBuffer.data;
outBuff.clear();
// Reset position to 0, and set limit to capacity (Since MediaCodec doesn't do that for us)
inBuff.clear();
if (inBuff.remaining() > outBuff.remaining()) {
// Overflow
// Limit inBuff to outBuff's capacity
inBuff.limit(outBuff.capacity());
mRemixer.remix(inBuff, outBuff);
// Reset limit to its own capacity & Keep position
inBuff.limit(inBuff.capacity());
// Remix the rest onto overflowBuffer
// NOTE: We should only reach this point when overflow buffer is empty
final long consumedDurationUs =
sampleCountToDurationUs(inBuff.position(), mInputSampleRate, mInputChannelCount);
mRemixer.remix(inBuff, overflowBuff);
// Seal off overflowBuff & mark limit
overflowBuff.flip();
mOverflowBuffer.presentationTimeUs = input.presentationTimeUs + consumedDurationUs;
} else {
// No overflow
mRemixer.remix(inBuff, outBuff);
}
return input.presentationTimeUs;
}
}
|
