1 /*
2  * Copyright (C) 2009 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "Utils"
19 #include <utils/Log.h>
20 #include <ctype.h>
21 #include <stdio.h>
22 #include <sys/stat.h>
23 
24 #include <utility>
25 #include <vector>
26 
27 #include "include/ESDS.h"
28 #include "include/HevcUtils.h"
29 
30 #include <cutils/properties.h>
31 #include <media/openmax/OMX_Audio.h>
32 #include <media/openmax/OMX_Video.h>
33 #include <media/openmax/OMX_VideoExt.h>
34 #include <media/stagefright/CodecBase.h>
35 #include <media/stagefright/foundation/ABuffer.h>
36 #include <media/stagefright/foundation/ADebug.h>
37 #include <media/stagefright/foundation/ALookup.h>
38 #include <media/stagefright/foundation/AMessage.h>
39 #include <media/stagefright/foundation/ByteUtils.h>
40 #include <media/stagefright/MetaData.h>
41 #include <media/stagefright/MediaDefs.h>
42 #include <media/AudioSystem.h>
43 #include <media/MediaPlayerInterface.h>
44 #include <media/stagefright/Utils.h>
45 #include <media/AudioParameter.h>
46 #include <system/audio.h>
47 
48 namespace android {
49 
copyNALUToABuffer(sp<ABuffer> * buffer,const uint8_t * ptr,size_t length)50 static status_t copyNALUToABuffer(sp<ABuffer> *buffer, const uint8_t *ptr, size_t length) {
51     if (((*buffer)->size() + 4 + length) > ((*buffer)->capacity() - (*buffer)->offset())) {
52         sp<ABuffer> tmpBuffer = new (std::nothrow) ABuffer((*buffer)->size() + 4 + length + 1024);
53         if (tmpBuffer.get() == NULL || tmpBuffer->base() == NULL) {
54             return NO_MEMORY;
55         }
56         memcpy(tmpBuffer->data(), (*buffer)->data(), (*buffer)->size());
57         tmpBuffer->setRange(0, (*buffer)->size());
58         (*buffer) = tmpBuffer;
59     }
60 
61     memcpy((*buffer)->data() + (*buffer)->size(), "\x00\x00\x00\x01", 4);
62     memcpy((*buffer)->data() + (*buffer)->size() + 4, ptr, length);
63     (*buffer)->setRange((*buffer)->offset(), (*buffer)->size() + 4 + length);
64     return OK;
65 }
66 
67 #if 0
68 static void convertMetaDataToMessageInt32(
69         const sp<MetaData> &meta, sp<AMessage> &msg, uint32_t key, const char *name) {
70     int32_t value;
71     if (meta->findInt32(key, &value)) {
72         msg->setInt32(name, value);
73     }
74 }
75 #endif
76 
convertMetaDataToMessageColorAspects(const sp<MetaData> & meta,sp<AMessage> & msg)77 static void convertMetaDataToMessageColorAspects(const sp<MetaData> &meta, sp<AMessage> &msg) {
78     // 0 values are unspecified
79     int32_t range = 0;
80     int32_t primaries = 0;
81     int32_t transferFunction = 0;
82     int32_t colorMatrix = 0;
83     meta->findInt32(kKeyColorRange, &range);
84     meta->findInt32(kKeyColorPrimaries, &primaries);
85     meta->findInt32(kKeyTransferFunction, &transferFunction);
86     meta->findInt32(kKeyColorMatrix, &colorMatrix);
87     ColorAspects colorAspects;
88     memset(&colorAspects, 0, sizeof(colorAspects));
89     colorAspects.mRange = (ColorAspects::Range)range;
90     colorAspects.mPrimaries = (ColorAspects::Primaries)primaries;
91     colorAspects.mTransfer = (ColorAspects::Transfer)transferFunction;
92     colorAspects.mMatrixCoeffs = (ColorAspects::MatrixCoeffs)colorMatrix;
93 
94     int32_t rangeMsg, standardMsg, transferMsg;
95     if (CodecBase::convertCodecColorAspectsToPlatformAspects(
96             colorAspects, &rangeMsg, &standardMsg, &transferMsg) != OK) {
97         return;
98     }
99 
100     // save specified values to msg
101     if (rangeMsg != 0) {
102         msg->setInt32("color-range", rangeMsg);
103     }
104     if (standardMsg != 0) {
105         msg->setInt32("color-standard", standardMsg);
106     }
107     if (transferMsg != 0) {
108         msg->setInt32("color-transfer", transferMsg);
109     }
110 }
111 
isHdr(const sp<AMessage> & format)112 static bool isHdr(const sp<AMessage> &format) {
113     // if CSD specifies HDR transfer(s), we assume HDR. Otherwise, if it specifies non-HDR
114     // transfers, we must assume non-HDR. This is because CSD trumps any color-transfer key
115     // in the format.
116     int32_t isHdr;
117     if (format->findInt32("android._is-hdr", &isHdr)) {
118         return isHdr;
119     }
120 
121     // if user/container supplied HDR static info without transfer set, assume true
122     if (format->contains("hdr-static-info") && !format->contains("color-transfer")) {
123         return true;
124     }
125     // otherwise, verify that an HDR transfer function is set
126     int32_t transfer;
127     if (format->findInt32("color-transfer", &transfer)) {
128         return transfer == ColorUtils::kColorTransferST2084
129                 || transfer == ColorUtils::kColorTransferHLG;
130     }
131     return false;
132 }
133 
parseAacProfileFromCsd(const sp<ABuffer> & csd,sp<AMessage> & format)134 static void parseAacProfileFromCsd(const sp<ABuffer> &csd, sp<AMessage> &format) {
135     if (csd->size() < 2) {
136         return;
137     }
138 
139     uint16_t audioObjectType = U16_AT((uint8_t*)csd->data());
140     if ((audioObjectType & 0xF800) == 0xF800) {
141         audioObjectType = 32 + ((audioObjectType >> 5) & 0x3F);
142     } else {
143         audioObjectType >>= 11;
144     }
145 
146     const static ALookup<uint16_t, OMX_AUDIO_AACPROFILETYPE> profiles {
147         { 1,  OMX_AUDIO_AACObjectMain     },
148         { 2,  OMX_AUDIO_AACObjectLC       },
149         { 3,  OMX_AUDIO_AACObjectSSR      },
150         { 4,  OMX_AUDIO_AACObjectLTP      },
151         { 5,  OMX_AUDIO_AACObjectHE       },
152         { 6,  OMX_AUDIO_AACObjectScalable },
153         { 17, OMX_AUDIO_AACObjectERLC     },
154         { 23, OMX_AUDIO_AACObjectLD       },
155         { 29, OMX_AUDIO_AACObjectHE_PS    },
156         { 39, OMX_AUDIO_AACObjectELD      },
157         { 42, OMX_AUDIO_AACObjectXHE      },
158     };
159 
160     OMX_AUDIO_AACPROFILETYPE profile;
161     if (profiles.map(audioObjectType, &profile)) {
162         format->setInt32("profile", profile);
163     }
164 }
165 
parseAvcProfileLevelFromAvcc(const uint8_t * ptr,size_t size,sp<AMessage> & format)166 static void parseAvcProfileLevelFromAvcc(const uint8_t *ptr, size_t size, sp<AMessage> &format) {
167     if (size < 4 || ptr[0] != 1) {  // configurationVersion == 1
168         return;
169     }
170     const uint8_t profile = ptr[1];
171     const uint8_t constraints = ptr[2];
172     const uint8_t level = ptr[3];
173 
174     const static ALookup<uint8_t, OMX_VIDEO_AVCLEVELTYPE> levels {
175         {  9, OMX_VIDEO_AVCLevel1b }, // technically, 9 is only used for High+ profiles
176         { 10, OMX_VIDEO_AVCLevel1  },
177         { 11, OMX_VIDEO_AVCLevel11 }, // prefer level 1.1 for the value 11
178         { 11, OMX_VIDEO_AVCLevel1b },
179         { 12, OMX_VIDEO_AVCLevel12 },
180         { 13, OMX_VIDEO_AVCLevel13 },
181         { 20, OMX_VIDEO_AVCLevel2  },
182         { 21, OMX_VIDEO_AVCLevel21 },
183         { 22, OMX_VIDEO_AVCLevel22 },
184         { 30, OMX_VIDEO_AVCLevel3  },
185         { 31, OMX_VIDEO_AVCLevel31 },
186         { 32, OMX_VIDEO_AVCLevel32 },
187         { 40, OMX_VIDEO_AVCLevel4  },
188         { 41, OMX_VIDEO_AVCLevel41 },
189         { 42, OMX_VIDEO_AVCLevel42 },
190         { 50, OMX_VIDEO_AVCLevel5  },
191         { 51, OMX_VIDEO_AVCLevel51 },
192         { 52, OMX_VIDEO_AVCLevel52 },
193     };
194     const static ALookup<uint8_t, OMX_VIDEO_AVCPROFILETYPE> profiles {
195         { 66, OMX_VIDEO_AVCProfileBaseline },
196         { 77, OMX_VIDEO_AVCProfileMain     },
197         { 88, OMX_VIDEO_AVCProfileExtended },
198         { 100, OMX_VIDEO_AVCProfileHigh    },
199         { 110, OMX_VIDEO_AVCProfileHigh10  },
200         { 122, OMX_VIDEO_AVCProfileHigh422 },
201         { 244, OMX_VIDEO_AVCProfileHigh444 },
202     };
203 
204     // set profile & level if they are recognized
205     OMX_VIDEO_AVCPROFILETYPE codecProfile;
206     OMX_VIDEO_AVCLEVELTYPE codecLevel;
207     if (profiles.map(profile, &codecProfile)) {
208         if (profile == 66 && (constraints & 0x40)) {
209             codecProfile = (OMX_VIDEO_AVCPROFILETYPE)OMX_VIDEO_AVCProfileConstrainedBaseline;
210         } else if (profile == 100 && (constraints & 0x0C) == 0x0C) {
211             codecProfile = (OMX_VIDEO_AVCPROFILETYPE)OMX_VIDEO_AVCProfileConstrainedHigh;
212         }
213         format->setInt32("profile", codecProfile);
214         if (levels.map(level, &codecLevel)) {
215             // for 9 && 11 decide level based on profile and constraint_set3 flag
216             if (level == 11 && (profile == 66 || profile == 77 || profile == 88)) {
217                 codecLevel = (constraints & 0x10) ? OMX_VIDEO_AVCLevel1b : OMX_VIDEO_AVCLevel11;
218             }
219             format->setInt32("level", codecLevel);
220         }
221     }
222 }
223 
parseH263ProfileLevelFromD263(const uint8_t * ptr,size_t size,sp<AMessage> & format)224 static void parseH263ProfileLevelFromD263(const uint8_t *ptr, size_t size, sp<AMessage> &format) {
225     if (size < 7) {
226         return;
227     }
228 
229     const uint8_t profile = ptr[6];
230     const uint8_t level = ptr[5];
231 
232     const static ALookup<uint8_t, OMX_VIDEO_H263PROFILETYPE> profiles {
233         { 0, OMX_VIDEO_H263ProfileBaseline },
234         { 1, OMX_VIDEO_H263ProfileH320Coding },
235         { 2, OMX_VIDEO_H263ProfileBackwardCompatible },
236         { 3, OMX_VIDEO_H263ProfileISWV2 },
237         { 4, OMX_VIDEO_H263ProfileISWV3 },
238         { 5, OMX_VIDEO_H263ProfileHighCompression },
239         { 6, OMX_VIDEO_H263ProfileInternet },
240         { 7, OMX_VIDEO_H263ProfileInterlace },
241         { 8, OMX_VIDEO_H263ProfileHighLatency },
242     };
243 
244     const static ALookup<uint8_t, OMX_VIDEO_H263LEVELTYPE> levels {
245         { 10, OMX_VIDEO_H263Level10 },
246         { 20, OMX_VIDEO_H263Level20 },
247         { 30, OMX_VIDEO_H263Level30 },
248         { 40, OMX_VIDEO_H263Level40 },
249         { 45, OMX_VIDEO_H263Level45 },
250         { 50, OMX_VIDEO_H263Level50 },
251         { 60, OMX_VIDEO_H263Level60 },
252         { 70, OMX_VIDEO_H263Level70 },
253     };
254 
255     // set profile & level if they are recognized
256     OMX_VIDEO_H263PROFILETYPE codecProfile;
257     OMX_VIDEO_H263LEVELTYPE codecLevel;
258     if (profiles.map(profile, &codecProfile)) {
259         format->setInt32("profile", codecProfile);
260         if (levels.map(level, &codecLevel)) {
261             format->setInt32("level", codecLevel);
262         }
263     }
264 }
265 
parseHevcProfileLevelFromHvcc(const uint8_t * ptr,size_t size,sp<AMessage> & format)266 static void parseHevcProfileLevelFromHvcc(const uint8_t *ptr, size_t size, sp<AMessage> &format) {
267     if (size < 13 || ptr[0] != 1) {  // configurationVersion == 1
268         return;
269     }
270 
271     const uint8_t profile = ptr[1] & 0x1F;
272     const uint8_t tier = (ptr[1] & 0x20) >> 5;
273     const uint8_t level = ptr[12];
274 
275     const static ALookup<std::pair<uint8_t, uint8_t>, OMX_VIDEO_HEVCLEVELTYPE> levels {
276         { { 0, 30  }, OMX_VIDEO_HEVCMainTierLevel1  },
277         { { 0, 60  }, OMX_VIDEO_HEVCMainTierLevel2  },
278         { { 0, 63  }, OMX_VIDEO_HEVCMainTierLevel21 },
279         { { 0, 90  }, OMX_VIDEO_HEVCMainTierLevel3  },
280         { { 0, 93  }, OMX_VIDEO_HEVCMainTierLevel31 },
281         { { 0, 120 }, OMX_VIDEO_HEVCMainTierLevel4  },
282         { { 0, 123 }, OMX_VIDEO_HEVCMainTierLevel41 },
283         { { 0, 150 }, OMX_VIDEO_HEVCMainTierLevel5  },
284         { { 0, 153 }, OMX_VIDEO_HEVCMainTierLevel51 },
285         { { 0, 156 }, OMX_VIDEO_HEVCMainTierLevel52 },
286         { { 0, 180 }, OMX_VIDEO_HEVCMainTierLevel6  },
287         { { 0, 183 }, OMX_VIDEO_HEVCMainTierLevel61 },
288         { { 0, 186 }, OMX_VIDEO_HEVCMainTierLevel62 },
289         { { 1, 30  }, OMX_VIDEO_HEVCHighTierLevel1  },
290         { { 1, 60  }, OMX_VIDEO_HEVCHighTierLevel2  },
291         { { 1, 63  }, OMX_VIDEO_HEVCHighTierLevel21 },
292         { { 1, 90  }, OMX_VIDEO_HEVCHighTierLevel3  },
293         { { 1, 93  }, OMX_VIDEO_HEVCHighTierLevel31 },
294         { { 1, 120 }, OMX_VIDEO_HEVCHighTierLevel4  },
295         { { 1, 123 }, OMX_VIDEO_HEVCHighTierLevel41 },
296         { { 1, 150 }, OMX_VIDEO_HEVCHighTierLevel5  },
297         { { 1, 153 }, OMX_VIDEO_HEVCHighTierLevel51 },
298         { { 1, 156 }, OMX_VIDEO_HEVCHighTierLevel52 },
299         { { 1, 180 }, OMX_VIDEO_HEVCHighTierLevel6  },
300         { { 1, 183 }, OMX_VIDEO_HEVCHighTierLevel61 },
301         { { 1, 186 }, OMX_VIDEO_HEVCHighTierLevel62 },
302     };
303 
304     const static ALookup<uint8_t, OMX_VIDEO_HEVCPROFILETYPE> profiles {
305         { 1, OMX_VIDEO_HEVCProfileMain   },
306         { 2, OMX_VIDEO_HEVCProfileMain10 },
307         // use Main for Main Still Picture decoding
308         { 3, OMX_VIDEO_HEVCProfileMain },
309     };
310 
311     // set profile & level if they are recognized
312     OMX_VIDEO_HEVCPROFILETYPE codecProfile;
313     OMX_VIDEO_HEVCLEVELTYPE codecLevel;
314     if (!profiles.map(profile, &codecProfile)) {
315         if (ptr[2] & 0x40 /* general compatibility flag 1 */) {
316             // Note that this case covers Main Still Picture too
317             codecProfile = OMX_VIDEO_HEVCProfileMain;
318         } else if (ptr[2] & 0x20 /* general compatibility flag 2 */) {
319             codecProfile = OMX_VIDEO_HEVCProfileMain10;
320         } else {
321             return;
322         }
323     }
324 
325     // bump to HDR profile
326     if (isHdr(format) && codecProfile == OMX_VIDEO_HEVCProfileMain10) {
327         codecProfile = OMX_VIDEO_HEVCProfileMain10HDR10;
328     }
329 
330     format->setInt32("profile", codecProfile);
331     if (levels.map(std::make_pair(tier, level), &codecLevel)) {
332         format->setInt32("level", codecLevel);
333     }
334 }
335 
parseMpeg2ProfileLevelFromHeader(const uint8_t * data,size_t size,sp<AMessage> & format)336 static void parseMpeg2ProfileLevelFromHeader(
337         const uint8_t *data, size_t size, sp<AMessage> &format) {
338     // find sequence extension
339     const uint8_t *seq = (const uint8_t*)memmem(data, size, "\x00\x00\x01\xB5", 4);
340     if (seq != NULL && seq + 5 < data + size) {
341         const uint8_t start_code = seq[4] >> 4;
342         if (start_code != 1 /* sequence extension ID */) {
343             return;
344         }
345         const uint8_t indication = ((seq[4] & 0xF) << 4) | ((seq[5] & 0xF0) >> 4);
346 
347         const static ALookup<uint8_t, OMX_VIDEO_MPEG2PROFILETYPE> profiles {
348             { 0x50, OMX_VIDEO_MPEG2ProfileSimple  },
349             { 0x40, OMX_VIDEO_MPEG2ProfileMain    },
350             { 0x30, OMX_VIDEO_MPEG2ProfileSNR     },
351             { 0x20, OMX_VIDEO_MPEG2ProfileSpatial },
352             { 0x10, OMX_VIDEO_MPEG2ProfileHigh    },
353         };
354 
355         const static ALookup<uint8_t, OMX_VIDEO_MPEG2LEVELTYPE> levels {
356             { 0x0A, OMX_VIDEO_MPEG2LevelLL  },
357             { 0x08, OMX_VIDEO_MPEG2LevelML  },
358             { 0x06, OMX_VIDEO_MPEG2LevelH14 },
359             { 0x04, OMX_VIDEO_MPEG2LevelHL  },
360             { 0x02, OMX_VIDEO_MPEG2LevelHP  },
361         };
362 
363         const static ALookup<uint8_t,
364                 std::pair<OMX_VIDEO_MPEG2PROFILETYPE, OMX_VIDEO_MPEG2LEVELTYPE>> escapes {
365             /* unsupported
366             { 0x8E, { XXX_MPEG2ProfileMultiView, OMX_VIDEO_MPEG2LevelLL  } },
367             { 0x8D, { XXX_MPEG2ProfileMultiView, OMX_VIDEO_MPEG2LevelML  } },
368             { 0x8B, { XXX_MPEG2ProfileMultiView, OMX_VIDEO_MPEG2LevelH14 } },
369             { 0x8A, { XXX_MPEG2ProfileMultiView, OMX_VIDEO_MPEG2LevelHL  } }, */
370             { 0x85, { OMX_VIDEO_MPEG2Profile422, OMX_VIDEO_MPEG2LevelML  } },
371             { 0x82, { OMX_VIDEO_MPEG2Profile422, OMX_VIDEO_MPEG2LevelHL  } },
372         };
373 
374         OMX_VIDEO_MPEG2PROFILETYPE profile;
375         OMX_VIDEO_MPEG2LEVELTYPE level;
376         std::pair<OMX_VIDEO_MPEG2PROFILETYPE, OMX_VIDEO_MPEG2LEVELTYPE> profileLevel;
377         if (escapes.map(indication, &profileLevel)) {
378             format->setInt32("profile", profileLevel.first);
379             format->setInt32("level", profileLevel.second);
380         } else if (profiles.map(indication & 0x70, &profile)) {
381             format->setInt32("profile", profile);
382             if (levels.map(indication & 0xF, &level)) {
383                 format->setInt32("level", level);
384             }
385         }
386     }
387 }
388 
parseMpeg2ProfileLevelFromEsds(ESDS & esds,sp<AMessage> & format)389 static void parseMpeg2ProfileLevelFromEsds(ESDS &esds, sp<AMessage> &format) {
390     // esds seems to only contain the profile for MPEG-2
391     uint8_t objType;
392     if (esds.getObjectTypeIndication(&objType) == OK) {
393         const static ALookup<uint8_t, OMX_VIDEO_MPEG2PROFILETYPE> profiles{
394             { 0x60, OMX_VIDEO_MPEG2ProfileSimple  },
395             { 0x61, OMX_VIDEO_MPEG2ProfileMain    },
396             { 0x62, OMX_VIDEO_MPEG2ProfileSNR     },
397             { 0x63, OMX_VIDEO_MPEG2ProfileSpatial },
398             { 0x64, OMX_VIDEO_MPEG2ProfileHigh    },
399             { 0x65, OMX_VIDEO_MPEG2Profile422     },
400         };
401 
402         OMX_VIDEO_MPEG2PROFILETYPE profile;
403         if (profiles.map(objType, &profile)) {
404             format->setInt32("profile", profile);
405         }
406     }
407 }
408 
parseMpeg4ProfileLevelFromCsd(const sp<ABuffer> & csd,sp<AMessage> & format)409 static void parseMpeg4ProfileLevelFromCsd(const sp<ABuffer> &csd, sp<AMessage> &format) {
410     const uint8_t *data = csd->data();
411     // find visual object sequence
412     const uint8_t *seq = (const uint8_t*)memmem(data, csd->size(), "\x00\x00\x01\xB0", 4);
413     if (seq != NULL && seq + 4 < data + csd->size()) {
414         const uint8_t indication = seq[4];
415 
416         const static ALookup<uint8_t,
417                 std::pair<OMX_VIDEO_MPEG4PROFILETYPE, OMX_VIDEO_MPEG4LEVELTYPE>> table {
418             { 0b00000001, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level1  } },
419             { 0b00000010, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level2  } },
420             { 0b00000011, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level3  } },
421             { 0b00000100, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level4a } },
422             { 0b00000101, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level5  } },
423             { 0b00000110, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level6  } },
424             { 0b00001000, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level0  } },
425             { 0b00001001, { OMX_VIDEO_MPEG4ProfileSimple,            OMX_VIDEO_MPEG4Level0b } },
426             { 0b00010000, { OMX_VIDEO_MPEG4ProfileSimpleScalable,    OMX_VIDEO_MPEG4Level0  } },
427             { 0b00010001, { OMX_VIDEO_MPEG4ProfileSimpleScalable,    OMX_VIDEO_MPEG4Level1  } },
428             { 0b00010010, { OMX_VIDEO_MPEG4ProfileSimpleScalable,    OMX_VIDEO_MPEG4Level2  } },
429             /* unsupported
430             { 0b00011101, { XXX_MPEG4ProfileSimpleScalableER,        OMX_VIDEO_MPEG4Level0  } },
431             { 0b00011110, { XXX_MPEG4ProfileSimpleScalableER,        OMX_VIDEO_MPEG4Level1  } },
432             { 0b00011111, { XXX_MPEG4ProfileSimpleScalableER,        OMX_VIDEO_MPEG4Level2  } }, */
433             { 0b00100001, { OMX_VIDEO_MPEG4ProfileCore,              OMX_VIDEO_MPEG4Level1  } },
434             { 0b00100010, { OMX_VIDEO_MPEG4ProfileCore,              OMX_VIDEO_MPEG4Level2  } },
435             { 0b00110010, { OMX_VIDEO_MPEG4ProfileMain,              OMX_VIDEO_MPEG4Level2  } },
436             { 0b00110011, { OMX_VIDEO_MPEG4ProfileMain,              OMX_VIDEO_MPEG4Level3  } },
437             { 0b00110100, { OMX_VIDEO_MPEG4ProfileMain,              OMX_VIDEO_MPEG4Level4  } },
438             /* deprecated
439             { 0b01000010, { OMX_VIDEO_MPEG4ProfileNbit,              OMX_VIDEO_MPEG4Level2  } }, */
440             { 0b01010001, { OMX_VIDEO_MPEG4ProfileScalableTexture,   OMX_VIDEO_MPEG4Level1  } },
441             { 0b01100001, { OMX_VIDEO_MPEG4ProfileSimpleFace,        OMX_VIDEO_MPEG4Level1  } },
442             { 0b01100010, { OMX_VIDEO_MPEG4ProfileSimpleFace,        OMX_VIDEO_MPEG4Level2  } },
443             { 0b01100011, { OMX_VIDEO_MPEG4ProfileSimpleFBA,         OMX_VIDEO_MPEG4Level1  } },
444             { 0b01100100, { OMX_VIDEO_MPEG4ProfileSimpleFBA,         OMX_VIDEO_MPEG4Level2  } },
445             { 0b01110001, { OMX_VIDEO_MPEG4ProfileBasicAnimated,     OMX_VIDEO_MPEG4Level1  } },
446             { 0b01110010, { OMX_VIDEO_MPEG4ProfileBasicAnimated,     OMX_VIDEO_MPEG4Level2  } },
447             { 0b10000001, { OMX_VIDEO_MPEG4ProfileHybrid,            OMX_VIDEO_MPEG4Level1  } },
448             { 0b10000010, { OMX_VIDEO_MPEG4ProfileHybrid,            OMX_VIDEO_MPEG4Level2  } },
449             { 0b10010001, { OMX_VIDEO_MPEG4ProfileAdvancedRealTime,  OMX_VIDEO_MPEG4Level1  } },
450             { 0b10010010, { OMX_VIDEO_MPEG4ProfileAdvancedRealTime,  OMX_VIDEO_MPEG4Level2  } },
451             { 0b10010011, { OMX_VIDEO_MPEG4ProfileAdvancedRealTime,  OMX_VIDEO_MPEG4Level3  } },
452             { 0b10010100, { OMX_VIDEO_MPEG4ProfileAdvancedRealTime,  OMX_VIDEO_MPEG4Level4  } },
453             { 0b10100001, { OMX_VIDEO_MPEG4ProfileCoreScalable,      OMX_VIDEO_MPEG4Level1  } },
454             { 0b10100010, { OMX_VIDEO_MPEG4ProfileCoreScalable,      OMX_VIDEO_MPEG4Level2  } },
455             { 0b10100011, { OMX_VIDEO_MPEG4ProfileCoreScalable,      OMX_VIDEO_MPEG4Level3  } },
456             { 0b10110001, { OMX_VIDEO_MPEG4ProfileAdvancedCoding,    OMX_VIDEO_MPEG4Level1  } },
457             { 0b10110010, { OMX_VIDEO_MPEG4ProfileAdvancedCoding,    OMX_VIDEO_MPEG4Level2  } },
458             { 0b10110011, { OMX_VIDEO_MPEG4ProfileAdvancedCoding,    OMX_VIDEO_MPEG4Level3  } },
459             { 0b10110100, { OMX_VIDEO_MPEG4ProfileAdvancedCoding,    OMX_VIDEO_MPEG4Level4  } },
460             { 0b11000001, { OMX_VIDEO_MPEG4ProfileAdvancedCore,      OMX_VIDEO_MPEG4Level1  } },
461             { 0b11000010, { OMX_VIDEO_MPEG4ProfileAdvancedCore,      OMX_VIDEO_MPEG4Level2  } },
462             { 0b11010001, { OMX_VIDEO_MPEG4ProfileAdvancedScalable,  OMX_VIDEO_MPEG4Level1  } },
463             { 0b11010010, { OMX_VIDEO_MPEG4ProfileAdvancedScalable,  OMX_VIDEO_MPEG4Level2  } },
464             { 0b11010011, { OMX_VIDEO_MPEG4ProfileAdvancedScalable,  OMX_VIDEO_MPEG4Level3  } },
465             /* unsupported
466             { 0b11100001, { XXX_MPEG4ProfileSimpleStudio,            OMX_VIDEO_MPEG4Level1  } },
467             { 0b11100010, { XXX_MPEG4ProfileSimpleStudio,            OMX_VIDEO_MPEG4Level2  } },
468             { 0b11100011, { XXX_MPEG4ProfileSimpleStudio,            OMX_VIDEO_MPEG4Level3  } },
469             { 0b11100100, { XXX_MPEG4ProfileSimpleStudio,            OMX_VIDEO_MPEG4Level4  } },
470             { 0b11100101, { XXX_MPEG4ProfileCoreStudio,              OMX_VIDEO_MPEG4Level1  } },
471             { 0b11100110, { XXX_MPEG4ProfileCoreStudio,              OMX_VIDEO_MPEG4Level2  } },
472             { 0b11100111, { XXX_MPEG4ProfileCoreStudio,              OMX_VIDEO_MPEG4Level3  } },
473             { 0b11101000, { XXX_MPEG4ProfileCoreStudio,              OMX_VIDEO_MPEG4Level4  } },
474             { 0b11101011, { XXX_MPEG4ProfileSimpleStudio,            OMX_VIDEO_MPEG4Level5  } },
475             { 0b11101100, { XXX_MPEG4ProfileSimpleStudio,            OMX_VIDEO_MPEG4Level6  } }, */
476             { 0b11110000, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level0  } },
477             { 0b11110001, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level1  } },
478             { 0b11110010, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level2  } },
479             { 0b11110011, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level3  } },
480             { 0b11110100, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level4  } },
481             { 0b11110101, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level5  } },
482             { 0b11110111, { OMX_VIDEO_MPEG4ProfileAdvancedSimple,    OMX_VIDEO_MPEG4Level3b } },
483             /* deprecated
484             { 0b11111000, { XXX_MPEG4ProfileFineGranularityScalable, OMX_VIDEO_MPEG4Level0  } },
485             { 0b11111001, { XXX_MPEG4ProfileFineGranularityScalable, OMX_VIDEO_MPEG4Level1  } },
486             { 0b11111010, { XXX_MPEG4ProfileFineGranularityScalable, OMX_VIDEO_MPEG4Level2  } },
487             { 0b11111011, { XXX_MPEG4ProfileFineGranularityScalable, OMX_VIDEO_MPEG4Level3  } },
488             { 0b11111100, { XXX_MPEG4ProfileFineGranularityScalable, OMX_VIDEO_MPEG4Level4  } },
489             { 0b11111101, { XXX_MPEG4ProfileFineGranularityScalable, OMX_VIDEO_MPEG4Level5  } }, */
490         };
491 
492         std::pair<OMX_VIDEO_MPEG4PROFILETYPE, OMX_VIDEO_MPEG4LEVELTYPE> profileLevel;
493         if (table.map(indication, &profileLevel)) {
494             format->setInt32("profile", profileLevel.first);
495             format->setInt32("level", profileLevel.second);
496         }
497     }
498 }
499 
parseVp9ProfileLevelFromCsd(const sp<ABuffer> & csd,sp<AMessage> & format)500 static void parseVp9ProfileLevelFromCsd(const sp<ABuffer> &csd, sp<AMessage> &format) {
501     const uint8_t *data = csd->data();
502     size_t remaining = csd->size();
503 
504     while (remaining >= 2) {
505         const uint8_t id = data[0];
506         const uint8_t length = data[1];
507         remaining -= 2;
508         data += 2;
509         if (length > remaining) {
510             break;
511         }
512         switch (id) {
513             case 1 /* profileId */:
514                 if (length >= 1) {
515                     const static ALookup<uint8_t, OMX_VIDEO_VP9PROFILETYPE> profiles {
516                         { 0, OMX_VIDEO_VP9Profile0 },
517                         { 1, OMX_VIDEO_VP9Profile1 },
518                         { 2, OMX_VIDEO_VP9Profile2 },
519                         { 3, OMX_VIDEO_VP9Profile3 },
520                     };
521 
522                     const static ALookup<OMX_VIDEO_VP9PROFILETYPE, OMX_VIDEO_VP9PROFILETYPE> toHdr {
523                         { OMX_VIDEO_VP9Profile2, OMX_VIDEO_VP9Profile2HDR },
524                         { OMX_VIDEO_VP9Profile3, OMX_VIDEO_VP9Profile3HDR },
525                     };
526 
527                     OMX_VIDEO_VP9PROFILETYPE profile;
528                     if (profiles.map(data[0], &profile)) {
529                         // convert to HDR profile
530                         if (isHdr(format)) {
531                             toHdr.lookup(profile, &profile);
532                         }
533 
534                         format->setInt32("profile", profile);
535                     }
536                 }
537                 break;
538             case 2 /* levelId */:
539                 if (length >= 1) {
540                     const static ALookup<uint8_t, OMX_VIDEO_VP9LEVELTYPE> levels {
541                         { 10, OMX_VIDEO_VP9Level1  },
542                         { 11, OMX_VIDEO_VP9Level11 },
543                         { 20, OMX_VIDEO_VP9Level2  },
544                         { 21, OMX_VIDEO_VP9Level21 },
545                         { 30, OMX_VIDEO_VP9Level3  },
546                         { 31, OMX_VIDEO_VP9Level31 },
547                         { 40, OMX_VIDEO_VP9Level4  },
548                         { 41, OMX_VIDEO_VP9Level41 },
549                         { 50, OMX_VIDEO_VP9Level5  },
550                         { 51, OMX_VIDEO_VP9Level51 },
551                         { 52, OMX_VIDEO_VP9Level52 },
552                         { 60, OMX_VIDEO_VP9Level6  },
553                         { 61, OMX_VIDEO_VP9Level61 },
554                         { 62, OMX_VIDEO_VP9Level62 },
555                     };
556 
557                     OMX_VIDEO_VP9LEVELTYPE level;
558                     if (levels.map(data[0], &level)) {
559                         format->setInt32("level", level);
560                     }
561                 }
562                 break;
563             default:
564                 break;
565         }
566         remaining -= length;
567         data += length;
568     }
569 }
570 
convertMetaDataToMessage(const sp<MetaData> & meta,sp<AMessage> * format)571 status_t convertMetaDataToMessage(
572         const sp<MetaData> &meta, sp<AMessage> *format) {
573 
574     format->clear();
575 
576     if (meta == NULL) {
577         ALOGE("convertMetaDataToMessage: NULL input");
578         return BAD_VALUE;
579     }
580 
581     const char *mime;
582     if (!meta->findCString(kKeyMIMEType, &mime)) {
583         return BAD_VALUE;
584     }
585 
586     sp<AMessage> msg = new AMessage;
587     msg->setString("mime", mime);
588 
589     uint32_t type;
590     const void *data;
591     size_t size;
592     if (meta->findData(kKeyCASessionID, &type, &data, &size)) {
593         sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
594         if (buffer.get() == NULL || buffer->base() == NULL) {
595             return NO_MEMORY;
596         }
597 
598         msg->setBuffer("ca-session-id", buffer);
599         memcpy(buffer->data(), data, size);
600     }
601 
602     int32_t systemId;
603     if (meta->findInt32(kKeyCASystemID, &systemId)) {
604         msg->setInt32("ca-system-id", systemId);
605     }
606 
607     if (!strncasecmp("video/scrambled", mime, 15)
608             || !strncasecmp("audio/scrambled", mime, 15)) {
609 
610         *format = msg;
611         return OK;
612     }
613 
614     int64_t durationUs;
615     if (meta->findInt64(kKeyDuration, &durationUs)) {
616         msg->setInt64("durationUs", durationUs);
617     }
618 
619     int32_t avgBitRate = 0;
620     if (meta->findInt32(kKeyBitRate, &avgBitRate) && avgBitRate > 0) {
621         msg->setInt32("bitrate", avgBitRate);
622     }
623 
624     int32_t maxBitRate;
625     if (meta->findInt32(kKeyMaxBitRate, &maxBitRate)
626             && maxBitRate > 0 && maxBitRate >= avgBitRate) {
627         msg->setInt32("max-bitrate", maxBitRate);
628     }
629 
630     int32_t isSync;
631     if (meta->findInt32(kKeyIsSyncFrame, &isSync) && isSync != 0) {
632         msg->setInt32("is-sync-frame", 1);
633     }
634 
635     // this only needs to be translated from meta to message as it is an extractor key
636     int32_t trackID;
637     if (meta->findInt32(kKeyTrackID, &trackID)) {
638         msg->setInt32("track-id", trackID);
639     }
640 
641     const char *lang;
642     if (meta->findCString(kKeyMediaLanguage, &lang)) {
643         msg->setString("language", lang);
644     }
645 
646     if (!strncasecmp("video/", mime, 6) ||
647             !strncasecmp("image/", mime, 6)) {
648         int32_t width, height;
649         if (!meta->findInt32(kKeyWidth, &width)
650                 || !meta->findInt32(kKeyHeight, &height)) {
651             return BAD_VALUE;
652         }
653 
654         msg->setInt32("width", width);
655         msg->setInt32("height", height);
656 
657         int32_t displayWidth, displayHeight;
658         if (meta->findInt32(kKeyDisplayWidth, &displayWidth)
659                 && meta->findInt32(kKeyDisplayHeight, &displayHeight)) {
660             msg->setInt32("display-width", displayWidth);
661             msg->setInt32("display-height", displayHeight);
662         }
663 
664         int32_t sarWidth, sarHeight;
665         if (meta->findInt32(kKeySARWidth, &sarWidth)
666                 && meta->findInt32(kKeySARHeight, &sarHeight)) {
667             msg->setInt32("sar-width", sarWidth);
668             msg->setInt32("sar-height", sarHeight);
669         }
670 
671         if (!strncasecmp("image/", mime, 6)) {
672             int32_t tileWidth, tileHeight, gridRows, gridCols;
673             if (meta->findInt32(kKeyTileWidth, &tileWidth)
674                     && meta->findInt32(kKeyTileHeight, &tileHeight)
675                     && meta->findInt32(kKeyGridRows, &gridRows)
676                     && meta->findInt32(kKeyGridCols, &gridCols)) {
677                 msg->setInt32("tile-width", tileWidth);
678                 msg->setInt32("tile-height", tileHeight);
679                 msg->setInt32("grid-rows", gridRows);
680                 msg->setInt32("grid-cols", gridCols);
681             }
682             int32_t isPrimary;
683             if (meta->findInt32(kKeyTrackIsDefault, &isPrimary) && isPrimary) {
684                 msg->setInt32("is-default", 1);
685             }
686         }
687 
688         int32_t colorFormat;
689         if (meta->findInt32(kKeyColorFormat, &colorFormat)) {
690             msg->setInt32("color-format", colorFormat);
691         }
692 
693         int32_t cropLeft, cropTop, cropRight, cropBottom;
694         if (meta->findRect(kKeyCropRect,
695                            &cropLeft,
696                            &cropTop,
697                            &cropRight,
698                            &cropBottom)) {
699             msg->setRect("crop", cropLeft, cropTop, cropRight, cropBottom);
700         }
701 
702         int32_t rotationDegrees;
703         if (meta->findInt32(kKeyRotation, &rotationDegrees)) {
704             msg->setInt32("rotation-degrees", rotationDegrees);
705         }
706 
707         uint32_t type;
708         const void *data;
709         size_t size;
710         if (meta->findData(kKeyHdrStaticInfo, &type, &data, &size)
711                 && type == 'hdrS' && size == sizeof(HDRStaticInfo)) {
712             ColorUtils::setHDRStaticInfoIntoFormat(*(HDRStaticInfo*)data, msg);
713         }
714 
715         convertMetaDataToMessageColorAspects(meta, msg);
716     } else if (!strncasecmp("audio/", mime, 6)) {
717         int32_t numChannels, sampleRate;
718         if (!meta->findInt32(kKeyChannelCount, &numChannels)
719                 || !meta->findInt32(kKeySampleRate, &sampleRate)) {
720             return BAD_VALUE;
721         }
722 
723         msg->setInt32("channel-count", numChannels);
724         msg->setInt32("sample-rate", sampleRate);
725 
726         int32_t channelMask;
727         if (meta->findInt32(kKeyChannelMask, &channelMask)) {
728             msg->setInt32("channel-mask", channelMask);
729         }
730 
731         int32_t delay = 0;
732         if (meta->findInt32(kKeyEncoderDelay, &delay)) {
733             msg->setInt32("encoder-delay", delay);
734         }
735         int32_t padding = 0;
736         if (meta->findInt32(kKeyEncoderPadding, &padding)) {
737             msg->setInt32("encoder-padding", padding);
738         }
739 
740         int32_t isADTS;
741         if (meta->findInt32(kKeyIsADTS, &isADTS)) {
742             msg->setInt32("is-adts", isADTS);
743         }
744 
745         int32_t aacProfile = -1;
746         if (meta->findInt32(kKeyAACAOT, &aacProfile)) {
747             msg->setInt32("aac-profile", aacProfile);
748         }
749 
750         int32_t pcmEncoding;
751         if (meta->findInt32(kKeyPcmEncoding, &pcmEncoding)) {
752             msg->setInt32("pcm-encoding", pcmEncoding);
753         }
754     }
755 
756     int32_t maxInputSize;
757     if (meta->findInt32(kKeyMaxInputSize, &maxInputSize)) {
758         msg->setInt32("max-input-size", maxInputSize);
759     }
760 
761     int32_t maxWidth;
762     if (meta->findInt32(kKeyMaxWidth, &maxWidth)) {
763         msg->setInt32("max-width", maxWidth);
764     }
765 
766     int32_t maxHeight;
767     if (meta->findInt32(kKeyMaxHeight, &maxHeight)) {
768         msg->setInt32("max-height", maxHeight);
769     }
770 
771     int32_t rotationDegrees;
772     if (meta->findInt32(kKeyRotation, &rotationDegrees)) {
773         msg->setInt32("rotation-degrees", rotationDegrees);
774     }
775 
776     int32_t fps;
777     if (meta->findInt32(kKeyFrameRate, &fps) && fps > 0) {
778         msg->setInt32("frame-rate", fps);
779     }
780 
781     if (meta->findData(kKeyAVCC, &type, &data, &size)) {
782         // Parse the AVCDecoderConfigurationRecord
783 
784         const uint8_t *ptr = (const uint8_t *)data;
785 
786         if (size < 7 || ptr[0] != 1) {  // configurationVersion == 1
787             ALOGE("b/23680780");
788             return BAD_VALUE;
789         }
790 
791         parseAvcProfileLevelFromAvcc(ptr, size, msg);
792 
793         // There is decodable content out there that fails the following
794         // assertion, let's be lenient for now...
795         // CHECK((ptr[4] >> 2) == 0x3f);  // reserved
796 
797         size_t lengthSize __unused = 1 + (ptr[4] & 3);
798 
799         // commented out check below as H264_QVGA_500_NO_AUDIO.3gp
800         // violates it...
801         // CHECK((ptr[5] >> 5) == 7);  // reserved
802 
803         size_t numSeqParameterSets = ptr[5] & 31;
804 
805         ptr += 6;
806         size -= 6;
807 
808         sp<ABuffer> buffer = new (std::nothrow) ABuffer(1024);
809         if (buffer.get() == NULL || buffer->base() == NULL) {
810             return NO_MEMORY;
811         }
812         buffer->setRange(0, 0);
813 
814         for (size_t i = 0; i < numSeqParameterSets; ++i) {
815             if (size < 2) {
816                 ALOGE("b/23680780");
817                 return BAD_VALUE;
818             }
819             size_t length = U16_AT(ptr);
820 
821             ptr += 2;
822             size -= 2;
823 
824             if (size < length) {
825                 return BAD_VALUE;
826             }
827             status_t err = copyNALUToABuffer(&buffer, ptr, length);
828             if (err != OK) {
829                 return err;
830             }
831 
832             ptr += length;
833             size -= length;
834         }
835 
836         buffer->meta()->setInt32("csd", true);
837         buffer->meta()->setInt64("timeUs", 0);
838 
839         msg->setBuffer("csd-0", buffer);
840 
841         buffer = new (std::nothrow) ABuffer(1024);
842         if (buffer.get() == NULL || buffer->base() == NULL) {
843             return NO_MEMORY;
844         }
845         buffer->setRange(0, 0);
846 
847         if (size < 1) {
848             ALOGE("b/23680780");
849             return BAD_VALUE;
850         }
851         size_t numPictureParameterSets = *ptr;
852         ++ptr;
853         --size;
854 
855         for (size_t i = 0; i < numPictureParameterSets; ++i) {
856             if (size < 2) {
857                 ALOGE("b/23680780");
858                 return BAD_VALUE;
859             }
860             size_t length = U16_AT(ptr);
861 
862             ptr += 2;
863             size -= 2;
864 
865             if (size < length) {
866                 return BAD_VALUE;
867             }
868             status_t err = copyNALUToABuffer(&buffer, ptr, length);
869             if (err != OK) {
870                 return err;
871             }
872 
873             ptr += length;
874             size -= length;
875         }
876 
877         buffer->meta()->setInt32("csd", true);
878         buffer->meta()->setInt64("timeUs", 0);
879         msg->setBuffer("csd-1", buffer);
880     } else if (meta->findData(kKeyHVCC, &type, &data, &size)) {
881         const uint8_t *ptr = (const uint8_t *)data;
882 
883         if (size < 23 || ptr[0] != 1) {  // configurationVersion == 1
884             ALOGE("b/23680780");
885             return BAD_VALUE;
886         }
887 
888         const size_t dataSize = size; // save for later
889         ptr += 22;
890         size -= 22;
891 
892         size_t numofArrays = (char)ptr[0];
893         ptr += 1;
894         size -= 1;
895         size_t j = 0, i = 0;
896 
897         sp<ABuffer> buffer = new (std::nothrow) ABuffer(1024);
898         if (buffer.get() == NULL || buffer->base() == NULL) {
899             return NO_MEMORY;
900         }
901         buffer->setRange(0, 0);
902 
903         HevcParameterSets hvcc;
904 
905         for (i = 0; i < numofArrays; i++) {
906             if (size < 3) {
907                 ALOGE("b/23680780");
908                 return BAD_VALUE;
909             }
910             ptr += 1;
911             size -= 1;
912 
913             //Num of nals
914             size_t numofNals = U16_AT(ptr);
915 
916             ptr += 2;
917             size -= 2;
918 
919             for (j = 0; j < numofNals; j++) {
920                 if (size < 2) {
921                     ALOGE("b/23680780");
922                     return BAD_VALUE;
923                 }
924                 size_t length = U16_AT(ptr);
925 
926                 ptr += 2;
927                 size -= 2;
928 
929                 if (size < length) {
930                     return BAD_VALUE;
931                 }
932                 status_t err = copyNALUToABuffer(&buffer, ptr, length);
933                 if (err != OK) {
934                     return err;
935                 }
936                 (void)hvcc.addNalUnit(ptr, length);
937 
938                 ptr += length;
939                 size -= length;
940             }
941         }
942         buffer->meta()->setInt32("csd", true);
943         buffer->meta()->setInt64("timeUs", 0);
944         msg->setBuffer("csd-0", buffer);
945 
946         // if we saw VUI color information we know whether this is HDR because VUI trumps other
947         // format parameters for HEVC.
948         HevcParameterSets::Info info = hvcc.getInfo();
949         if (info & hvcc.kInfoHasColorDescription) {
950             msg->setInt32("android._is-hdr", (info & hvcc.kInfoIsHdr) != 0);
951         }
952 
953         parseHevcProfileLevelFromHvcc((const uint8_t *)data, dataSize, msg);
954     } else if (meta->findData(kKeyESDS, &type, &data, &size)) {
955         ESDS esds((const char *)data, size);
956         if (esds.InitCheck() != (status_t)OK) {
957             return BAD_VALUE;
958         }
959 
960         const void *codec_specific_data;
961         size_t codec_specific_data_size;
962         esds.getCodecSpecificInfo(
963                 &codec_specific_data, &codec_specific_data_size);
964 
965         sp<ABuffer> buffer = new (std::nothrow) ABuffer(codec_specific_data_size);
966         if (buffer.get() == NULL || buffer->base() == NULL) {
967             return NO_MEMORY;
968         }
969 
970         memcpy(buffer->data(), codec_specific_data,
971                codec_specific_data_size);
972 
973         buffer->meta()->setInt32("csd", true);
974         buffer->meta()->setInt64("timeUs", 0);
975         msg->setBuffer("csd-0", buffer);
976 
977         if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_MPEG4)) {
978             parseMpeg4ProfileLevelFromCsd(buffer, msg);
979         } else if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_MPEG2)) {
980             parseMpeg2ProfileLevelFromEsds(esds, msg);
981             if (meta->findData(kKeyStreamHeader, &type, &data, &size)) {
982                 parseMpeg2ProfileLevelFromHeader((uint8_t*)data, size, msg);
983             }
984         } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) {
985             parseAacProfileFromCsd(buffer, msg);
986         }
987 
988         uint32_t maxBitrate, avgBitrate;
989         if (esds.getBitRate(&maxBitrate, &avgBitrate) == OK) {
990             if (!meta->hasData(kKeyBitRate)
991                     && avgBitrate > 0 && avgBitrate <= INT32_MAX) {
992                 msg->setInt32("bitrate", (int32_t)avgBitrate);
993             } else {
994                 (void)msg->findInt32("bitrate", (int32_t*)&avgBitrate);
995             }
996             if (!meta->hasData(kKeyMaxBitRate)
997                     && maxBitrate > 0 && maxBitrate <= INT32_MAX && maxBitrate >= avgBitrate) {
998                 msg->setInt32("max-bitrate", (int32_t)maxBitrate);
999             }
1000         }
1001     } else if (meta->findData(kTypeD263, &type, &data, &size)) {
1002         const uint8_t *ptr = (const uint8_t *)data;
1003         parseH263ProfileLevelFromD263(ptr, size, msg);
1004     } else if (meta->findData(kKeyVorbisInfo, &type, &data, &size)) {
1005         sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
1006         if (buffer.get() == NULL || buffer->base() == NULL) {
1007             return NO_MEMORY;
1008         }
1009         memcpy(buffer->data(), data, size);
1010 
1011         buffer->meta()->setInt32("csd", true);
1012         buffer->meta()->setInt64("timeUs", 0);
1013         msg->setBuffer("csd-0", buffer);
1014 
1015         if (!meta->findData(kKeyVorbisBooks, &type, &data, &size)) {
1016             return -EINVAL;
1017         }
1018 
1019         buffer = new (std::nothrow) ABuffer(size);
1020         if (buffer.get() == NULL || buffer->base() == NULL) {
1021             return NO_MEMORY;
1022         }
1023         memcpy(buffer->data(), data, size);
1024 
1025         buffer->meta()->setInt32("csd", true);
1026         buffer->meta()->setInt64("timeUs", 0);
1027         msg->setBuffer("csd-1", buffer);
1028     } else if (meta->findData(kKeyOpusHeader, &type, &data, &size)) {
1029         sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
1030         if (buffer.get() == NULL || buffer->base() == NULL) {
1031             return NO_MEMORY;
1032         }
1033         memcpy(buffer->data(), data, size);
1034 
1035         buffer->meta()->setInt32("csd", true);
1036         buffer->meta()->setInt64("timeUs", 0);
1037         msg->setBuffer("csd-0", buffer);
1038 
1039         if (!meta->findData(kKeyOpusCodecDelay, &type, &data, &size)) {
1040             return -EINVAL;
1041         }
1042 
1043         buffer = new (std::nothrow) ABuffer(size);
1044         if (buffer.get() == NULL || buffer->base() == NULL) {
1045             return NO_MEMORY;
1046         }
1047         memcpy(buffer->data(), data, size);
1048 
1049         buffer->meta()->setInt32("csd", true);
1050         buffer->meta()->setInt64("timeUs", 0);
1051         msg->setBuffer("csd-1", buffer);
1052 
1053         if (!meta->findData(kKeyOpusSeekPreRoll, &type, &data, &size)) {
1054             return -EINVAL;
1055         }
1056 
1057         buffer = new (std::nothrow) ABuffer(size);
1058         if (buffer.get() == NULL || buffer->base() == NULL) {
1059             return NO_MEMORY;
1060         }
1061         memcpy(buffer->data(), data, size);
1062 
1063         buffer->meta()->setInt32("csd", true);
1064         buffer->meta()->setInt64("timeUs", 0);
1065         msg->setBuffer("csd-2", buffer);
1066     } else if (meta->findData(kKeyFlacMetadata, &type, &data, &size)) {
1067         sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
1068         if (buffer.get() == NULL || buffer->base() == NULL) {
1069             return NO_MEMORY;
1070         }
1071         memcpy(buffer->data(), data, size);
1072 
1073         buffer->meta()->setInt32("csd", true);
1074         buffer->meta()->setInt64("timeUs", 0);
1075         msg->setBuffer("csd-0", buffer);
1076     } else if (meta->findData(kKeyVp9CodecPrivate, &type, &data, &size)) {
1077         sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
1078         if (buffer.get() == NULL || buffer->base() == NULL) {
1079             return NO_MEMORY;
1080         }
1081         memcpy(buffer->data(), data, size);
1082 
1083         buffer->meta()->setInt32("csd", true);
1084         buffer->meta()->setInt64("timeUs", 0);
1085         msg->setBuffer("csd-0", buffer);
1086 
1087         parseVp9ProfileLevelFromCsd(buffer, msg);
1088     }
1089 
1090     // TODO expose "crypto-key"/kKeyCryptoKey through public api
1091     if (meta->findData(kKeyCryptoKey, &type, &data, &size)) {
1092         sp<ABuffer> buffer = new (std::nothrow) ABuffer(size);
1093         msg->setBuffer("crypto-key", buffer);
1094         memcpy(buffer->data(), data, size);
1095     }
1096 
1097     *format = msg;
1098 
1099     return OK;
1100 }
1101 
findNextNalStartCode(const uint8_t * data,size_t length)1102 const uint8_t *findNextNalStartCode(const uint8_t *data, size_t length) {
1103     uint8_t *res = NULL;
1104     if (length > 4) {
1105         // minus 1 as to not match NAL start code at end
1106         res = (uint8_t *)memmem(data, length - 1, "\x00\x00\x00\x01", 4);
1107     }
1108     return res != NULL && res < data + length - 4 ? res : &data[length];
1109 }
1110 
reassembleAVCC(const sp<ABuffer> & csd0,const sp<ABuffer> & csd1,char * avcc)1111 static size_t reassembleAVCC(const sp<ABuffer> &csd0, const sp<ABuffer> &csd1, char *avcc) {
1112     avcc[0] = 1;        // version
1113     avcc[1] = 0x64;     // profile (default to high)
1114     avcc[2] = 0;        // constraints (default to none)
1115     avcc[3] = 0xd;      // level (default to 1.3)
1116     avcc[4] = 0xff;     // reserved+size
1117 
1118     size_t i = 0;
1119     int numparams = 0;
1120     int lastparamoffset = 0;
1121     int avccidx = 6;
1122     do {
1123         i = findNextNalStartCode(csd0->data() + i, csd0->size() - i) - csd0->data();
1124         ALOGV("block at %zu, last was %d", i, lastparamoffset);
1125         if (lastparamoffset > 0) {
1126             const uint8_t *lastparam = csd0->data() + lastparamoffset;
1127             int size = i - lastparamoffset;
1128             if (size > 3) {
1129                 if (numparams && memcmp(avcc + 1, lastparam + 1, 3)) {
1130                     ALOGW("Inconsisted profile/level found in SPS: %x,%x,%x vs %x,%x,%x",
1131                             avcc[1], avcc[2], avcc[3], lastparam[1], lastparam[2], lastparam[3]);
1132                 } else if (!numparams) {
1133                     // fill in profile, constraints and level
1134                     memcpy(avcc + 1, lastparam + 1, 3);
1135                 }
1136             }
1137             avcc[avccidx++] = size >> 8;
1138             avcc[avccidx++] = size & 0xff;
1139             memcpy(avcc+avccidx, lastparam, size);
1140             avccidx += size;
1141             numparams++;
1142         }
1143         i += 4;
1144         lastparamoffset = i;
1145     } while(i < csd0->size());
1146     ALOGV("csd0 contains %d params", numparams);
1147 
1148     avcc[5] = 0xe0 | numparams;
1149     //and now csd-1
1150     i = 0;
1151     numparams = 0;
1152     lastparamoffset = 0;
1153     int numpicparamsoffset = avccidx;
1154     avccidx++;
1155     do {
1156         i = findNextNalStartCode(csd1->data() + i, csd1->size() - i) - csd1->data();
1157         ALOGV("block at %zu, last was %d", i, lastparamoffset);
1158         if (lastparamoffset > 0) {
1159             int size = i - lastparamoffset;
1160             avcc[avccidx++] = size >> 8;
1161             avcc[avccidx++] = size & 0xff;
1162             memcpy(avcc+avccidx, csd1->data() + lastparamoffset, size);
1163             avccidx += size;
1164             numparams++;
1165         }
1166         i += 4;
1167         lastparamoffset = i;
1168     } while(i < csd1->size());
1169     avcc[numpicparamsoffset] = numparams;
1170     return avccidx;
1171 }
1172 
reassembleESDS(const sp<ABuffer> & csd0,char * esds)1173 static void reassembleESDS(const sp<ABuffer> &csd0, char *esds) {
1174     int csd0size = csd0->size();
1175     esds[0] = 3; // kTag_ESDescriptor;
1176     int esdescriptorsize = 26 + csd0size;
1177     CHECK(esdescriptorsize < 268435456); // 7 bits per byte, so max is 2^28-1
1178     esds[1] = 0x80 | (esdescriptorsize >> 21);
1179     esds[2] = 0x80 | ((esdescriptorsize >> 14) & 0x7f);
1180     esds[3] = 0x80 | ((esdescriptorsize >> 7) & 0x7f);
1181     esds[4] = (esdescriptorsize & 0x7f);
1182     esds[5] = esds[6] = 0; // es id
1183     esds[7] = 0; // flags
1184     esds[8] = 4; // kTag_DecoderConfigDescriptor
1185     int configdescriptorsize = 18 + csd0size;
1186     esds[9] = 0x80 | (configdescriptorsize >> 21);
1187     esds[10] = 0x80 | ((configdescriptorsize >> 14) & 0x7f);
1188     esds[11] = 0x80 | ((configdescriptorsize >> 7) & 0x7f);
1189     esds[12] = (configdescriptorsize & 0x7f);
1190     esds[13] = 0x40; // objectTypeIndication
1191     // bytes 14-25 are examples from a real file. they are unused/overwritten by muxers.
1192     esds[14] = 0x15; // streamType(5), upStream(0),
1193     esds[15] = 0x00; // 15-17: bufferSizeDB (6KB)
1194     esds[16] = 0x18;
1195     esds[17] = 0x00;
1196     esds[18] = 0x00; // 18-21: maxBitrate (64kbps)
1197     esds[19] = 0x00;
1198     esds[20] = 0xfa;
1199     esds[21] = 0x00;
1200     esds[22] = 0x00; // 22-25: avgBitrate (64kbps)
1201     esds[23] = 0x00;
1202     esds[24] = 0xfa;
1203     esds[25] = 0x00;
1204     esds[26] = 5; // kTag_DecoderSpecificInfo;
1205     esds[27] = 0x80 | (csd0size >> 21);
1206     esds[28] = 0x80 | ((csd0size >> 14) & 0x7f);
1207     esds[29] = 0x80 | ((csd0size >> 7) & 0x7f);
1208     esds[30] = (csd0size & 0x7f);
1209     memcpy((void*)&esds[31], csd0->data(), csd0size);
1210     // data following this is ignored, so don't bother appending it
1211 }
1212 
reassembleHVCC(const sp<ABuffer> & csd0,uint8_t * hvcc,size_t hvccSize,size_t nalSizeLength)1213 static size_t reassembleHVCC(const sp<ABuffer> &csd0, uint8_t *hvcc, size_t hvccSize, size_t nalSizeLength) {
1214     HevcParameterSets paramSets;
1215     uint8_t* data = csd0->data();
1216     if (csd0->size() < 4) {
1217         ALOGE("csd0 too small");
1218         return 0;
1219     }
1220     if (memcmp(data, "\x00\x00\x00\x01", 4) != 0) {
1221         ALOGE("csd0 doesn't start with a start code");
1222         return 0;
1223     }
1224     size_t prevNalOffset = 4;
1225     status_t err = OK;
1226     for (size_t i = 1; i < csd0->size() - 4; ++i) {
1227         if (memcmp(&data[i], "\x00\x00\x00\x01", 4) != 0) {
1228             continue;
1229         }
1230         err = paramSets.addNalUnit(&data[prevNalOffset], i - prevNalOffset);
1231         if (err != OK) {
1232             return 0;
1233         }
1234         prevNalOffset = i + 4;
1235     }
1236     err = paramSets.addNalUnit(&data[prevNalOffset], csd0->size() - prevNalOffset);
1237     if (err != OK) {
1238         return 0;
1239     }
1240     size_t size = hvccSize;
1241     err = paramSets.makeHvcc(hvcc, &size, nalSizeLength);
1242     if (err != OK) {
1243         return 0;
1244     }
1245     return size;
1246 }
1247 
1248 #if 0
1249 static void convertMessageToMetaDataInt32(
1250         const sp<AMessage> &msg, sp<MetaData> &meta, uint32_t key, const char *name) {
1251     int32_t value;
1252     if (msg->findInt32(name, &value)) {
1253         meta->setInt32(key, value);
1254     }
1255 }
1256 #endif
1257 
convertMessageToMetaDataColorAspects(const sp<AMessage> & msg,sp<MetaData> & meta)1258 static void convertMessageToMetaDataColorAspects(const sp<AMessage> &msg, sp<MetaData> &meta) {
1259     // 0 values are unspecified
1260     int32_t range = 0, standard = 0, transfer = 0;
1261     (void)msg->findInt32("color-range", &range);
1262     (void)msg->findInt32("color-standard", &standard);
1263     (void)msg->findInt32("color-transfer", &transfer);
1264 
1265     ColorAspects colorAspects;
1266     memset(&colorAspects, 0, sizeof(colorAspects));
1267     if (CodecBase::convertPlatformColorAspectsToCodecAspects(
1268             range, standard, transfer, colorAspects) != OK) {
1269         return;
1270     }
1271 
1272     // save specified values to meta
1273     if (colorAspects.mRange != 0) {
1274         meta->setInt32(kKeyColorRange, colorAspects.mRange);
1275     }
1276     if (colorAspects.mPrimaries != 0) {
1277         meta->setInt32(kKeyColorPrimaries, colorAspects.mPrimaries);
1278     }
1279     if (colorAspects.mTransfer != 0) {
1280         meta->setInt32(kKeyTransferFunction, colorAspects.mTransfer);
1281     }
1282     if (colorAspects.mMatrixCoeffs != 0) {
1283         meta->setInt32(kKeyColorMatrix, colorAspects.mMatrixCoeffs);
1284     }
1285 }
1286 
convertMessageToMetaData(const sp<AMessage> & msg,sp<MetaData> & meta)1287 void convertMessageToMetaData(const sp<AMessage> &msg, sp<MetaData> &meta) {
1288     AString mime;
1289     if (msg->findString("mime", &mime)) {
1290         meta->setCString(kKeyMIMEType, mime.c_str());
1291     } else {
1292         ALOGW("did not find mime type");
1293     }
1294 
1295     int64_t durationUs;
1296     if (msg->findInt64("durationUs", &durationUs)) {
1297         meta->setInt64(kKeyDuration, durationUs);
1298     }
1299 
1300     int32_t isSync;
1301     if (msg->findInt32("is-sync-frame", &isSync) && isSync != 0) {
1302         meta->setInt32(kKeyIsSyncFrame, 1);
1303     }
1304 
1305     int32_t avgBitrate = 0;
1306     int32_t maxBitrate;
1307     if (msg->findInt32("bitrate", &avgBitrate) && avgBitrate > 0) {
1308         meta->setInt32(kKeyBitRate, avgBitrate);
1309     }
1310     if (msg->findInt32("max-bitrate", &maxBitrate) && maxBitrate > 0 && maxBitrate >= avgBitrate) {
1311         meta->setInt32(kKeyMaxBitRate, maxBitrate);
1312     }
1313 
1314     AString lang;
1315     if (msg->findString("language", &lang)) {
1316         meta->setCString(kKeyMediaLanguage, lang.c_str());
1317     }
1318 
1319     if (mime.startsWith("video/") || mime.startsWith("image/")) {
1320         int32_t width;
1321         int32_t height;
1322         if (msg->findInt32("width", &width) && msg->findInt32("height", &height)) {
1323             meta->setInt32(kKeyWidth, width);
1324             meta->setInt32(kKeyHeight, height);
1325         } else {
1326             ALOGW("did not find width and/or height");
1327         }
1328 
1329         int32_t sarWidth, sarHeight;
1330         if (msg->findInt32("sar-width", &sarWidth)
1331                 && msg->findInt32("sar-height", &sarHeight)) {
1332             meta->setInt32(kKeySARWidth, sarWidth);
1333             meta->setInt32(kKeySARHeight, sarHeight);
1334         }
1335 
1336         int32_t displayWidth, displayHeight;
1337         if (msg->findInt32("display-width", &displayWidth)
1338                 && msg->findInt32("display-height", &displayHeight)) {
1339             meta->setInt32(kKeyDisplayWidth, displayWidth);
1340             meta->setInt32(kKeyDisplayHeight, displayHeight);
1341         }
1342 
1343         if (mime.startsWith("image/")){
1344             int32_t isPrimary;
1345             if (msg->findInt32("is-default", &isPrimary) && isPrimary) {
1346                 meta->setInt32(kKeyTrackIsDefault, 1);
1347             }
1348             int32_t tileWidth, tileHeight, gridRows, gridCols;
1349             if (msg->findInt32("tile-width", &tileWidth)) {
1350                 meta->setInt32(kKeyTileWidth, tileWidth);
1351             }
1352             if (msg->findInt32("tile-height", &tileHeight)) {
1353                 meta->setInt32(kKeyTileHeight, tileHeight);
1354             }
1355             if (msg->findInt32("grid-rows", &gridRows)) {
1356                 meta->setInt32(kKeyGridRows, gridRows);
1357             }
1358             if (msg->findInt32("grid-cols", &gridCols)) {
1359                 meta->setInt32(kKeyGridCols, gridCols);
1360             }
1361         }
1362 
1363         int32_t colorFormat;
1364         if (msg->findInt32("color-format", &colorFormat)) {
1365             meta->setInt32(kKeyColorFormat, colorFormat);
1366         }
1367 
1368         int32_t cropLeft, cropTop, cropRight, cropBottom;
1369         if (msg->findRect("crop",
1370                           &cropLeft,
1371                           &cropTop,
1372                           &cropRight,
1373                           &cropBottom)) {
1374             meta->setRect(kKeyCropRect, cropLeft, cropTop, cropRight, cropBottom);
1375         }
1376 
1377         int32_t rotationDegrees;
1378         if (msg->findInt32("rotation-degrees", &rotationDegrees)) {
1379             meta->setInt32(kKeyRotation, rotationDegrees);
1380         }
1381 
1382         if (msg->contains("hdr-static-info")) {
1383             HDRStaticInfo info;
1384             if (ColorUtils::getHDRStaticInfoFromFormat(msg, &info)) {
1385                 meta->setData(kKeyHdrStaticInfo, 'hdrS', &info, sizeof(info));
1386             }
1387         }
1388 
1389         convertMessageToMetaDataColorAspects(msg, meta);
1390 
1391         AString tsSchema;
1392         if (msg->findString("ts-schema", &tsSchema)) {
1393             unsigned int numLayers = 0;
1394             unsigned int numBLayers = 0;
1395             char dummy;
1396             int tags = sscanf(tsSchema.c_str(), "android.generic.%u%c%u%c",
1397                     &numLayers, &dummy, &numBLayers, &dummy);
1398             if ((tags == 1 || (tags == 3 && dummy == '+'))
1399                     && numLayers > 0 && numLayers < UINT32_MAX - numBLayers
1400                     && numLayers + numBLayers <= INT32_MAX) {
1401                 meta->setInt32(kKeyTemporalLayerCount, numLayers + numBLayers);
1402             }
1403         }
1404     } else if (mime.startsWith("audio/")) {
1405         int32_t numChannels;
1406         if (msg->findInt32("channel-count", &numChannels)) {
1407             meta->setInt32(kKeyChannelCount, numChannels);
1408         }
1409         int32_t sampleRate;
1410         if (msg->findInt32("sample-rate", &sampleRate)) {
1411             meta->setInt32(kKeySampleRate, sampleRate);
1412         }
1413         int32_t channelMask;
1414         if (msg->findInt32("channel-mask", &channelMask)) {
1415             meta->setInt32(kKeyChannelMask, channelMask);
1416         }
1417         int32_t delay = 0;
1418         if (msg->findInt32("encoder-delay", &delay)) {
1419             meta->setInt32(kKeyEncoderDelay, delay);
1420         }
1421         int32_t padding = 0;
1422         if (msg->findInt32("encoder-padding", &padding)) {
1423             meta->setInt32(kKeyEncoderPadding, padding);
1424         }
1425 
1426         int32_t isADTS;
1427         if (msg->findInt32("is-adts", &isADTS)) {
1428             meta->setInt32(kKeyIsADTS, isADTS);
1429         }
1430 
1431         int32_t pcmEncoding;
1432         if (msg->findInt32("pcm-encoding", &pcmEncoding)) {
1433             meta->setInt32(kKeyPcmEncoding, pcmEncoding);
1434         }
1435     }
1436 
1437     int32_t maxInputSize;
1438     if (msg->findInt32("max-input-size", &maxInputSize)) {
1439         meta->setInt32(kKeyMaxInputSize, maxInputSize);
1440     }
1441 
1442     int32_t maxWidth;
1443     if (msg->findInt32("max-width", &maxWidth)) {
1444         meta->setInt32(kKeyMaxWidth, maxWidth);
1445     }
1446 
1447     int32_t maxHeight;
1448     if (msg->findInt32("max-height", &maxHeight)) {
1449         meta->setInt32(kKeyMaxHeight, maxHeight);
1450     }
1451 
1452     int32_t fps;
1453     float fpsFloat;
1454     if (msg->findInt32("frame-rate", &fps) && fps > 0) {
1455         meta->setInt32(kKeyFrameRate, fps);
1456     } else if (msg->findFloat("frame-rate", &fpsFloat)
1457             && fpsFloat >= 1 && fpsFloat <= INT32_MAX) {
1458         // truncate values to distinguish between e.g. 24 vs 23.976 fps
1459         meta->setInt32(kKeyFrameRate, (int32_t)fpsFloat);
1460     }
1461 
1462     // reassemble the csd data into its original form
1463     sp<ABuffer> csd0, csd1, csd2;
1464     if (msg->findBuffer("csd-0", &csd0)) {
1465         int csd0size = csd0->size();
1466         if (mime == MEDIA_MIMETYPE_VIDEO_AVC) {
1467             sp<ABuffer> csd1;
1468             if (msg->findBuffer("csd-1", &csd1)) {
1469                 std::vector<char> avcc(csd0size + csd1->size() + 1024);
1470                 size_t outsize = reassembleAVCC(csd0, csd1, avcc.data());
1471                 meta->setData(kKeyAVCC, kKeyAVCC, avcc.data(), outsize);
1472             }
1473         } else if (mime == MEDIA_MIMETYPE_AUDIO_AAC || mime == MEDIA_MIMETYPE_VIDEO_MPEG4) {
1474             std::vector<char> esds(csd0size + 31);
1475             // The written ESDS is actually for an audio stream, but it's enough
1476             // for transporting the CSD to muxers.
1477             reassembleESDS(csd0, esds.data());
1478             meta->setData(kKeyESDS, kKeyESDS, esds.data(), esds.size());
1479         } else if (mime == MEDIA_MIMETYPE_VIDEO_HEVC ||
1480                    mime == MEDIA_MIMETYPE_IMAGE_ANDROID_HEIC) {
1481             std::vector<uint8_t> hvcc(csd0size + 1024);
1482             size_t outsize = reassembleHVCC(csd0, hvcc.data(), hvcc.size(), 4);
1483             meta->setData(kKeyHVCC, kKeyHVCC, hvcc.data(), outsize);
1484         } else if (mime == MEDIA_MIMETYPE_VIDEO_VP9) {
1485             meta->setData(kKeyVp9CodecPrivate, 0, csd0->data(), csd0->size());
1486         } else if (mime == MEDIA_MIMETYPE_AUDIO_OPUS) {
1487             meta->setData(kKeyOpusHeader, 0, csd0->data(), csd0->size());
1488             if (msg->findBuffer("csd-1", &csd1)) {
1489                 meta->setData(kKeyOpusCodecDelay, 0, csd1->data(), csd1->size());
1490             }
1491             if (msg->findBuffer("csd-2", &csd2)) {
1492                 meta->setData(kKeyOpusSeekPreRoll, 0, csd2->data(), csd2->size());
1493             }
1494         } else if (mime == MEDIA_MIMETYPE_AUDIO_VORBIS) {
1495             meta->setData(kKeyVorbisInfo, 0, csd0->data(), csd0->size());
1496             if (msg->findBuffer("csd-1", &csd1)) {
1497                 meta->setData(kKeyVorbisBooks, 0, csd1->data(), csd1->size());
1498             }
1499         }
1500     }
1501 
1502     int32_t timeScale;
1503     if (msg->findInt32("time-scale", &timeScale)) {
1504         meta->setInt32(kKeyTimeScale, timeScale);
1505     }
1506 
1507     // XXX TODO add whatever other keys there are
1508 
1509 #if 0
1510     ALOGI("converted %s to:", msg->debugString(0).c_str());
1511     meta->dumpToLog();
1512 #endif
1513 }
1514 
MakeUserAgent()1515 AString MakeUserAgent() {
1516     AString ua;
1517     ua.append("stagefright/1.2 (Linux;Android ");
1518 
1519 #if (PROPERTY_VALUE_MAX < 8)
1520 #error "PROPERTY_VALUE_MAX must be at least 8"
1521 #endif
1522 
1523     char value[PROPERTY_VALUE_MAX];
1524     property_get("ro.build.version.release", value, "Unknown");
1525     ua.append(value);
1526     ua.append(")");
1527 
1528     return ua;
1529 }
1530 
sendMetaDataToHal(sp<MediaPlayerBase::AudioSink> & sink,const sp<MetaData> & meta)1531 status_t sendMetaDataToHal(sp<MediaPlayerBase::AudioSink>& sink,
1532                            const sp<MetaData>& meta)
1533 {
1534     int32_t sampleRate = 0;
1535     int32_t bitRate = 0;
1536     int32_t channelMask = 0;
1537     int32_t delaySamples = 0;
1538     int32_t paddingSamples = 0;
1539 
1540     AudioParameter param = AudioParameter();
1541 
1542     if (meta->findInt32(kKeySampleRate, &sampleRate)) {
1543         param.addInt(String8(AUDIO_OFFLOAD_CODEC_SAMPLE_RATE), sampleRate);
1544     }
1545     if (meta->findInt32(kKeyChannelMask, &channelMask)) {
1546         param.addInt(String8(AUDIO_OFFLOAD_CODEC_NUM_CHANNEL), channelMask);
1547     }
1548     if (meta->findInt32(kKeyBitRate, &bitRate)) {
1549         param.addInt(String8(AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE), bitRate);
1550     }
1551     if (meta->findInt32(kKeyEncoderDelay, &delaySamples)) {
1552         param.addInt(String8(AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES), delaySamples);
1553     }
1554     if (meta->findInt32(kKeyEncoderPadding, &paddingSamples)) {
1555         param.addInt(String8(AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES), paddingSamples);
1556     }
1557 
1558     ALOGV("sendMetaDataToHal: bitRate %d, sampleRate %d, chanMask %d,"
1559           "delaySample %d, paddingSample %d", bitRate, sampleRate,
1560           channelMask, delaySamples, paddingSamples);
1561 
1562     sink->setParameters(param.toString());
1563     return OK;
1564 }
1565 
1566 struct mime_conv_t {
1567     const char* mime;
1568     audio_format_t format;
1569 };
1570 
1571 static const struct mime_conv_t mimeLookup[] = {
1572     { MEDIA_MIMETYPE_AUDIO_MPEG,        AUDIO_FORMAT_MP3 },
1573     { MEDIA_MIMETYPE_AUDIO_RAW,         AUDIO_FORMAT_PCM_16_BIT },
1574     { MEDIA_MIMETYPE_AUDIO_AMR_NB,      AUDIO_FORMAT_AMR_NB },
1575     { MEDIA_MIMETYPE_AUDIO_AMR_WB,      AUDIO_FORMAT_AMR_WB },
1576     { MEDIA_MIMETYPE_AUDIO_AAC,         AUDIO_FORMAT_AAC },
1577     { MEDIA_MIMETYPE_AUDIO_VORBIS,      AUDIO_FORMAT_VORBIS },
1578     { MEDIA_MIMETYPE_AUDIO_OPUS,        AUDIO_FORMAT_OPUS},
1579     { MEDIA_MIMETYPE_AUDIO_AC3,         AUDIO_FORMAT_AC3},
1580     { MEDIA_MIMETYPE_AUDIO_FLAC,        AUDIO_FORMAT_FLAC},
1581     { 0, AUDIO_FORMAT_INVALID }
1582 };
1583 
mapMimeToAudioFormat(audio_format_t & format,const char * mime)1584 status_t mapMimeToAudioFormat( audio_format_t& format, const char* mime )
1585 {
1586 const struct mime_conv_t* p = &mimeLookup[0];
1587     while (p->mime != NULL) {
1588         if (0 == strcasecmp(mime, p->mime)) {
1589             format = p->format;
1590             return OK;
1591         }
1592         ++p;
1593     }
1594 
1595     return BAD_VALUE;
1596 }
1597 
1598 struct aac_format_conv_t {
1599     OMX_AUDIO_AACPROFILETYPE eAacProfileType;
1600     audio_format_t format;
1601 };
1602 
1603 static const struct aac_format_conv_t profileLookup[] = {
1604     { OMX_AUDIO_AACObjectMain,        AUDIO_FORMAT_AAC_MAIN},
1605     { OMX_AUDIO_AACObjectLC,          AUDIO_FORMAT_AAC_LC},
1606     { OMX_AUDIO_AACObjectSSR,         AUDIO_FORMAT_AAC_SSR},
1607     { OMX_AUDIO_AACObjectLTP,         AUDIO_FORMAT_AAC_LTP},
1608     { OMX_AUDIO_AACObjectHE,          AUDIO_FORMAT_AAC_HE_V1},
1609     { OMX_AUDIO_AACObjectScalable,    AUDIO_FORMAT_AAC_SCALABLE},
1610     { OMX_AUDIO_AACObjectERLC,        AUDIO_FORMAT_AAC_ERLC},
1611     { OMX_AUDIO_AACObjectLD,          AUDIO_FORMAT_AAC_LD},
1612     { OMX_AUDIO_AACObjectHE_PS,       AUDIO_FORMAT_AAC_HE_V2},
1613     { OMX_AUDIO_AACObjectELD,         AUDIO_FORMAT_AAC_ELD},
1614     { OMX_AUDIO_AACObjectXHE,         AUDIO_FORMAT_AAC_XHE},
1615     { OMX_AUDIO_AACObjectNull,        AUDIO_FORMAT_AAC},
1616 };
1617 
mapAACProfileToAudioFormat(audio_format_t & format,uint64_t eAacProfile)1618 void mapAACProfileToAudioFormat( audio_format_t& format, uint64_t eAacProfile)
1619 {
1620 const struct aac_format_conv_t* p = &profileLookup[0];
1621     while (p->eAacProfileType != OMX_AUDIO_AACObjectNull) {
1622         if (eAacProfile == p->eAacProfileType) {
1623             format = p->format;
1624             return;
1625         }
1626         ++p;
1627     }
1628     format = AUDIO_FORMAT_AAC;
1629     return;
1630 }
1631 
canOffloadStream(const sp<MetaData> & meta,bool hasVideo,bool isStreaming,audio_stream_type_t streamType)1632 bool canOffloadStream(const sp<MetaData>& meta, bool hasVideo,
1633                       bool isStreaming, audio_stream_type_t streamType)
1634 {
1635     const char *mime;
1636     if (meta == NULL) {
1637         return false;
1638     }
1639     CHECK(meta->findCString(kKeyMIMEType, &mime));
1640 
1641     audio_offload_info_t info = AUDIO_INFO_INITIALIZER;
1642 
1643     info.format = AUDIO_FORMAT_INVALID;
1644     if (mapMimeToAudioFormat(info.format, mime) != OK) {
1645         ALOGE(" Couldn't map mime type \"%s\" to a valid AudioSystem::audio_format !", mime);
1646         return false;
1647     } else {
1648         ALOGV("Mime type \"%s\" mapped to audio_format %d", mime, info.format);
1649     }
1650 
1651     if (AUDIO_FORMAT_INVALID == info.format) {
1652         // can't offload if we don't know what the source format is
1653         ALOGE("mime type \"%s\" not a known audio format", mime);
1654         return false;
1655     }
1656 
1657     // Redefine aac format according to its profile
1658     // Offloading depends on audio DSP capabilities.
1659     int32_t aacaot = -1;
1660     if (meta->findInt32(kKeyAACAOT, &aacaot)) {
1661         mapAACProfileToAudioFormat(info.format,(OMX_AUDIO_AACPROFILETYPE) aacaot);
1662     }
1663 
1664     int32_t srate = -1;
1665     if (!meta->findInt32(kKeySampleRate, &srate)) {
1666         ALOGV("track of type '%s' does not publish sample rate", mime);
1667     }
1668     info.sample_rate = srate;
1669 
1670     int32_t cmask = 0;
1671     if (!meta->findInt32(kKeyChannelMask, &cmask)) {
1672         ALOGV("track of type '%s' does not publish channel mask", mime);
1673 
1674         // Try a channel count instead
1675         int32_t channelCount;
1676         if (!meta->findInt32(kKeyChannelCount, &channelCount)) {
1677             ALOGV("track of type '%s' does not publish channel count", mime);
1678         } else {
1679             cmask = audio_channel_out_mask_from_count(channelCount);
1680         }
1681     }
1682     info.channel_mask = cmask;
1683 
1684     int64_t duration = 0;
1685     if (!meta->findInt64(kKeyDuration, &duration)) {
1686         ALOGV("track of type '%s' does not publish duration", mime);
1687     }
1688     info.duration_us = duration;
1689 
1690     int32_t brate = -1;
1691     if (!meta->findInt32(kKeyBitRate, &brate)) {
1692         ALOGV("track of type '%s' does not publish bitrate", mime);
1693     }
1694     info.bit_rate = brate;
1695 
1696 
1697     info.stream_type = streamType;
1698     info.has_video = hasVideo;
1699     info.is_streaming = isStreaming;
1700 
1701     // Check if offload is possible for given format, stream type, sample rate,
1702     // bit rate, duration, video and streaming
1703     return AudioSystem::isOffloadSupported(info);
1704 }
1705 
uriDebugString(const AString & uri,bool incognito)1706 AString uriDebugString(const AString &uri, bool incognito) {
1707     if (incognito) {
1708         return AString("<URI suppressed>");
1709     }
1710 
1711     if (property_get_bool("media.stagefright.log-uri", false)) {
1712         return uri;
1713     }
1714 
1715     // find scheme
1716     AString scheme;
1717     const char *chars = uri.c_str();
1718     for (size_t i = 0; i < uri.size(); i++) {
1719         const char c = chars[i];
1720         if (!isascii(c)) {
1721             break;
1722         } else if (isalpha(c)) {
1723             continue;
1724         } else if (i == 0) {
1725             // first character must be a letter
1726             break;
1727         } else if (isdigit(c) || c == '+' || c == '.' || c =='-') {
1728             continue;
1729         } else if (c != ':') {
1730             break;
1731         }
1732         scheme = AString(uri, 0, i);
1733         scheme.append("://<suppressed>");
1734         return scheme;
1735     }
1736     return AString("<no-scheme URI suppressed>");
1737 }
1738 
HLSTime(const sp<AMessage> & meta)1739 HLSTime::HLSTime(const sp<AMessage>& meta) :
1740     mSeq(-1),
1741     mTimeUs(-1ll),
1742     mMeta(meta) {
1743     if (meta != NULL) {
1744         CHECK(meta->findInt32("discontinuitySeq", &mSeq));
1745         CHECK(meta->findInt64("timeUs", &mTimeUs));
1746     }
1747 }
1748 
getSegmentTimeUs() const1749 int64_t HLSTime::getSegmentTimeUs() const {
1750     int64_t segmentStartTimeUs = -1ll;
1751     if (mMeta != NULL) {
1752         CHECK(mMeta->findInt64("segmentStartTimeUs", &segmentStartTimeUs));
1753 
1754         int64_t segmentFirstTimeUs;
1755         if (mMeta->findInt64("segmentFirstTimeUs", &segmentFirstTimeUs)) {
1756             segmentStartTimeUs += mTimeUs - segmentFirstTimeUs;
1757         }
1758 
1759         // adjust segment time by playlist age (for live streaming)
1760         int64_t playlistTimeUs;
1761         if (mMeta->findInt64("playlistTimeUs", &playlistTimeUs)) {
1762             int64_t playlistAgeUs = ALooper::GetNowUs() - playlistTimeUs;
1763 
1764             int64_t durationUs;
1765             CHECK(mMeta->findInt64("segmentDurationUs", &durationUs));
1766 
1767             // round to nearest whole segment
1768             playlistAgeUs = (playlistAgeUs + durationUs / 2)
1769                     / durationUs * durationUs;
1770 
1771             segmentStartTimeUs -= playlistAgeUs;
1772             if (segmentStartTimeUs < 0) {
1773                 segmentStartTimeUs = 0;
1774             }
1775         }
1776     }
1777     return segmentStartTimeUs;
1778 }
1779 
operator <(const HLSTime & t0,const HLSTime & t1)1780 bool operator <(const HLSTime &t0, const HLSTime &t1) {
1781     // we can only compare discontinuity sequence and timestamp.
1782     // (mSegmentTimeUs is not reliable in live streaming case, it's the
1783     // time starting from beginning of playlist but playlist could change.)
1784     return t0.mSeq < t1.mSeq
1785             || (t0.mSeq == t1.mSeq && t0.mTimeUs < t1.mTimeUs);
1786 }
1787 
writeToAMessage(const sp<AMessage> & msg,const AudioPlaybackRate & rate)1788 void writeToAMessage(const sp<AMessage> &msg, const AudioPlaybackRate &rate) {
1789     msg->setFloat("speed", rate.mSpeed);
1790     msg->setFloat("pitch", rate.mPitch);
1791     msg->setInt32("audio-fallback-mode", rate.mFallbackMode);
1792     msg->setInt32("audio-stretch-mode", rate.mStretchMode);
1793 }
1794 
readFromAMessage(const sp<AMessage> & msg,AudioPlaybackRate * rate)1795 void readFromAMessage(const sp<AMessage> &msg, AudioPlaybackRate *rate /* nonnull */) {
1796     *rate = AUDIO_PLAYBACK_RATE_DEFAULT;
1797     CHECK(msg->findFloat("speed", &rate->mSpeed));
1798     CHECK(msg->findFloat("pitch", &rate->mPitch));
1799     CHECK(msg->findInt32("audio-fallback-mode", (int32_t *)&rate->mFallbackMode));
1800     CHECK(msg->findInt32("audio-stretch-mode", (int32_t *)&rate->mStretchMode));
1801 }
1802 
writeToAMessage(const sp<AMessage> & msg,const AVSyncSettings & sync,float videoFpsHint)1803 void writeToAMessage(const sp<AMessage> &msg, const AVSyncSettings &sync, float videoFpsHint) {
1804     msg->setInt32("sync-source", sync.mSource);
1805     msg->setInt32("audio-adjust-mode", sync.mAudioAdjustMode);
1806     msg->setFloat("tolerance", sync.mTolerance);
1807     msg->setFloat("video-fps", videoFpsHint);
1808 }
1809 
readFromAMessage(const sp<AMessage> & msg,AVSyncSettings * sync,float * videoFps)1810 void readFromAMessage(
1811         const sp<AMessage> &msg,
1812         AVSyncSettings *sync /* nonnull */,
1813         float *videoFps /* nonnull */) {
1814     AVSyncSettings settings;
1815     CHECK(msg->findInt32("sync-source", (int32_t *)&settings.mSource));
1816     CHECK(msg->findInt32("audio-adjust-mode", (int32_t *)&settings.mAudioAdjustMode));
1817     CHECK(msg->findFloat("tolerance", &settings.mTolerance));
1818     CHECK(msg->findFloat("video-fps", videoFps));
1819     *sync = settings;
1820 }
1821 
writeToAMessage(const sp<AMessage> & msg,const BufferingSettings & buffering)1822 void writeToAMessage(const sp<AMessage> &msg, const BufferingSettings &buffering) {
1823     msg->setInt32("init-ms", buffering.mInitialMarkMs);
1824     msg->setInt32("resume-playback-ms", buffering.mResumePlaybackMarkMs);
1825 }
1826 
readFromAMessage(const sp<AMessage> & msg,BufferingSettings * buffering)1827 void readFromAMessage(const sp<AMessage> &msg, BufferingSettings *buffering /* nonnull */) {
1828     int32_t value;
1829     if (msg->findInt32("init-ms", &value)) {
1830         buffering->mInitialMarkMs = value;
1831     }
1832     if (msg->findInt32("resume-playback-ms", &value)) {
1833         buffering->mResumePlaybackMarkMs = value;
1834     }
1835 }
1836 
nameForFd(int fd)1837 AString nameForFd(int fd) {
1838     const size_t SIZE = 256;
1839     char buffer[SIZE];
1840     AString result;
1841     snprintf(buffer, SIZE, "/proc/%d/fd/%d", getpid(), fd);
1842     struct stat s;
1843     if (lstat(buffer, &s) == 0) {
1844         if ((s.st_mode & S_IFMT) == S_IFLNK) {
1845             char linkto[256];
1846             int len = readlink(buffer, linkto, sizeof(linkto));
1847             if(len > 0) {
1848                 if(len > 255) {
1849                     linkto[252] = '.';
1850                     linkto[253] = '.';
1851                     linkto[254] = '.';
1852                     linkto[255] = 0;
1853                 } else {
1854                     linkto[len] = 0;
1855                 }
1856                 result.append(linkto);
1857             }
1858         } else {
1859             result.append("unexpected type for ");
1860             result.append(buffer);
1861         }
1862     } else {
1863         result.append("couldn't open ");
1864         result.append(buffer);
1865     }
1866     return result;
1867 }
1868 
1869 }  // namespace android
1870 
1871