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