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
|
/*
* Copyright (C) 2010 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.
*/
package android.media;
import java.util.List;
import java.util.ArrayList;
/**
* The EncoderCapabilities class is used to retrieve the
* capabilities for different video and audio
* encoders supported on a specific Android platform.
* {@hide}
*/
public class EncoderCapabilities
{
private static final String TAG = "EncoderCapabilities";
/**
* The VideoEncoderCap class represents a video encoder's
* supported parameter range in:
*
* <ul>
* <li>Resolution: the frame size (width/height) in pixels;
* <li>Bit rate: the compressed output bit rate in bits per second;
* <li>Frame rate: the output number of frames per second.
* </ul>
*
*/
static public class VideoEncoderCap {
// These are not modifiable externally, thus are public accessible
public final int mCodec; // @see android.media.MediaRecorder.VideoEncoder
public final int mMinBitRate, mMaxBitRate; // min and max bit rate (bps)
public final int mMinFrameRate, mMaxFrameRate; // min and max frame rate (fps)
public final int mMinFrameWidth, mMaxFrameWidth; // min and max frame width (pixel)
public final int mMinFrameHeight, mMaxFrameHeight; // minn and max frame height (pixel)
// Private constructor called by JNI
private VideoEncoderCap(int codec,
int minBitRate, int maxBitRate,
int minFrameRate, int maxFrameRate,
int minFrameWidth, int maxFrameWidth,
int minFrameHeight, int maxFrameHeight) {
mCodec = codec;
mMinBitRate = minBitRate;
mMaxBitRate = maxBitRate;
mMinFrameRate = minFrameRate;
mMaxFrameRate = maxFrameRate;
mMinFrameWidth = minFrameWidth;
mMaxFrameWidth = maxFrameWidth;
mMinFrameHeight = minFrameHeight;
mMaxFrameHeight = maxFrameHeight;
}
};
/**
* The AudioEncoderCap class represents an audio encoder's
* parameter range in:
*
* <ul>
* <li>Bit rate: the compressed output bit rate in bits per second;
* <li>Sample rate: the sampling rate used for recording the audio in samples per second;
* <li>Number of channels: the number of channels the audio is recorded.
* </ul>
*
*/
static public class AudioEncoderCap {
// These are not modifiable externally, thus are public accessible
public final int mCodec; // @see android.media.MediaRecorder.AudioEncoder
public final int mMinChannels, mMaxChannels; // min and max number of channels
public final int mMinSampleRate, mMaxSampleRate; // min and max sample rate (hz)
public final int mMinBitRate, mMaxBitRate; // min and max bit rate (bps)
// Private constructor called by JNI
private AudioEncoderCap(int codec,
int minBitRate, int maxBitRate,
int minSampleRate, int maxSampleRate,
int minChannels, int maxChannels) {
mCodec = codec;
mMinBitRate = minBitRate;
mMaxBitRate = maxBitRate;
mMinSampleRate = minSampleRate;
mMaxSampleRate = maxSampleRate;
mMinChannels = minChannels;
mMaxChannels = maxChannels;
}
};
static {
System.loadLibrary("media_jni");
native_init();
}
/**
* Returns the array of supported output file formats.
* @see android.media.MediaRecorder.OutputFormat
*/
public static int[] getOutputFileFormats() {
int nFormats = native_get_num_file_formats();
if (nFormats == 0) return null;
int[] formats = new int[nFormats];
for (int i = 0; i < nFormats; ++i) {
formats[i] = native_get_file_format(i);
}
return formats;
}
/**
* Returns the capabilities of the supported video encoders.
* @see android.media.EncoderCapabilities.VideoEncoderCap
*/
public static List<VideoEncoderCap> getVideoEncoders() {
int nEncoders = native_get_num_video_encoders();
if (nEncoders == 0) return null;
List<VideoEncoderCap> encoderList = new ArrayList<VideoEncoderCap>();
for (int i = 0; i < nEncoders; ++i) {
encoderList.add(native_get_video_encoder_cap(i));
}
return encoderList;
}
/**
* Returns the capabilities of the supported audio encoders.
* @see android.media.EncoderCapabilities.AudioEncoderCap
*/
public static List<AudioEncoderCap> getAudioEncoders() {
int nEncoders = native_get_num_audio_encoders();
if (nEncoders == 0) return null;
List<AudioEncoderCap> encoderList = new ArrayList<AudioEncoderCap>();
for (int i = 0; i < nEncoders; ++i) {
encoderList.add(native_get_audio_encoder_cap(i));
}
return encoderList;
}
private EncoderCapabilities() {} // Don't call me
// Implemented by JNI
private static native final void native_init();
private static native final int native_get_num_file_formats();
private static native final int native_get_file_format(int index);
private static native final int native_get_num_video_encoders();
private static native final VideoEncoderCap native_get_video_encoder_cap(int index);
private static native final int native_get_num_audio_encoders();
private static native final AudioEncoderCap native_get_audio_encoder_cap(int index);
}
|
