MediaProfiles.cpp revision 0f056290cb16763453f18bbef80cde673041dbbc 
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
19//#define LOG_NDEBUG 0
20#define LOG_TAG "MediaProfiles"
21
22#include <stdlib.h>
23#include <utils/Log.h>
24#include <utils/Vector.h>
25#include <cutils/properties.h>
26#include <expat.h>
27#include <media/MediaProfiles.h>
28#include <media/stagefright/MediaDebug.h>
29
30namespace android {
31
32Mutex MediaProfiles::sLock;
33bool MediaProfiles::sIsInitialized = false;
34MediaProfiles *MediaProfiles::sInstance = NULL;
35
36const MediaProfiles::NameToTagMap MediaProfiles::sVideoEncoderNameMap[] = {
37    {"h263", VIDEO_ENCODER_H263},
38    {"h264", VIDEO_ENCODER_H264},
39    {"m4v",  VIDEO_ENCODER_MPEG_4_SP}
40};
41
42const MediaProfiles::NameToTagMap MediaProfiles::sAudioEncoderNameMap[] = {
43    {"amrnb", AUDIO_ENCODER_AMR_NB},
44    {"amrwb", AUDIO_ENCODER_AMR_WB},
45    {"aac",   AUDIO_ENCODER_AAC},
46};
47
48const MediaProfiles::NameToTagMap MediaProfiles::sFileFormatMap[] = {
49    {"3gp", OUTPUT_FORMAT_THREE_GPP},
50    {"mp4", OUTPUT_FORMAT_MPEG_4}
51};
52
53const MediaProfiles::NameToTagMap MediaProfiles::sVideoDecoderNameMap[] = {
54    {"wmv", VIDEO_DECODER_WMV}
55};
56
57const MediaProfiles::NameToTagMap MediaProfiles::sAudioDecoderNameMap[] = {
58    {"wma", AUDIO_DECODER_WMA}
59};
60
61const MediaProfiles::NameToTagMap MediaProfiles::sCamcorderQualityNameMap[] = {
62    {"low", CAMCORDER_QUALITY_LOW},
63    {"high", CAMCORDER_QUALITY_HIGH},
64    {"qcif", CAMCORDER_QUALITY_QCIF},
65    {"cif", CAMCORDER_QUALITY_CIF},
66    {"480p", CAMCORDER_QUALITY_480P},
67    {"720p", CAMCORDER_QUALITY_720P},
68    {"1080p", CAMCORDER_QUALITY_1080P},
69
70    {"timelapselow",  CAMCORDER_QUALITY_TIME_LAPSE_LOW},
71    {"timelapsehigh", CAMCORDER_QUALITY_TIME_LAPSE_HIGH},
72    {"timelapseqcif", CAMCORDER_QUALITY_TIME_LAPSE_QCIF},
73    {"timelapsecif", CAMCORDER_QUALITY_TIME_LAPSE_CIF},
74    {"timelapse480p", CAMCORDER_QUALITY_TIME_LAPSE_480P},
75    {"timelapse720p", CAMCORDER_QUALITY_TIME_LAPSE_720P},
76    {"timelapse1080p", CAMCORDER_QUALITY_TIME_LAPSE_1080P}
77};
78
79/*static*/ void
80MediaProfiles::logVideoCodec(const MediaProfiles::VideoCodec& codec)
81{
82    LOGV("video codec:");
83    LOGV("codec = %d", codec.mCodec);
84    LOGV("bit rate: %d", codec.mBitRate);
85    LOGV("frame width: %d", codec.mFrameWidth);
86    LOGV("frame height: %d", codec.mFrameHeight);
87    LOGV("frame rate: %d", codec.mFrameRate);
88}
89
90/*static*/ void
91MediaProfiles::logAudioCodec(const MediaProfiles::AudioCodec& codec)
92{
93    LOGV("audio codec:");
94    LOGV("codec = %d", codec.mCodec);
95    LOGV("bit rate: %d", codec.mBitRate);
96    LOGV("sample rate: %d", codec.mSampleRate);
97    LOGV("number of channels: %d", codec.mChannels);
98}
99
100/*static*/ void
101MediaProfiles::logVideoEncoderCap(const MediaProfiles::VideoEncoderCap& cap)
102{
103    LOGV("video encoder cap:");
104    LOGV("codec = %d", cap.mCodec);
105    LOGV("bit rate: min = %d and max = %d", cap.mMinBitRate, cap.mMaxBitRate);
106    LOGV("frame width: min = %d and max = %d", cap.mMinFrameWidth, cap.mMaxFrameWidth);
107    LOGV("frame height: min = %d and max = %d", cap.mMinFrameHeight, cap.mMaxFrameHeight);
108    LOGV("frame rate: min = %d and max = %d", cap.mMinFrameRate, cap.mMaxFrameRate);
109}
110
111/*static*/ void
112MediaProfiles::logAudioEncoderCap(const MediaProfiles::AudioEncoderCap& cap)
113{
114    LOGV("audio encoder cap:");
115    LOGV("codec = %d", cap.mCodec);
116    LOGV("bit rate: min = %d and max = %d", cap.mMinBitRate, cap.mMaxBitRate);
117    LOGV("sample rate: min = %d and max = %d", cap.mMinSampleRate, cap.mMaxSampleRate);
118    LOGV("number of channels: min = %d and max = %d", cap.mMinChannels, cap.mMaxChannels);
119}
120
121/*static*/ void
122MediaProfiles::logVideoDecoderCap(const MediaProfiles::VideoDecoderCap& cap)
123{
124    LOGV("video decoder cap:");
125    LOGV("codec = %d", cap.mCodec);
126}
127
128/*static*/ void
129MediaProfiles::logAudioDecoderCap(const MediaProfiles::AudioDecoderCap& cap)
130{
131    LOGV("audio codec cap:");
132    LOGV("codec = %d", cap.mCodec);
133}
134
135/*static*/ int
136MediaProfiles::findTagForName(const MediaProfiles::NameToTagMap *map, size_t nMappings, const char *name)
137{
138    int tag = -1;
139    for (size_t i = 0; i < nMappings; ++i) {
140        if (!strcmp(map[i].name, name)) {
141            tag = map[i].tag;
142            break;
143        }
144    }
145    return tag;
146}
147
148/*static*/ MediaProfiles::VideoCodec*
149MediaProfiles::createVideoCodec(const char **atts, MediaProfiles *profiles)
150{
151    CHECK(!strcmp("codec",     atts[0]) &&
152          !strcmp("bitRate",   atts[2]) &&
153          !strcmp("width",     atts[4]) &&
154          !strcmp("height",    atts[6]) &&
155          !strcmp("frameRate", atts[8]));
156
157    const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]);
158    const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]);
159    CHECK(codec != -1);
160
161    MediaProfiles::VideoCodec *videoCodec =
162        new MediaProfiles::VideoCodec(static_cast<video_encoder>(codec),
163            atoi(atts[3]), atoi(atts[5]), atoi(atts[7]), atoi(atts[9]));
164    logVideoCodec(*videoCodec);
165
166    size_t nCamcorderProfiles;
167    CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1);
168    profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mVideoCodec = videoCodec;
169    return videoCodec;
170}
171
172/*static*/ MediaProfiles::AudioCodec*
173MediaProfiles::createAudioCodec(const char **atts, MediaProfiles *profiles)
174{
175    CHECK(!strcmp("codec",      atts[0]) &&
176          !strcmp("bitRate",    atts[2]) &&
177          !strcmp("sampleRate", atts[4]) &&
178          !strcmp("channels",   atts[6]));
179    const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]);
180    const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]);
181    CHECK(codec != -1);
182
183    MediaProfiles::AudioCodec *audioCodec =
184        new MediaProfiles::AudioCodec(static_cast<audio_encoder>(codec),
185            atoi(atts[3]), atoi(atts[5]), atoi(atts[7]));
186    logAudioCodec(*audioCodec);
187
188    size_t nCamcorderProfiles;
189    CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1);
190    profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mAudioCodec = audioCodec;
191    return audioCodec;
192}
193/*static*/ MediaProfiles::AudioDecoderCap*
194MediaProfiles::createAudioDecoderCap(const char **atts)
195{
196    CHECK(!strcmp("name",    atts[0]) &&
197          !strcmp("enabled", atts[2]));
198
199    const size_t nMappings = sizeof(sAudioDecoderNameMap)/sizeof(sAudioDecoderNameMap[0]);
200    const int codec = findTagForName(sAudioDecoderNameMap, nMappings, atts[1]);
201    CHECK(codec != -1);
202
203    MediaProfiles::AudioDecoderCap *cap =
204        new MediaProfiles::AudioDecoderCap(static_cast<audio_decoder>(codec));
205    logAudioDecoderCap(*cap);
206    return cap;
207}
208
209/*static*/ MediaProfiles::VideoDecoderCap*
210MediaProfiles::createVideoDecoderCap(const char **atts)
211{
212    CHECK(!strcmp("name",    atts[0]) &&
213          !strcmp("enabled", atts[2]));
214
215    const size_t nMappings = sizeof(sVideoDecoderNameMap)/sizeof(sVideoDecoderNameMap[0]);
216    const int codec = findTagForName(sVideoDecoderNameMap, nMappings, atts[1]);
217    CHECK(codec != -1);
218
219    MediaProfiles::VideoDecoderCap *cap =
220        new MediaProfiles::VideoDecoderCap(static_cast<video_decoder>(codec));
221    logVideoDecoderCap(*cap);
222    return cap;
223}
224
225/*static*/ MediaProfiles::VideoEncoderCap*
226MediaProfiles::createVideoEncoderCap(const char **atts)
227{
228    CHECK(!strcmp("name",           atts[0])  &&
229          !strcmp("enabled",        atts[2])  &&
230          !strcmp("minBitRate",     atts[4])  &&
231          !strcmp("maxBitRate",     atts[6])  &&
232          !strcmp("minFrameWidth",  atts[8])  &&
233          !strcmp("maxFrameWidth",  atts[10]) &&
234          !strcmp("minFrameHeight", atts[12]) &&
235          !strcmp("maxFrameHeight", atts[14]) &&
236          !strcmp("minFrameRate",   atts[16]) &&
237          !strcmp("maxFrameRate",   atts[18]));
238
239    const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]);
240    const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]);
241    CHECK(codec != -1);
242
243    MediaProfiles::VideoEncoderCap *cap =
244        new MediaProfiles::VideoEncoderCap(static_cast<video_encoder>(codec),
245            atoi(atts[5]), atoi(atts[7]), atoi(atts[9]), atoi(atts[11]), atoi(atts[13]),
246            atoi(atts[15]), atoi(atts[17]), atoi(atts[19]));
247    logVideoEncoderCap(*cap);
248    return cap;
249}
250
251/*static*/ MediaProfiles::AudioEncoderCap*
252MediaProfiles::createAudioEncoderCap(const char **atts)
253{
254    CHECK(!strcmp("name",          atts[0])  &&
255          !strcmp("enabled",       atts[2])  &&
256          !strcmp("minBitRate",    atts[4])  &&
257          !strcmp("maxBitRate",    atts[6])  &&
258          !strcmp("minSampleRate", atts[8])  &&
259          !strcmp("maxSampleRate", atts[10]) &&
260          !strcmp("minChannels",   atts[12]) &&
261          !strcmp("maxChannels",   atts[14]));
262
263    const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]);
264    const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]);
265    CHECK(codec != -1);
266
267    MediaProfiles::AudioEncoderCap *cap =
268        new MediaProfiles::AudioEncoderCap(static_cast<audio_encoder>(codec), atoi(atts[5]), atoi(atts[7]),
269            atoi(atts[9]), atoi(atts[11]), atoi(atts[13]),
270            atoi(atts[15]));
271    logAudioEncoderCap(*cap);
272    return cap;
273}
274
275/*static*/ output_format
276MediaProfiles::createEncoderOutputFileFormat(const char **atts)
277{
278    CHECK(!strcmp("name", atts[0]));
279
280    const size_t nMappings =sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]);
281    const int format = findTagForName(sFileFormatMap, nMappings, atts[1]);
282    CHECK(format != -1);
283
284    return static_cast<output_format>(format);
285}
286
287static bool isCameraIdFound(int cameraId, const Vector<int>& cameraIds) {
288    for (int i = 0, n = cameraIds.size(); i < n; ++i) {
289        if (cameraId == cameraIds[i]) {
290            return true;
291        }
292    }
293    return false;
294}
295
296/*static*/ MediaProfiles::CamcorderProfile*
297MediaProfiles::createCamcorderProfile(int cameraId, const char **atts, Vector<int>& cameraIds)
298{
299    CHECK(!strcmp("quality",    atts[0]) &&
300          !strcmp("fileFormat", atts[2]) &&
301          !strcmp("duration",   atts[4]));
302
303    const size_t nProfileMappings = sizeof(sCamcorderQualityNameMap)/sizeof(sCamcorderQualityNameMap[0]);
304    const int quality = findTagForName(sCamcorderQualityNameMap, nProfileMappings, atts[1]);
305    CHECK(quality != -1);
306
307    const size_t nFormatMappings = sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]);
308    const int fileFormat = findTagForName(sFileFormatMap, nFormatMappings, atts[3]);
309    CHECK(fileFormat != -1);
310
311    MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
312    profile->mCameraId = cameraId;
313    if (!isCameraIdFound(cameraId, cameraIds)) {
314        cameraIds.add(cameraId);
315    }
316    profile->mFileFormat = static_cast<output_format>(fileFormat);
317    profile->mQuality = static_cast<camcorder_quality>(quality);
318    profile->mDuration = atoi(atts[5]);
319    return profile;
320}
321
322MediaProfiles::ImageEncodingQualityLevels*
323MediaProfiles::findImageEncodingQualityLevels(int cameraId) const
324{
325    int n = mImageEncodingQualityLevels.size();
326    for (int i = 0; i < n; i++) {
327        ImageEncodingQualityLevels *levels = mImageEncodingQualityLevels[i];
328        if (levels->mCameraId == cameraId) {
329            return levels;
330        }
331    }
332    return NULL;
333}
334
335void MediaProfiles::addImageEncodingQualityLevel(int cameraId, const char** atts)
336{
337    CHECK(!strcmp("quality", atts[0]));
338    int quality = atoi(atts[1]);
339    LOGV("%s: cameraId=%d, quality=%d\n", __func__, cameraId, quality);
340    ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId);
341
342    if (levels == NULL) {
343        levels = new ImageEncodingQualityLevels();
344        levels->mCameraId = cameraId;
345        mImageEncodingQualityLevels.add(levels);
346    }
347
348    levels->mLevels.add(quality);
349}
350
351/*static*/ int
352MediaProfiles::getCameraId(const char** atts)
353{
354    if (!atts[0]) return 0;  // default cameraId = 0
355    CHECK(!strcmp("cameraId", atts[0]));
356    return atoi(atts[1]);
357}
358
359void MediaProfiles::addStartTimeOffset(int cameraId, const char** atts)
360{
361    int offsetTimeMs = 700;
362    if (atts[2]) {
363        CHECK(!strcmp("startOffsetMs", atts[2]));
364        offsetTimeMs = atoi(atts[3]);
365    }
366
367    LOGV("%s: cameraId=%d, offset=%d ms", __func__, cameraId, offsetTimeMs);
368    mStartTimeOffsets.replaceValueFor(cameraId, offsetTimeMs);
369}
370
371/*static*/ void
372MediaProfiles::startElementHandler(void *userData, const char *name, const char **atts)
373{
374    MediaProfiles *profiles = (MediaProfiles *) userData;
375    if (strcmp("Video", name) == 0) {
376        createVideoCodec(atts, profiles);
377    } else if (strcmp("Audio", name) == 0) {
378        createAudioCodec(atts, profiles);
379    } else if (strcmp("VideoEncoderCap", name) == 0 &&
380               strcmp("true", atts[3]) == 0) {
381        profiles->mVideoEncoders.add(createVideoEncoderCap(atts));
382    } else if (strcmp("AudioEncoderCap", name) == 0 &&
383               strcmp("true", atts[3]) == 0) {
384        profiles->mAudioEncoders.add(createAudioEncoderCap(atts));
385    } else if (strcmp("VideoDecoderCap", name) == 0 &&
386               strcmp("true", atts[3]) == 0) {
387        profiles->mVideoDecoders.add(createVideoDecoderCap(atts));
388    } else if (strcmp("AudioDecoderCap", name) == 0 &&
389               strcmp("true", atts[3]) == 0) {
390        profiles->mAudioDecoders.add(createAudioDecoderCap(atts));
391    } else if (strcmp("EncoderOutputFileFormat", name) == 0) {
392        profiles->mEncoderOutputFileFormats.add(createEncoderOutputFileFormat(atts));
393    } else if (strcmp("CamcorderProfiles", name) == 0) {
394        profiles->mCurrentCameraId = getCameraId(atts);
395        profiles->addStartTimeOffset(profiles->mCurrentCameraId, atts);
396    } else if (strcmp("EncoderProfile", name) == 0) {
397        profiles->mCamcorderProfiles.add(
398            createCamcorderProfile(profiles->mCurrentCameraId, atts, profiles->mCameraIds));
399    } else if (strcmp("ImageEncoding", name) == 0) {
400        profiles->addImageEncodingQualityLevel(profiles->mCurrentCameraId, atts);
401    }
402}
403
404static bool isCamcorderProfile(camcorder_quality quality) {
405    return quality >= CAMCORDER_QUALITY_LIST_START &&
406           quality <= CAMCORDER_QUALITY_LIST_END;
407}
408
409static bool isTimelapseProfile(camcorder_quality quality) {
410    return quality >= CAMCORDER_QUALITY_TIME_LAPSE_LIST_START &&
411           quality <= CAMCORDER_QUALITY_TIME_LAPSE_LIST_END;
412}
413
414void MediaProfiles::initRequiredProfileRefs(const Vector<int>& cameraIds) {
415    LOGV("Number of camera ids: %d", cameraIds.size());
416    CHECK(cameraIds.size() > 0);
417    mRequiredProfileRefs = new RequiredProfiles[cameraIds.size()];
418    for (size_t i = 0, n = cameraIds.size(); i < n; ++i) {
419        mRequiredProfileRefs[i].mCameraId = cameraIds[i];
420        for (size_t j = 0; j < kNumRequiredProfiles; ++j) {
421            mRequiredProfileRefs[i].mRefs[j].mHasRefProfile = false;
422            mRequiredProfileRefs[i].mRefs[j].mRefProfileIndex = -1;
423            if ((j & 1) == 0) {  // low resolution
424                mRequiredProfileRefs[i].mRefs[j].mResolutionProduct = 0x7FFFFFFF;
425            } else {             // high resolution
426                mRequiredProfileRefs[i].mRefs[j].mResolutionProduct = 0;
427            }
428        }
429    }
430}
431
432int MediaProfiles::getRequiredProfileRefIndex(int cameraId) {
433    for (size_t i = 0, n = mCameraIds.size(); i < n; ++i) {
434        if (mCameraIds[i] == cameraId) {
435            return i;
436        }
437    }
438    return -1;
439}
440
441void MediaProfiles::checkAndAddRequiredProfilesIfNecessary() {
442    if (sIsInitialized) {
443        return;
444    }
445
446    initRequiredProfileRefs(mCameraIds);
447
448    for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) {
449        int product = mCamcorderProfiles[i]->mVideoCodec->mFrameWidth *
450                      mCamcorderProfiles[i]->mVideoCodec->mFrameHeight;
451
452        camcorder_quality quality = mCamcorderProfiles[i]->mQuality;
453        int cameraId = mCamcorderProfiles[i]->mCameraId;
454        int index = -1;
455        int refIndex = getRequiredProfileRefIndex(cameraId);
456        CHECK(refIndex != -1);
457        RequiredProfileRefInfo *info;
458        camcorder_quality refQuality;
459        VideoCodec *codec = NULL;
460
461        // Check high and low from either camcorder profile or timelapse profile
462        // but not both. Default, check camcorder profile
463        size_t j = 0;
464        size_t n = 2;
465        if (isTimelapseProfile(quality)) {
466            // Check timelapse profile instead.
467            j = 2;
468            n = kNumRequiredProfiles;
469        } else {
470            // Must be camcorder profile.
471            CHECK(isCamcorderProfile(quality));
472        }
473        for (; j < n; ++j) {
474            info = &(mRequiredProfileRefs[refIndex].mRefs[j]);
475            if ((j % 2 == 0 && product > info->mResolutionProduct) ||  // low
476                (j % 2 != 0 && product < info->mResolutionProduct)) {  // high
477                continue;
478            }
479            switch (j) {
480                case 0:
481                   refQuality = CAMCORDER_QUALITY_LOW;
482                   break;
483                case 1:
484                   refQuality = CAMCORDER_QUALITY_HIGH;
485                   break;
486                case 2:
487                   refQuality = CAMCORDER_QUALITY_TIME_LAPSE_LOW;
488                   break;
489                case 3:
490                   refQuality = CAMCORDER_QUALITY_TIME_LAPSE_HIGH;
491                   break;
492                default:
493                    CHECK(!"Should never reach here");
494            }
495
496            if (!info->mHasRefProfile) {
497                index = getCamcorderProfileIndex(cameraId, refQuality);
498            }
499            if (index == -1) {
500                // New high or low quality profile is found.
501                // Update its reference.
502                info->mHasRefProfile = true;
503                info->mRefProfileIndex = i;
504                info->mResolutionProduct = product;
505            }
506        }
507    }
508
509    for (size_t cameraId = 0; cameraId < mCameraIds.size(); ++cameraId) {
510        for (size_t j = 0; j < kNumRequiredProfiles; ++j) {
511            int refIndex = getRequiredProfileRefIndex(cameraId);
512            CHECK(refIndex != -1);
513            RequiredProfileRefInfo *info =
514                    &mRequiredProfileRefs[refIndex].mRefs[j];
515
516            if (info->mHasRefProfile) {
517
518                CamcorderProfile *profile =
519                    new CamcorderProfile(
520                            *mCamcorderProfiles[info->mRefProfileIndex]);
521
522                // Overwrite the quality
523                switch (j % kNumRequiredProfiles) {
524                    case 0:
525                        profile->mQuality = CAMCORDER_QUALITY_LOW;
526                        break;
527                    case 1:
528                        profile->mQuality = CAMCORDER_QUALITY_HIGH;
529                        break;
530                    case 2:
531                        profile->mQuality = CAMCORDER_QUALITY_TIME_LAPSE_LOW;
532                        break;
533                    case 3:
534                        profile->mQuality = CAMCORDER_QUALITY_TIME_LAPSE_HIGH;
535                        break;
536                    default:
537                        CHECK(!"Should never come here");
538                }
539
540                int index = getCamcorderProfileIndex(cameraId, profile->mQuality);
541                if (index != -1) {
542                    LOGV("Profile quality %d for camera %d already exists",
543                        profile->mQuality, cameraId);
544                    CHECK(index == refIndex);
545                    continue;
546                }
547
548                // Insert the new profile
549                LOGV("Add a profile: quality %d=>%d for camera %d",
550                        mCamcorderProfiles[info->mRefProfileIndex]->mQuality,
551                        profile->mQuality, cameraId);
552
553                mCamcorderProfiles.add(profile);
554            }
555        }
556    }
557}
558
559/*static*/ MediaProfiles*
560MediaProfiles::getInstance()
561{
562    LOGV("getInstance");
563    Mutex::Autolock lock(sLock);
564    if (!sIsInitialized) {
565        char value[PROPERTY_VALUE_MAX];
566        if (property_get("media.settings.xml", value, NULL) <= 0) {
567            const char *defaultXmlFile = "/etc/media_profiles.xml";
568            FILE *fp = fopen(defaultXmlFile, "r");
569            if (fp == NULL) {
570                LOGW("could not find media config xml file");
571                sInstance = createDefaultInstance();
572            } else {
573                fclose(fp);  // close the file first.
574                sInstance = createInstanceFromXmlFile(defaultXmlFile);
575            }
576        } else {
577            sInstance = createInstanceFromXmlFile(value);
578        }
579        CHECK(sInstance != NULL);
580        sInstance->checkAndAddRequiredProfilesIfNecessary();
581        sIsInitialized = true;
582    }
583
584    return sInstance;
585}
586
587/*static*/ MediaProfiles::VideoEncoderCap*
588MediaProfiles::createDefaultH263VideoEncoderCap()
589{
590    return new MediaProfiles::VideoEncoderCap(
591        VIDEO_ENCODER_H263, 192000, 420000, 176, 352, 144, 288, 1, 20);
592}
593
594/*static*/ MediaProfiles::VideoEncoderCap*
595MediaProfiles::createDefaultM4vVideoEncoderCap()
596{
597    return new MediaProfiles::VideoEncoderCap(
598        VIDEO_ENCODER_MPEG_4_SP, 192000, 420000, 176, 352, 144, 288, 1, 20);
599}
600
601
602/*static*/ void
603MediaProfiles::createDefaultVideoEncoders(MediaProfiles *profiles)
604{
605    profiles->mVideoEncoders.add(createDefaultH263VideoEncoderCap());
606    profiles->mVideoEncoders.add(createDefaultM4vVideoEncoderCap());
607}
608
609/*static*/ MediaProfiles::CamcorderProfile*
610MediaProfiles::createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality)
611{
612    MediaProfiles::VideoCodec *videoCodec =
613        new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 1000000, 176, 144, 20);
614
615    AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
616    CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
617    profile->mCameraId = 0;
618    profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
619    profile->mQuality = quality;
620    profile->mDuration = 60;
621    profile->mVideoCodec = videoCodec;
622    profile->mAudioCodec = audioCodec;
623    return profile;
624}
625
626/*static*/ MediaProfiles::CamcorderProfile*
627MediaProfiles::createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality)
628{
629    MediaProfiles::VideoCodec *videoCodec =
630        new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 20000000, 720, 480, 20);
631
632    AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
633    CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
634    profile->mCameraId = 0;
635    profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
636    profile->mQuality = quality;
637    profile->mDuration = 60;
638    profile->mVideoCodec = videoCodec;
639    profile->mAudioCodec = audioCodec;
640    return profile;
641}
642
643/*static*/ void
644MediaProfiles::createDefaultCamcorderTimeLapseLowProfiles(
645        MediaProfiles::CamcorderProfile **lowTimeLapseProfile,
646        MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile) {
647    *lowTimeLapseProfile = createDefaultCamcorderTimeLapseQcifProfile(CAMCORDER_QUALITY_TIME_LAPSE_LOW);
648    *lowSpecificTimeLapseProfile = createDefaultCamcorderTimeLapseQcifProfile(CAMCORDER_QUALITY_TIME_LAPSE_QCIF);
649}
650
651/*static*/ void
652MediaProfiles::createDefaultCamcorderTimeLapseHighProfiles(
653        MediaProfiles::CamcorderProfile **highTimeLapseProfile,
654        MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile) {
655    *highTimeLapseProfile = createDefaultCamcorderTimeLapse480pProfile(CAMCORDER_QUALITY_TIME_LAPSE_HIGH);
656    *highSpecificTimeLapseProfile = createDefaultCamcorderTimeLapse480pProfile(CAMCORDER_QUALITY_TIME_LAPSE_480P);
657}
658
659/*static*/ MediaProfiles::CamcorderProfile*
660MediaProfiles::createDefaultCamcorderQcifProfile(camcorder_quality quality)
661{
662    MediaProfiles::VideoCodec *videoCodec =
663        new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 192000, 176, 144, 20);
664
665    MediaProfiles::AudioCodec *audioCodec =
666        new MediaProfiles::AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
667
668    MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
669    profile->mCameraId = 0;
670    profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
671    profile->mQuality = quality;
672    profile->mDuration = 30;
673    profile->mVideoCodec = videoCodec;
674    profile->mAudioCodec = audioCodec;
675    return profile;
676}
677
678/*static*/ MediaProfiles::CamcorderProfile*
679MediaProfiles::createDefaultCamcorderCifProfile(camcorder_quality quality)
680{
681    MediaProfiles::VideoCodec *videoCodec =
682        new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 360000, 352, 288, 20);
683
684    AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
685    CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
686    profile->mCameraId = 0;
687    profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
688    profile->mQuality = quality;
689    profile->mDuration = 60;
690    profile->mVideoCodec = videoCodec;
691    profile->mAudioCodec = audioCodec;
692    return profile;
693}
694
695/*static*/ void
696MediaProfiles::createDefaultCamcorderLowProfiles(
697        MediaProfiles::CamcorderProfile **lowProfile,
698        MediaProfiles::CamcorderProfile **lowSpecificProfile) {
699    *lowProfile = createDefaultCamcorderQcifProfile(CAMCORDER_QUALITY_LOW);
700    *lowSpecificProfile = createDefaultCamcorderQcifProfile(CAMCORDER_QUALITY_QCIF);
701}
702
703/*static*/ void
704MediaProfiles::createDefaultCamcorderHighProfiles(
705        MediaProfiles::CamcorderProfile **highProfile,
706        MediaProfiles::CamcorderProfile **highSpecificProfile) {
707    *highProfile = createDefaultCamcorderCifProfile(CAMCORDER_QUALITY_HIGH);
708    *highSpecificProfile = createDefaultCamcorderCifProfile(CAMCORDER_QUALITY_CIF);
709}
710
711/*static*/ void
712MediaProfiles::createDefaultCamcorderProfiles(MediaProfiles *profiles)
713{
714    // low camcorder profiles.
715    MediaProfiles::CamcorderProfile *lowProfile, *lowSpecificProfile;
716    createDefaultCamcorderLowProfiles(&lowProfile, &lowSpecificProfile);
717    profiles->mCamcorderProfiles.add(lowProfile);
718    profiles->mCamcorderProfiles.add(lowSpecificProfile);
719
720    // high camcorder profiles.
721    MediaProfiles::CamcorderProfile* highProfile, *highSpecificProfile;
722    createDefaultCamcorderHighProfiles(&highProfile, &highSpecificProfile);
723    profiles->mCamcorderProfiles.add(highProfile);
724    profiles->mCamcorderProfiles.add(highSpecificProfile);
725
726    // low camcorder time lapse profiles.
727    MediaProfiles::CamcorderProfile *lowTimeLapseProfile, *lowSpecificTimeLapseProfile;
728    createDefaultCamcorderTimeLapseLowProfiles(&lowTimeLapseProfile, &lowSpecificTimeLapseProfile);
729    profiles->mCamcorderProfiles.add(lowTimeLapseProfile);
730    profiles->mCamcorderProfiles.add(lowSpecificTimeLapseProfile);
731
732    // high camcorder time lapse profiles.
733    MediaProfiles::CamcorderProfile *highTimeLapseProfile, *highSpecificTimeLapseProfile;
734    createDefaultCamcorderTimeLapseHighProfiles(&highTimeLapseProfile, &highSpecificTimeLapseProfile);
735    profiles->mCamcorderProfiles.add(highTimeLapseProfile);
736    profiles->mCamcorderProfiles.add(highSpecificTimeLapseProfile);
737
738    // For emulator and other legacy devices which does not have a
739    // media_profiles.xml file, We assume that the default camera id
740    // is 0 and that is the only camera available.
741    profiles->mCameraIds.push(0);
742}
743
744/*static*/ void
745MediaProfiles::createDefaultAudioEncoders(MediaProfiles *profiles)
746{
747    profiles->mAudioEncoders.add(createDefaultAmrNBEncoderCap());
748}
749
750/*static*/ void
751MediaProfiles::createDefaultVideoDecoders(MediaProfiles *profiles)
752{
753    MediaProfiles::VideoDecoderCap *cap =
754        new MediaProfiles::VideoDecoderCap(VIDEO_DECODER_WMV);
755
756    profiles->mVideoDecoders.add(cap);
757}
758
759/*static*/ void
760MediaProfiles::createDefaultAudioDecoders(MediaProfiles *profiles)
761{
762    MediaProfiles::AudioDecoderCap *cap =
763        new MediaProfiles::AudioDecoderCap(AUDIO_DECODER_WMA);
764
765    profiles->mAudioDecoders.add(cap);
766}
767
768/*static*/ void
769MediaProfiles::createDefaultEncoderOutputFileFormats(MediaProfiles *profiles)
770{
771    profiles->mEncoderOutputFileFormats.add(OUTPUT_FORMAT_THREE_GPP);
772    profiles->mEncoderOutputFileFormats.add(OUTPUT_FORMAT_MPEG_4);
773}
774
775/*static*/ MediaProfiles::AudioEncoderCap*
776MediaProfiles::createDefaultAmrNBEncoderCap()
777{
778    return new MediaProfiles::AudioEncoderCap(
779        AUDIO_ENCODER_AMR_NB, 5525, 12200, 8000, 8000, 1, 1);
780}
781
782/*static*/ void
783MediaProfiles::createDefaultImageEncodingQualityLevels(MediaProfiles *profiles)
784{
785    ImageEncodingQualityLevels *levels = new ImageEncodingQualityLevels();
786    levels->mCameraId = 0;
787    levels->mLevels.add(70);
788    levels->mLevels.add(80);
789    levels->mLevels.add(90);
790    profiles->mImageEncodingQualityLevels.add(levels);
791}
792
793/*static*/ MediaProfiles*
794MediaProfiles::createDefaultInstance()
795{
796    MediaProfiles *profiles = new MediaProfiles;
797    createDefaultCamcorderProfiles(profiles);
798    createDefaultVideoEncoders(profiles);
799    createDefaultAudioEncoders(profiles);
800    createDefaultVideoDecoders(profiles);
801    createDefaultAudioDecoders(profiles);
802    createDefaultEncoderOutputFileFormats(profiles);
803    createDefaultImageEncodingQualityLevels(profiles);
804    return profiles;
805}
806
807/*static*/ MediaProfiles*
808MediaProfiles::createInstanceFromXmlFile(const char *xml)
809{
810    FILE *fp = NULL;
811    CHECK((fp = fopen(xml, "r")));
812
813    XML_Parser parser = ::XML_ParserCreate(NULL);
814    CHECK(parser != NULL);
815
816    MediaProfiles *profiles = new MediaProfiles();
817    ::XML_SetUserData(parser, profiles);
818    ::XML_SetElementHandler(parser, startElementHandler, NULL);
819
820    /*
821      FIXME:
822      expat is not compiled with -DXML_DTD. We don't have DTD parsing support.
823
824      if (!::XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS)) {
825          LOGE("failed to enable DTD support in the xml file");
826          return UNKNOWN_ERROR;
827      }
828
829    */
830
831    const int BUFF_SIZE = 512;
832    for (;;) {
833        void *buff = ::XML_GetBuffer(parser, BUFF_SIZE);
834        if (buff == NULL) {
835            LOGE("failed to in call to XML_GetBuffer()");
836            delete profiles;
837            profiles = NULL;
838            goto exit;
839        }
840
841        int bytes_read = ::fread(buff, 1, BUFF_SIZE, fp);
842        if (bytes_read < 0) {
843            LOGE("failed in call to read");
844            delete profiles;
845            profiles = NULL;
846            goto exit;
847        }
848
849        CHECK(::XML_ParseBuffer(parser, bytes_read, bytes_read == 0));
850
851        if (bytes_read == 0) break;  // done parsing the xml file
852    }
853
854exit:
855    ::XML_ParserFree(parser);
856    ::fclose(fp);
857    return profiles;
858}
859
860Vector<output_format> MediaProfiles::getOutputFileFormats() const
861{
862    return mEncoderOutputFileFormats;  // copy out
863}
864
865Vector<video_encoder> MediaProfiles::getVideoEncoders() const
866{
867    Vector<video_encoder> encoders;
868    for (size_t i = 0; i < mVideoEncoders.size(); ++i) {
869        encoders.add(mVideoEncoders[i]->mCodec);
870    }
871    return encoders;  // copy out
872}
873
874int MediaProfiles::getVideoEncoderParamByName(const char *name, video_encoder codec) const
875{
876    LOGV("getVideoEncoderParamByName: %s for codec %d", name, codec);
877    int index = -1;
878    for (size_t i = 0, n = mVideoEncoders.size(); i < n; ++i) {
879        if (mVideoEncoders[i]->mCodec == codec) {
880            index = i;
881            break;
882        }
883    }
884    if (index == -1) {
885        LOGE("The given video encoder %d is not found", codec);
886        return -1;
887    }
888
889    if (!strcmp("enc.vid.width.min", name)) return mVideoEncoders[index]->mMinFrameWidth;
890    if (!strcmp("enc.vid.width.max", name)) return mVideoEncoders[index]->mMaxFrameWidth;
891    if (!strcmp("enc.vid.height.min", name)) return mVideoEncoders[index]->mMinFrameHeight;
892    if (!strcmp("enc.vid.height.max", name)) return mVideoEncoders[index]->mMaxFrameHeight;
893    if (!strcmp("enc.vid.bps.min", name)) return mVideoEncoders[index]->mMinBitRate;
894    if (!strcmp("enc.vid.bps.max", name)) return mVideoEncoders[index]->mMaxBitRate;
895    if (!strcmp("enc.vid.fps.min", name)) return mVideoEncoders[index]->mMinFrameRate;
896    if (!strcmp("enc.vid.fps.max", name)) return mVideoEncoders[index]->mMaxFrameRate;
897
898    LOGE("The given video encoder param name %s is not found", name);
899    return -1;
900}
901
902Vector<audio_encoder> MediaProfiles::getAudioEncoders() const
903{
904    Vector<audio_encoder> encoders;
905    for (size_t i = 0; i < mAudioEncoders.size(); ++i) {
906        encoders.add(mAudioEncoders[i]->mCodec);
907    }
908    return encoders;  // copy out
909}
910
911int MediaProfiles::getAudioEncoderParamByName(const char *name, audio_encoder codec) const
912{
913    LOGV("getAudioEncoderParamByName: %s for codec %d", name, codec);
914    int index = -1;
915    for (size_t i = 0, n = mAudioEncoders.size(); i < n; ++i) {
916        if (mAudioEncoders[i]->mCodec == codec) {
917            index = i;
918            break;
919        }
920    }
921    if (index == -1) {
922        LOGE("The given audio encoder %d is not found", codec);
923        return -1;
924    }
925
926    if (!strcmp("enc.aud.ch.min", name)) return mAudioEncoders[index]->mMinChannels;
927    if (!strcmp("enc.aud.ch.max", name)) return mAudioEncoders[index]->mMaxChannels;
928    if (!strcmp("enc.aud.bps.min", name)) return mAudioEncoders[index]->mMinBitRate;
929    if (!strcmp("enc.aud.bps.max", name)) return mAudioEncoders[index]->mMaxBitRate;
930    if (!strcmp("enc.aud.hz.min", name)) return mAudioEncoders[index]->mMinSampleRate;
931    if (!strcmp("enc.aud.hz.max", name)) return mAudioEncoders[index]->mMaxSampleRate;
932
933    LOGE("The given audio encoder param name %s is not found", name);
934    return -1;
935}
936
937Vector<video_decoder> MediaProfiles::getVideoDecoders() const
938{
939    Vector<video_decoder> decoders;
940    for (size_t i = 0; i < mVideoDecoders.size(); ++i) {
941        decoders.add(mVideoDecoders[i]->mCodec);
942    }
943    return decoders;  // copy out
944}
945
946Vector<audio_decoder> MediaProfiles::getAudioDecoders() const
947{
948    Vector<audio_decoder> decoders;
949    for (size_t i = 0; i < mAudioDecoders.size(); ++i) {
950        decoders.add(mAudioDecoders[i]->mCodec);
951    }
952    return decoders;  // copy out
953}
954
955int MediaProfiles::getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const
956{
957    int index = -1;
958    for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) {
959        if (mCamcorderProfiles[i]->mCameraId == cameraId &&
960            mCamcorderProfiles[i]->mQuality == quality) {
961            index = i;
962            break;
963        }
964    }
965    return index;
966}
967
968int MediaProfiles::getCamcorderProfileParamByName(const char *name,
969                                                  int cameraId,
970                                                  camcorder_quality quality) const
971{
972    LOGV("getCamcorderProfileParamByName: %s for camera %d, quality %d",
973         name, cameraId, quality);
974
975    int index = getCamcorderProfileIndex(cameraId, quality);
976    if (index == -1) {
977        LOGE("The given camcorder profile camera %d quality %d is not found",
978             cameraId, quality);
979        return -1;
980    }
981
982    if (!strcmp("duration", name)) return mCamcorderProfiles[index]->mDuration;
983    if (!strcmp("file.format", name)) return mCamcorderProfiles[index]->mFileFormat;
984    if (!strcmp("vid.codec", name)) return mCamcorderProfiles[index]->mVideoCodec->mCodec;
985    if (!strcmp("vid.width", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameWidth;
986    if (!strcmp("vid.height", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameHeight;
987    if (!strcmp("vid.bps", name)) return mCamcorderProfiles[index]->mVideoCodec->mBitRate;
988    if (!strcmp("vid.fps", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameRate;
989    if (!strcmp("aud.codec", name)) return mCamcorderProfiles[index]->mAudioCodec->mCodec;
990    if (!strcmp("aud.bps", name)) return mCamcorderProfiles[index]->mAudioCodec->mBitRate;
991    if (!strcmp("aud.ch", name)) return mCamcorderProfiles[index]->mAudioCodec->mChannels;
992    if (!strcmp("aud.hz", name)) return mCamcorderProfiles[index]->mAudioCodec->mSampleRate;
993
994    LOGE("The given camcorder profile param id %d name %s is not found", cameraId, name);
995    return -1;
996}
997
998bool MediaProfiles::hasCamcorderProfile(int cameraId, camcorder_quality quality) const
999{
1000    return (getCamcorderProfileIndex(cameraId, quality) != -1);
1001}
1002
1003Vector<int> MediaProfiles::getImageEncodingQualityLevels(int cameraId) const
1004{
1005    Vector<int> result;
1006    ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId);
1007    if (levels != NULL) {
1008        result = levels->mLevels;  // copy out
1009    }
1010    return result;
1011}
1012
1013int MediaProfiles::getStartTimeOffsetMs(int cameraId) const {
1014    int offsetTimeMs = -1;
1015    ssize_t index = mStartTimeOffsets.indexOfKey(cameraId);
1016    if (index >= 0) {
1017        offsetTimeMs = mStartTimeOffsets.valueFor(cameraId);
1018    }
1019    LOGV("%s: offsetTime=%d ms and cameraId=%d", offsetTimeMs, cameraId);
1020    return offsetTimeMs;
1021}
1022
1023MediaProfiles::~MediaProfiles()
1024{
1025    CHECK("destructor should never be called" == 0);
1026#if 0
1027    for (size_t i = 0; i < mAudioEncoders.size(); ++i) {
1028        delete mAudioEncoders[i];
1029    }
1030    mAudioEncoders.clear();
1031
1032    for (size_t i = 0; i < mVideoEncoders.size(); ++i) {
1033        delete mVideoEncoders[i];
1034    }
1035    mVideoEncoders.clear();
1036
1037    for (size_t i = 0; i < mVideoDecoders.size(); ++i) {
1038        delete mVideoDecoders[i];
1039    }
1040    mVideoDecoders.clear();
1041
1042    for (size_t i = 0; i < mAudioDecoders.size(); ++i) {
1043        delete mAudioDecoders[i];
1044    }
1045    mAudioDecoders.clear();
1046
1047    for (size_t i = 0; i < mCamcorderProfiles.size(); ++i) {
1048        delete mCamcorderProfiles[i];
1049    }
1050    mCamcorderProfiles.clear();
1051#endif
1052}
1053} // namespace android
1054