MediaProfiles.h revision 3a9cefebd2c5d2157aefaed01c54f151dc64a5b3 
1/*
2 **
3 ** Copyright 2010, The Android Open Source Project.
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 **     http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18#ifndef ANDROID_MEDIAPROFILES_H
19#define ANDROID_MEDIAPROFILES_H
20
21#include <utils/threads.h>
22#include <media/mediarecorder.h>
23
24namespace android {
25
26enum camcorder_quality {
27    CAMCORDER_QUALITY_LIST_START = 0,
28    CAMCORDER_QUALITY_LOW  = 0,
29    CAMCORDER_QUALITY_HIGH = 1,
30    CAMCORDER_QUALITY_QCIF = 2,
31    CAMCORDER_QUALITY_CIF = 3,
32    CAMCORDER_QUALITY_480P = 4,
33    CAMCORDER_QUALITY_720P = 5,
34    CAMCORDER_QUALITY_1080P = 6,
35    CAMCORDER_QUALITY_QVGA = 7,
36    CAMCORDER_QUALITY_LIST_END = 7,
37
38    CAMCORDER_QUALITY_TIME_LAPSE_LIST_START = 1000,
39    CAMCORDER_QUALITY_TIME_LAPSE_LOW  = 1000,
40    CAMCORDER_QUALITY_TIME_LAPSE_HIGH = 1001,
41    CAMCORDER_QUALITY_TIME_LAPSE_QCIF = 1002,
42    CAMCORDER_QUALITY_TIME_LAPSE_CIF = 1003,
43    CAMCORDER_QUALITY_TIME_LAPSE_480P = 1004,
44    CAMCORDER_QUALITY_TIME_LAPSE_720P = 1005,
45    CAMCORDER_QUALITY_TIME_LAPSE_1080P = 1006,
46    CAMCORDER_QUALITY_TIME_LAPSE_QVGA = 1007,
47    CAMCORDER_QUALITY_TIME_LAPSE_LIST_END = 1007,
48};
49
50/**
51 * Set CIF as default maximum import and export resolution of video editor.
52 * The maximum import and export resolutions are platform specific,
53 * which should be defined in media_profiles.xml.
54 * Set default maximum prefetch YUV frames to 6, which means video editor can
55 * queue up to 6 YUV frames in the video encoder source.
56 * This value is used to limit the amount of memory used by video editor
57 * engine when the encoder consumes YUV frames at a lower speed
58 * than video editor engine produces.
59 */
60enum videoeditor_capability {
61    VIDEOEDITOR_DEFAULT_MAX_INPUT_FRAME_WIDTH = 352,
62    VIDEOEDITOR_DEFUALT_MAX_INPUT_FRAME_HEIGHT = 288,
63    VIDEOEDITOR_DEFAULT_MAX_OUTPUT_FRAME_WIDTH = 352,
64    VIDEOEDITOR_DEFUALT_MAX_OUTPUT_FRAME_HEIGHT = 288,
65    VIDEOEDITOR_DEFAULT_MAX_PREFETCH_YUV_FRAMES = 6
66};
67
68enum video_decoder {
69    VIDEO_DECODER_WMV,
70};
71
72enum audio_decoder {
73    AUDIO_DECODER_WMA,
74};
75
76
77class MediaProfiles
78{
79public:
80
81    /**
82     * Returns the singleton instance for subsequence queries.
83     * or NULL if error.
84     */
85    static MediaProfiles* getInstance();
86
87    /**
88     * Returns the value for the given param name for the given camera at
89     * the given quality level, or -1 if error.
90     *
91     * Supported param name are:
92     * duration - the recording duration.
93     * file.format - output file format. see mediarecorder.h for details
94     * vid.codec - video encoder. see mediarecorder.h for details.
95     * aud.codec - audio encoder. see mediarecorder.h for details.
96     * vid.width - video frame width
97     * vid.height - video frame height
98     * vid.fps - video frame rate
99     * vid.bps - video bit rate
100     * aud.bps - audio bit rate
101     * aud.hz - audio sample rate
102     * aud.ch - number of audio channels
103     */
104    int getCamcorderProfileParamByName(const char *name, int cameraId,
105                                       camcorder_quality quality) const;
106
107    /**
108     * Returns true if a profile for the given camera at the given quality exists,
109     * or false if not.
110     */
111    bool hasCamcorderProfile(int cameraId, camcorder_quality quality) const;
112
113    /**
114     * Returns the output file formats supported.
115     */
116    Vector<output_format> getOutputFileFormats() const;
117
118    /**
119     * Returns the video encoders supported.
120     */
121    Vector<video_encoder> getVideoEncoders() const;
122
123    /**
124     * Returns the value for the given param name for the given video encoder
125     * returned from getVideoEncoderByIndex or -1 if error.
126     *
127     * Supported param name are:
128     * enc.vid.width.min - min video frame width
129     * enc.vid.width.max - max video frame width
130     * enc.vid.height.min - min video frame height
131     * enc.vid.height.max - max video frame height
132     * enc.vid.bps.min - min bit rate in bits per second
133     * enc.vid.bps.max - max bit rate in bits per second
134     * enc.vid.fps.min - min frame rate in frames per second
135     * enc.vid.fps.max - max frame rate in frames per second
136     */
137    int getVideoEncoderParamByName(const char *name, video_encoder codec) const;
138
139    /**
140     * Returns the value for the given param name for the video editor cap
141     * param or -1 if error.
142     * Supported param name are:
143     * videoeditor.input.width.max - max input video frame width
144     * videoeditor.input.height.max - max input video frame height
145     * videoeditor.output.width.max - max output video frame width
146     * videoeditor.output.height.max - max output video frame height
147     * maxPrefetchYUVFrames - max prefetch YUV frames in video editor engine. This value is used
148     * to limit the memory consumption.
149     */
150    int getVideoEditorCapParamByName(const char *name) const;
151
152    /**
153     * Returns the value for the given param name for the video editor export codec format
154     * param or -1 if error.
155     * Supported param name are:
156     * videoeditor.export.profile - export video profile
157     * videoeditor.export.level - export video level
158     * Supported param codec are:
159     * 1 for h263
160     * 2 for h264
161     * 3 for mpeg4
162     */
163    int getVideoEditorExportParamByName(const char *name, int codec) const;
164
165    /**
166     * Returns the audio encoders supported.
167     */
168    Vector<audio_encoder> getAudioEncoders() const;
169
170    /**
171     * Returns the value for the given param name for the given audio encoder
172     * returned from getAudioEncoderByIndex or -1 if error.
173     *
174     * Supported param name are:
175     * enc.aud.ch.min - min number of channels
176     * enc.aud.ch.max - max number of channels
177     * enc.aud.bps.min - min bit rate in bits per second
178     * enc.aud.bps.max - max bit rate in bits per second
179     * enc.aud.hz.min - min sample rate in samples per second
180     * enc.aud.hz.max - max sample rate in samples per second
181     */
182    int getAudioEncoderParamByName(const char *name, audio_encoder codec) const;
183
184    /**
185      * Returns the video decoders supported.
186      */
187    Vector<video_decoder> getVideoDecoders() const;
188
189     /**
190      * Returns the audio decoders supported.
191      */
192    Vector<audio_decoder> getAudioDecoders() const;
193
194    /**
195     * Returns the number of image encoding quality levels supported.
196     */
197    Vector<int> getImageEncodingQualityLevels(int cameraId) const;
198
199    /**
200     * Returns the start time offset (in ms) for the given camera Id.
201     * If the given camera Id does not exist, -1 will be returned.
202     */
203    int getStartTimeOffsetMs(int cameraId) const;
204
205private:
206    enum {
207        // Camcorder profiles (high/low) and timelapse profiles (high/low)
208        kNumRequiredProfiles = 4,
209    };
210
211    MediaProfiles& operator=(const MediaProfiles&);  // Don't call me
212    MediaProfiles(const MediaProfiles&);             // Don't call me
213    MediaProfiles() { mVideoEditorCap = NULL; }        // Dummy default constructor
214    ~MediaProfiles();                                // Don't delete me
215
216    struct VideoCodec {
217        VideoCodec(video_encoder codec, int bitRate, int frameWidth, int frameHeight, int frameRate)
218            : mCodec(codec),
219              mBitRate(bitRate),
220              mFrameWidth(frameWidth),
221              mFrameHeight(frameHeight),
222              mFrameRate(frameRate) {}
223
224        VideoCodec(const VideoCodec& copy) {
225            mCodec = copy.mCodec;
226            mBitRate = copy.mBitRate;
227            mFrameWidth = copy.mFrameWidth;
228            mFrameHeight = copy.mFrameHeight;
229            mFrameRate = copy.mFrameRate;
230        }
231
232        ~VideoCodec() {}
233
234        video_encoder mCodec;
235        int mBitRate;
236        int mFrameWidth;
237        int mFrameHeight;
238        int mFrameRate;
239    };
240
241    struct AudioCodec {
242        AudioCodec(audio_encoder codec, int bitRate, int sampleRate, int channels)
243            : mCodec(codec),
244              mBitRate(bitRate),
245              mSampleRate(sampleRate),
246              mChannels(channels) {}
247
248        AudioCodec(const AudioCodec& copy) {
249            mCodec = copy.mCodec;
250            mBitRate = copy.mBitRate;
251            mSampleRate = copy.mSampleRate;
252            mChannels = copy.mChannels;
253        }
254
255        ~AudioCodec() {}
256
257        audio_encoder mCodec;
258        int mBitRate;
259        int mSampleRate;
260        int mChannels;
261    };
262
263    struct CamcorderProfile {
264        CamcorderProfile()
265            : mCameraId(0),
266              mFileFormat(OUTPUT_FORMAT_THREE_GPP),
267              mQuality(CAMCORDER_QUALITY_HIGH),
268              mDuration(0),
269              mVideoCodec(0),
270              mAudioCodec(0) {}
271
272        CamcorderProfile(const CamcorderProfile& copy) {
273            mCameraId = copy.mCameraId;
274            mFileFormat = copy.mFileFormat;
275            mQuality = copy.mQuality;
276            mDuration = copy.mDuration;
277            mVideoCodec = new VideoCodec(*copy.mVideoCodec);
278            mAudioCodec = new AudioCodec(*copy.mAudioCodec);
279        }
280
281        ~CamcorderProfile() {
282            delete mVideoCodec;
283            delete mAudioCodec;
284        }
285
286        int mCameraId;
287        output_format mFileFormat;
288        camcorder_quality mQuality;
289        int mDuration;
290        VideoCodec *mVideoCodec;
291        AudioCodec *mAudioCodec;
292    };
293
294    struct VideoEncoderCap {
295        // Ugly constructor
296        VideoEncoderCap(video_encoder codec,
297                        int minBitRate, int maxBitRate,
298                        int minFrameWidth, int maxFrameWidth,
299                        int minFrameHeight, int maxFrameHeight,
300                        int minFrameRate, int maxFrameRate)
301            : mCodec(codec),
302              mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
303              mMinFrameWidth(minFrameWidth), mMaxFrameWidth(maxFrameWidth),
304              mMinFrameHeight(minFrameHeight), mMaxFrameHeight(maxFrameHeight),
305              mMinFrameRate(minFrameRate), mMaxFrameRate(maxFrameRate) {}
306
307         ~VideoEncoderCap() {}
308
309        video_encoder mCodec;
310        int mMinBitRate, mMaxBitRate;
311        int mMinFrameWidth, mMaxFrameWidth;
312        int mMinFrameHeight, mMaxFrameHeight;
313        int mMinFrameRate, mMaxFrameRate;
314    };
315
316    struct AudioEncoderCap {
317        // Ugly constructor
318        AudioEncoderCap(audio_encoder codec,
319                        int minBitRate, int maxBitRate,
320                        int minSampleRate, int maxSampleRate,
321                        int minChannels, int maxChannels)
322            : mCodec(codec),
323              mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
324              mMinSampleRate(minSampleRate), mMaxSampleRate(maxSampleRate),
325              mMinChannels(minChannels), mMaxChannels(maxChannels) {}
326
327        ~AudioEncoderCap() {}
328
329        audio_encoder mCodec;
330        int mMinBitRate, mMaxBitRate;
331        int mMinSampleRate, mMaxSampleRate;
332        int mMinChannels, mMaxChannels;
333    };
334
335    struct VideoDecoderCap {
336        VideoDecoderCap(video_decoder codec): mCodec(codec) {}
337        ~VideoDecoderCap() {}
338
339        video_decoder mCodec;
340    };
341
342    struct AudioDecoderCap {
343        AudioDecoderCap(audio_decoder codec): mCodec(codec) {}
344        ~AudioDecoderCap() {}
345
346        audio_decoder mCodec;
347    };
348
349    struct NameToTagMap {
350        const char* name;
351        int tag;
352    };
353
354    struct ImageEncodingQualityLevels {
355        int mCameraId;
356        Vector<int> mLevels;
357    };
358    struct ExportVideoProfile {
359        ExportVideoProfile(int codec, int profile, int level)
360            :mCodec(codec),mProfile(profile),mLevel(level) {}
361        ~ExportVideoProfile() {}
362        int mCodec;
363        int mProfile;
364        int mLevel;
365    };
366    struct VideoEditorCap {
367        VideoEditorCap(int inFrameWidth, int inFrameHeight,
368            int outFrameWidth, int outFrameHeight, int frames)
369            : mMaxInputFrameWidth(inFrameWidth),
370              mMaxInputFrameHeight(inFrameHeight),
371              mMaxOutputFrameWidth(outFrameWidth),
372              mMaxOutputFrameHeight(outFrameHeight),
373              mMaxPrefetchYUVFrames(frames) {}
374
375        ~VideoEditorCap() {}
376
377        int mMaxInputFrameWidth;
378        int mMaxInputFrameHeight;
379        int mMaxOutputFrameWidth;
380        int mMaxOutputFrameHeight;
381        int mMaxPrefetchYUVFrames;
382    };
383
384    int getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const;
385    void initRequiredProfileRefs(const Vector<int>& cameraIds);
386    int getRequiredProfileRefIndex(int cameraId);
387
388    // Debug
389    static void logVideoCodec(const VideoCodec& codec);
390    static void logAudioCodec(const AudioCodec& codec);
391    static void logVideoEncoderCap(const VideoEncoderCap& cap);
392    static void logAudioEncoderCap(const AudioEncoderCap& cap);
393    static void logVideoDecoderCap(const VideoDecoderCap& cap);
394    static void logAudioDecoderCap(const AudioDecoderCap& cap);
395    static void logVideoEditorCap(const VideoEditorCap& cap);
396
397    // If the xml configuration file does exist, use the settings
398    // from the xml
399    static MediaProfiles* createInstanceFromXmlFile(const char *xml);
400    static output_format createEncoderOutputFileFormat(const char **atts);
401    static VideoCodec* createVideoCodec(const char **atts, MediaProfiles *profiles);
402    static AudioCodec* createAudioCodec(const char **atts, MediaProfiles *profiles);
403    static AudioDecoderCap* createAudioDecoderCap(const char **atts);
404    static VideoDecoderCap* createVideoDecoderCap(const char **atts);
405    static VideoEncoderCap* createVideoEncoderCap(const char **atts);
406    static AudioEncoderCap* createAudioEncoderCap(const char **atts);
407    static VideoEditorCap* createVideoEditorCap(
408                const char **atts, MediaProfiles *profiles);
409    static ExportVideoProfile* createExportVideoProfile(const char **atts);
410
411    static CamcorderProfile* createCamcorderProfile(
412                int cameraId, const char **atts, Vector<int>& cameraIds);
413
414    static int getCameraId(const char **atts);
415
416    void addStartTimeOffset(int cameraId, const char **atts);
417
418    ImageEncodingQualityLevels* findImageEncodingQualityLevels(int cameraId) const;
419    void addImageEncodingQualityLevel(int cameraId, const char** atts);
420
421    // Customized element tag handler for parsing the xml configuration file.
422    static void startElementHandler(void *userData, const char *name, const char **atts);
423
424    // If the xml configuration file does not exist, use hard-coded values
425    static MediaProfiles* createDefaultInstance();
426
427    static CamcorderProfile *createDefaultCamcorderQcifProfile(camcorder_quality quality);
428    static CamcorderProfile *createDefaultCamcorderCifProfile(camcorder_quality quality);
429    static void createDefaultCamcorderLowProfiles(
430            MediaProfiles::CamcorderProfile **lowProfile,
431            MediaProfiles::CamcorderProfile **lowSpecificProfile);
432    static void createDefaultCamcorderHighProfiles(
433            MediaProfiles::CamcorderProfile **highProfile,
434            MediaProfiles::CamcorderProfile **highSpecificProfile);
435
436    static CamcorderProfile *createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality);
437    static CamcorderProfile *createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality);
438    static void createDefaultCamcorderTimeLapseLowProfiles(
439            MediaProfiles::CamcorderProfile **lowTimeLapseProfile,
440            MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile);
441    static void createDefaultCamcorderTimeLapseHighProfiles(
442            MediaProfiles::CamcorderProfile **highTimeLapseProfile,
443            MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile);
444
445    static void createDefaultCamcorderProfiles(MediaProfiles *profiles);
446    static void createDefaultVideoEncoders(MediaProfiles *profiles);
447    static void createDefaultAudioEncoders(MediaProfiles *profiles);
448    static void createDefaultVideoDecoders(MediaProfiles *profiles);
449    static void createDefaultAudioDecoders(MediaProfiles *profiles);
450    static void createDefaultEncoderOutputFileFormats(MediaProfiles *profiles);
451    static void createDefaultImageEncodingQualityLevels(MediaProfiles *profiles);
452    static void createDefaultImageDecodingMaxMemory(MediaProfiles *profiles);
453    static void createDefaultVideoEditorCap(MediaProfiles *profiles);
454    static void createDefaultExportVideoProfiles(MediaProfiles *profiles);
455
456    static VideoEncoderCap* createDefaultH263VideoEncoderCap();
457    static VideoEncoderCap* createDefaultM4vVideoEncoderCap();
458    static AudioEncoderCap* createDefaultAmrNBEncoderCap();
459
460    static int findTagForName(const NameToTagMap *map, size_t nMappings, const char *name);
461
462    /**
463     * Check on existing profiles with the following criteria:
464     * 1. Low quality profile must have the lowest video
465     *    resolution product (width x height)
466     * 2. High quality profile must have the highest video
467     *    resolution product (width x height)
468     *
469     * and add required low/high quality camcorder/timelapse
470     * profiles if they are not found. This allows to remove
471     * duplicate profile definitions in the media_profiles.xml
472     * file.
473     */
474    void checkAndAddRequiredProfilesIfNecessary();
475
476
477    // Mappings from name (for instance, codec name) to enum value
478    static const NameToTagMap sVideoEncoderNameMap[];
479    static const NameToTagMap sAudioEncoderNameMap[];
480    static const NameToTagMap sFileFormatMap[];
481    static const NameToTagMap sVideoDecoderNameMap[];
482    static const NameToTagMap sAudioDecoderNameMap[];
483    static const NameToTagMap sCamcorderQualityNameMap[];
484
485    static bool sIsInitialized;
486    static MediaProfiles *sInstance;
487    static Mutex sLock;
488    int mCurrentCameraId;
489
490    Vector<CamcorderProfile*> mCamcorderProfiles;
491    Vector<AudioEncoderCap*>  mAudioEncoders;
492    Vector<VideoEncoderCap*>  mVideoEncoders;
493    Vector<AudioDecoderCap*>  mAudioDecoders;
494    Vector<VideoDecoderCap*>  mVideoDecoders;
495    Vector<output_format>     mEncoderOutputFileFormats;
496    Vector<ImageEncodingQualityLevels *>  mImageEncodingQualityLevels;
497    KeyedVector<int, int> mStartTimeOffsets;
498
499    typedef struct {
500        bool mHasRefProfile;      // Refers to an existing profile
501        int  mRefProfileIndex;    // Reference profile index
502        int  mResolutionProduct;  // width x height
503    } RequiredProfileRefInfo;     // Required low and high profiles
504
505    typedef struct {
506        RequiredProfileRefInfo mRefs[kNumRequiredProfiles];
507        int mCameraId;
508    } RequiredProfiles;
509
510    RequiredProfiles *mRequiredProfileRefs;
511    Vector<int>              mCameraIds;
512    VideoEditorCap* mVideoEditorCap;
513    Vector<ExportVideoProfile*> mVideoEditorExportProfiles;
514};
515
516}; // namespace android
517
518#endif // ANDROID_MEDIAPROFILES_H
519
520