mime_util_unittest.cc 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/base/mime_util.h"
  5. #include <stddef.h>
  6. #include "base/strings/string_split.h"
  7. #include "base/strings/stringprintf.h"
  8. #include "base/test/scoped_command_line.h"
  9. #include "build/build_config.h"
  10. #include "media/base/audio_codecs.h"
  11. #include "media/base/media.h"
  12. #include "media/base/media_switches.h"
  13. #include "media/base/mime_util_internal.h"
  14. #include "media/base/video_codecs.h"
  15. #include "media/base/video_color_space.h"
  16. #include "media/media_buildflags.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. #if BUILDFLAG(IS_ANDROID)
  19. #include "base/android/build_info.h"
  20. #endif
  21. namespace media {
  22. namespace internal {
  23. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  24. // TODO(https://crbug.com/1117275): Remove conditioning of kUsePropCodecs when
  25. // testing *parsing* functions.
  26. const bool kUsePropCodecs = true;
  27. #else
  28. const bool kUsePropCodecs = false;
  29. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  30. // MIME type for use with IsCodecSupportedOnAndroid() test; type is ignored in
  31. // all cases except for when paired with the Opus codec.
  32. const char kTestMimeType[] = "foo/foo";
  33. #if BUILDFLAG(IS_ANDROID) && BUILDFLAG(USE_PROPRIETARY_CODECS)
  34. // HLS is supported on Android API level 14 and higher and Chrome supports
  35. // API levels 15 and higher, so HLS is always supported on Android.
  36. const bool kHlsSupported = true;
  37. #else
  38. const bool kHlsSupported = false;
  39. #endif
  40. // Helper method for creating a multi-value vector of |kTestStates| if
  41. // |test_all_values| is true or if false, a single value vector containing
  42. // |single_value|.
  43. static std::vector<bool> CreateTestVector(bool test_all_values,
  44. bool single_value) {
  45. const bool kTestStates[] = {true, false};
  46. if (test_all_values)
  47. return std::vector<bool>(kTestStates, kTestStates + std::size(kTestStates));
  48. return std::vector<bool>(1, single_value);
  49. }
  50. // Helper method for running IsCodecSupportedOnAndroid() tests that will
  51. // iterate over all possible field values for a MimeUtil::PlatformInfo struct.
  52. //
  53. // To request a field be varied, set its value to true in the |states_to_vary|
  54. // struct. If false, the only value tested will be the field value from
  55. // |test_states|.
  56. //
  57. // |test_func| should have the signature <void(const MimeUtil::PlatformInfo&,
  58. // MimeUtil::Codec)>.
  59. template <typename TestCallback>
  60. static void RunCodecSupportTest(const MimeUtil::PlatformInfo& states_to_vary,
  61. const MimeUtil::PlatformInfo& test_states,
  62. TestCallback test_func) {
  63. #define MAKE_TEST_VECTOR(name) \
  64. std::vector<bool> name##_states = \
  65. CreateTestVector(states_to_vary.name, test_states.name)
  66. // Stuff states to test into vectors for easy for_each() iteration.
  67. MAKE_TEST_VECTOR(has_platform_vp8_decoder);
  68. MAKE_TEST_VECTOR(has_platform_vp9_decoder);
  69. MAKE_TEST_VECTOR(has_platform_opus_decoder);
  70. #undef MAKE_TEST_VECTOR
  71. MimeUtil::PlatformInfo info;
  72. #define RUN_TEST_VECTOR_BEGIN(name) \
  73. for (size_t name##_index = 0; name##_index < name##_states.size(); \
  74. ++name##_index) { \
  75. info.name = name##_states[name##_index];
  76. #define RUN_TEST_VECTOR_END() }
  77. RUN_TEST_VECTOR_BEGIN(has_platform_vp8_decoder)
  78. RUN_TEST_VECTOR_BEGIN(has_platform_vp9_decoder)
  79. RUN_TEST_VECTOR_BEGIN(has_platform_opus_decoder)
  80. for (int codec = MimeUtil::INVALID_CODEC; codec <= MimeUtil::LAST_CODEC;
  81. ++codec) {
  82. SCOPED_TRACE(base::StringPrintf(
  83. "has_platform_vp8_decoder=%d, "
  84. "has_platform_opus_decoder=%d, "
  85. "has_platform_vp9_decoder=%d, "
  86. "codec=%d",
  87. info.has_platform_vp8_decoder, info.has_platform_opus_decoder,
  88. info.has_platform_vp9_decoder, codec));
  89. test_func(info, static_cast<MimeUtil::Codec>(codec));
  90. }
  91. RUN_TEST_VECTOR_END()
  92. RUN_TEST_VECTOR_END()
  93. RUN_TEST_VECTOR_END()
  94. #undef RUN_TEST_VECTOR_BEGIN
  95. #undef RUN_TEST_VECTOR_END
  96. }
  97. // Helper method for generating the |states_to_vary| value used by
  98. // RunPlatformCodecTest(). Marks all fields to be varied.
  99. static MimeUtil::PlatformInfo VaryAllFields() {
  100. MimeUtil::PlatformInfo states_to_vary;
  101. states_to_vary.has_platform_vp8_decoder = true;
  102. states_to_vary.has_platform_vp9_decoder = true;
  103. states_to_vary.has_platform_opus_decoder = true;
  104. return states_to_vary;
  105. }
  106. // This is to validate MimeUtil::IsCodecSupportedOnPlatform(), which is used
  107. // only on Android platform.
  108. static bool HasDolbyVisionSupport() {
  109. return false;
  110. }
  111. static bool HasEac3Support() {
  112. #if BUILDFLAG(ENABLE_PLATFORM_AC3_EAC3_AUDIO)
  113. return true;
  114. #else
  115. return false;
  116. #endif
  117. }
  118. TEST(MimeUtilTest, CommonMediaMimeType) {
  119. EXPECT_TRUE(IsSupportedMediaMimeType("audio/webm"));
  120. EXPECT_TRUE(IsSupportedMediaMimeType("video/webm"));
  121. EXPECT_TRUE(IsSupportedMediaMimeType("audio/wav"));
  122. EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-wav"));
  123. EXPECT_TRUE(IsSupportedMediaMimeType("audio/flac"));
  124. EXPECT_TRUE(IsSupportedMediaMimeType("audio/ogg"));
  125. EXPECT_TRUE(IsSupportedMediaMimeType("application/ogg"));
  126. EXPECT_TRUE(IsSupportedMediaMimeType("video/ogg"));
  127. EXPECT_EQ(kHlsSupported, IsSupportedMediaMimeType("application/x-mpegurl"));
  128. EXPECT_EQ(kHlsSupported, IsSupportedMediaMimeType("Application/X-MPEGURL"));
  129. EXPECT_EQ(kHlsSupported, IsSupportedMediaMimeType(
  130. "application/vnd.apple.mpegurl"));
  131. EXPECT_EQ(kHlsSupported, IsSupportedMediaMimeType("audio/mpegurl"));
  132. EXPECT_EQ(kHlsSupported, IsSupportedMediaMimeType("audio/x-mpegurl"));
  133. EXPECT_TRUE(IsSupportedMediaMimeType("audio/mp4"));
  134. EXPECT_TRUE(IsSupportedMediaMimeType("audio/mp3"));
  135. EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-mp3"));
  136. EXPECT_TRUE(IsSupportedMediaMimeType("audio/mpeg"));
  137. EXPECT_TRUE(IsSupportedMediaMimeType("video/mp4"));
  138. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  139. EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-m4a"));
  140. EXPECT_TRUE(IsSupportedMediaMimeType("video/x-m4v"));
  141. EXPECT_TRUE(IsSupportedMediaMimeType("audio/aac"));
  142. EXPECT_TRUE(IsSupportedMediaMimeType("video/3gpp"));
  143. #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
  144. EXPECT_TRUE(IsSupportedMediaMimeType("video/mp2t"));
  145. #else
  146. EXPECT_FALSE(IsSupportedMediaMimeType("video/mp2t"));
  147. #endif // BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
  148. #else
  149. EXPECT_FALSE(IsSupportedMediaMimeType("audio/x-m4a"));
  150. EXPECT_FALSE(IsSupportedMediaMimeType("video/x-m4v"));
  151. EXPECT_FALSE(IsSupportedMediaMimeType("audio/aac"));
  152. EXPECT_FALSE(IsSupportedMediaMimeType("video/3gpp"));
  153. #endif // USE_PROPRIETARY_CODECS
  154. EXPECT_FALSE(IsSupportedMediaMimeType("video/mp3"));
  155. EXPECT_FALSE(IsSupportedMediaMimeType("video/unknown"));
  156. EXPECT_FALSE(IsSupportedMediaMimeType("audio/unknown"));
  157. EXPECT_FALSE(IsSupportedMediaMimeType("unknown/unknown"));
  158. }
  159. // Note: codecs should only be a list of 2 or fewer; hence the restriction of
  160. // results' length to 2.
  161. TEST(MimeUtilTest, SplitAndStripCodecs) {
  162. const struct {
  163. const char* const original;
  164. size_t expected_size;
  165. const char* const split_results[2];
  166. const char* const strip_results[2];
  167. } tests[] = {
  168. {"\"bogus\"", 1, {"bogus"}, {"bogus"}},
  169. {"0", 1, {"0"}, {"0"}},
  170. {"avc1.42E01E, mp4a.40.2",
  171. 2,
  172. {"avc1.42E01E", "mp4a.40.2"},
  173. {"avc1", "mp4a"}},
  174. {"\"mp4v.20.240, mp4a.40.2\"",
  175. 2,
  176. {"mp4v.20.240", "mp4a.40.2"},
  177. {"mp4v", "mp4a"}},
  178. {"mp4v.20.8, samr", 2, {"mp4v.20.8", "samr"}, {"mp4v", "samr"}},
  179. {"\"theora, vorbis\"", 2, {"theora", "vorbis"}, {"theora", "vorbis"}},
  180. {"", 0, {}, {}},
  181. {"\"\"", 0, {}, {}},
  182. {"\" \"", 0, {}, {}},
  183. {",", 2, {"", ""}, {"", ""}},
  184. };
  185. for (size_t i = 0; i < std::size(tests); ++i) {
  186. std::vector<std::string> codecs_out;
  187. SplitCodecs(tests[i].original, &codecs_out);
  188. ASSERT_EQ(tests[i].expected_size, codecs_out.size());
  189. for (size_t j = 0; j < tests[i].expected_size; ++j)
  190. EXPECT_EQ(tests[i].split_results[j], codecs_out[j]);
  191. StripCodecs(&codecs_out);
  192. ASSERT_EQ(tests[i].expected_size, codecs_out.size());
  193. for (size_t j = 0; j < tests[i].expected_size; ++j)
  194. EXPECT_EQ(tests[i].strip_results[j], codecs_out[j]);
  195. }
  196. }
  197. // Basic smoke test for API. More exhaustive codec string testing found in
  198. // media_canplaytype_browsertest.cc.
  199. TEST(MimeUtilTest, ParseVideoCodecString) {
  200. bool out_is_ambiguous;
  201. VideoCodec out_codec;
  202. VideoCodecProfile out_profile;
  203. uint8_t out_level;
  204. VideoColorSpace out_colorspace;
  205. // Valid AVC string whenever proprietary codecs are supported.
  206. EXPECT_EQ(kUsePropCodecs,
  207. ParseVideoCodecString("video/mp4", "avc3.42E01E", &out_is_ambiguous,
  208. &out_codec, &out_profile, &out_level,
  209. &out_colorspace));
  210. if (kUsePropCodecs) {
  211. EXPECT_FALSE(out_is_ambiguous);
  212. EXPECT_EQ(VideoCodec::kH264, out_codec);
  213. EXPECT_EQ(H264PROFILE_BASELINE, out_profile);
  214. EXPECT_EQ(30, out_level);
  215. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  216. }
  217. // Valid VP9 string.
  218. EXPECT_TRUE(ParseVideoCodecString("video/webm", "vp09.00.10.08",
  219. &out_is_ambiguous, &out_codec, &out_profile,
  220. &out_level, &out_colorspace));
  221. EXPECT_FALSE(out_is_ambiguous);
  222. EXPECT_EQ(VideoCodec::kVP9, out_codec);
  223. EXPECT_EQ(VP9PROFILE_PROFILE0, out_profile);
  224. EXPECT_EQ(10, out_level);
  225. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  226. // Valid VP9 string with REC601 color space.
  227. EXPECT_TRUE(ParseVideoCodecString("video/webm", "vp09.02.10.10.01.06.06.06",
  228. &out_is_ambiguous, &out_codec, &out_profile,
  229. &out_level, &out_colorspace));
  230. EXPECT_FALSE(out_is_ambiguous);
  231. EXPECT_EQ(VideoCodec::kVP9, out_codec);
  232. EXPECT_EQ(VP9PROFILE_PROFILE2, out_profile);
  233. EXPECT_EQ(10, out_level);
  234. EXPECT_EQ(VideoColorSpace::REC601(), out_colorspace);
  235. // Ambiguous AVC string (when proprietary codecs are supported).
  236. EXPECT_EQ(
  237. kUsePropCodecs,
  238. ParseVideoCodecString("video/mp4", "avc3", &out_is_ambiguous, &out_codec,
  239. &out_profile, &out_level, &out_colorspace));
  240. if (kUsePropCodecs) {
  241. EXPECT_TRUE(out_is_ambiguous);
  242. EXPECT_EQ(VideoCodec::kH264, out_codec);
  243. EXPECT_EQ(VIDEO_CODEC_PROFILE_UNKNOWN, out_profile);
  244. EXPECT_EQ(0, out_level);
  245. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  246. }
  247. // Audio codecs codec is not valid for video API.
  248. EXPECT_FALSE(ParseVideoCodecString("video/webm", "opus", &out_is_ambiguous,
  249. &out_codec, &out_profile, &out_level,
  250. &out_colorspace));
  251. // Made up codec is invalid.
  252. EXPECT_FALSE(ParseVideoCodecString("video/webm", "bogus", &out_is_ambiguous,
  253. &out_codec, &out_profile, &out_level,
  254. &out_colorspace));
  255. }
  256. // Basic smoke test for API. More exhaustive codec string testing found in
  257. // media_canplaytype_browsertest.cc.
  258. TEST(MimeUtilTest, ParseVideoCodecString_NoMimeType) {
  259. bool out_is_ambiguous;
  260. VideoCodec out_codec;
  261. VideoCodecProfile out_profile;
  262. uint8_t out_level;
  263. VideoColorSpace out_colorspace;
  264. // Invalid to give empty codec without a mime type.
  265. EXPECT_FALSE(ParseVideoCodecString("", "", &out_is_ambiguous, &out_codec,
  266. &out_profile, &out_level,
  267. &out_colorspace));
  268. // Valid AVC string whenever proprietary codecs are supported.
  269. EXPECT_TRUE(ParseVideoCodecString("", "avc3.42E01E", &out_is_ambiguous,
  270. &out_codec, &out_profile, &out_level,
  271. &out_colorspace));
  272. EXPECT_FALSE(out_is_ambiguous);
  273. EXPECT_EQ(VideoCodec::kH264, out_codec);
  274. EXPECT_EQ(H264PROFILE_BASELINE, out_profile);
  275. EXPECT_EQ(30, out_level);
  276. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  277. // Valid VP9 string.
  278. EXPECT_TRUE(ParseVideoCodecString("", "vp09.00.10.08", &out_is_ambiguous,
  279. &out_codec, &out_profile, &out_level,
  280. &out_colorspace));
  281. EXPECT_FALSE(out_is_ambiguous);
  282. EXPECT_EQ(VideoCodec::kVP9, out_codec);
  283. EXPECT_EQ(VP9PROFILE_PROFILE0, out_profile);
  284. EXPECT_EQ(10, out_level);
  285. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  286. EXPECT_TRUE(ParseVideoCodecString("", "vp09.02.10.10.01.06.06.06",
  287. &out_is_ambiguous, &out_codec, &out_profile,
  288. &out_level, &out_colorspace));
  289. EXPECT_FALSE(out_is_ambiguous);
  290. EXPECT_EQ(VideoCodec::kVP9, out_codec);
  291. EXPECT_EQ(VP9PROFILE_PROFILE2, out_profile);
  292. EXPECT_EQ(10, out_level);
  293. EXPECT_EQ(VideoColorSpace::REC601(), out_colorspace);
  294. // Ambiguous AVC string (when proprietary codecs are supported).
  295. EXPECT_TRUE(ParseVideoCodecString("", "avc3", &out_is_ambiguous, &out_codec,
  296. &out_profile, &out_level, &out_colorspace));
  297. EXPECT_TRUE(out_is_ambiguous);
  298. EXPECT_EQ(VideoCodec::kH264, out_codec);
  299. EXPECT_EQ(VIDEO_CODEC_PROFILE_UNKNOWN, out_profile);
  300. EXPECT_EQ(0, out_level);
  301. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  302. // Audio codecs codec is not valid for video API.
  303. EXPECT_FALSE(ParseVideoCodecString("", "opus", &out_is_ambiguous, &out_codec,
  304. &out_profile, &out_level,
  305. &out_colorspace));
  306. // Made up codec is invalid.
  307. EXPECT_FALSE(ParseVideoCodecString("", "bogus", &out_is_ambiguous, &out_codec,
  308. &out_profile, &out_level,
  309. &out_colorspace));
  310. }
  311. TEST(MimeUtilTest, ParseAudioCodecString) {
  312. bool out_is_ambiguous;
  313. AudioCodec out_codec;
  314. // Valid Opus string.
  315. EXPECT_TRUE(ParseAudioCodecString("audio/webm", "opus", &out_is_ambiguous,
  316. &out_codec));
  317. EXPECT_FALSE(out_is_ambiguous);
  318. EXPECT_EQ(AudioCodec::kOpus, out_codec);
  319. // Valid AAC string when proprietary codecs are supported.
  320. EXPECT_EQ(kUsePropCodecs,
  321. ParseAudioCodecString("audio/mp4", "mp4a.40.2", &out_is_ambiguous,
  322. &out_codec));
  323. if (kUsePropCodecs) {
  324. EXPECT_FALSE(out_is_ambiguous);
  325. EXPECT_EQ(AudioCodec::kAAC, out_codec);
  326. }
  327. // Valid FLAC string with MP4. Neither decoding nor demuxing is proprietary.
  328. EXPECT_TRUE(ParseAudioCodecString("audio/mp4", "flac", &out_is_ambiguous,
  329. &out_codec));
  330. EXPECT_FALSE(out_is_ambiguous);
  331. EXPECT_EQ(AudioCodec::kFLAC, out_codec);
  332. // Ambiguous AAC string.
  333. // TODO(chcunningha): This can probably be allowed. I think we treat all
  334. // MPEG4_AAC the same.
  335. EXPECT_EQ(kUsePropCodecs,
  336. ParseAudioCodecString("audio/mp4", "mp4a.40", &out_is_ambiguous,
  337. &out_codec));
  338. if (kUsePropCodecs) {
  339. EXPECT_TRUE(out_is_ambiguous);
  340. EXPECT_EQ(AudioCodec::kAAC, out_codec);
  341. }
  342. // Valid empty codec string. Codec unambiguously implied by mime type.
  343. EXPECT_TRUE(
  344. ParseAudioCodecString("audio/flac", "", &out_is_ambiguous, &out_codec));
  345. EXPECT_FALSE(out_is_ambiguous);
  346. EXPECT_EQ(AudioCodec::kFLAC, out_codec);
  347. // Valid audio codec should still be allowed with video mime type.
  348. EXPECT_TRUE(ParseAudioCodecString("video/webm", "opus", &out_is_ambiguous,
  349. &out_codec));
  350. EXPECT_FALSE(out_is_ambiguous);
  351. EXPECT_EQ(AudioCodec::kOpus, out_codec);
  352. // Video codec is not valid for audio API.
  353. EXPECT_FALSE(ParseAudioCodecString("audio/webm", "vp09.00.10.08",
  354. &out_is_ambiguous, &out_codec));
  355. // Made up codec is also not valid.
  356. EXPECT_FALSE(ParseAudioCodecString("audio/webm", "bogus", &out_is_ambiguous,
  357. &out_codec));
  358. }
  359. TEST(MimeUtilTest, ParseAudioCodecString_NoMimeType) {
  360. bool out_is_ambiguous;
  361. AudioCodec out_codec;
  362. // Invalid to give empty codec without a mime type.
  363. EXPECT_FALSE(ParseAudioCodecString("", "", &out_is_ambiguous, &out_codec));
  364. // Valid Opus string.
  365. EXPECT_TRUE(ParseAudioCodecString("", "opus", &out_is_ambiguous, &out_codec));
  366. EXPECT_FALSE(out_is_ambiguous);
  367. EXPECT_EQ(AudioCodec::kOpus, out_codec);
  368. // Valid AAC string when proprietary codecs are supported.
  369. EXPECT_TRUE(
  370. ParseAudioCodecString("", "mp4a.40.2", &out_is_ambiguous, &out_codec));
  371. EXPECT_FALSE(out_is_ambiguous);
  372. EXPECT_EQ(AudioCodec::kAAC, out_codec);
  373. // Valid FLAC string. Neither decoding nor demuxing is proprietary.
  374. EXPECT_TRUE(ParseAudioCodecString("", "flac", &out_is_ambiguous, &out_codec));
  375. EXPECT_FALSE(out_is_ambiguous);
  376. EXPECT_EQ(AudioCodec::kFLAC, out_codec);
  377. // Ambiguous AAC string.
  378. // TODO(chcunningha): This can probably be allowed. I think we treat all
  379. // MPEG4_AAC the same.
  380. EXPECT_TRUE(
  381. ParseAudioCodecString("", "mp4a.40", &out_is_ambiguous, &out_codec));
  382. if (kUsePropCodecs) {
  383. EXPECT_TRUE(out_is_ambiguous);
  384. EXPECT_EQ(AudioCodec::kAAC, out_codec);
  385. }
  386. // Video codec is not valid for audio API.
  387. EXPECT_FALSE(ParseAudioCodecString("", "vp09.00.10.08", &out_is_ambiguous,
  388. &out_codec));
  389. // Made up codec is also not valid.
  390. EXPECT_FALSE(
  391. ParseAudioCodecString("", "bogus", &out_is_ambiguous, &out_codec));
  392. }
  393. // MP3 is a weird case where we allow either the mime type, codec string, or
  394. // both, and there are several valid codec strings.
  395. TEST(MimeUtilTest, ParseAudioCodecString_Mp3) {
  396. bool out_is_ambiguous;
  397. AudioCodec out_codec;
  398. EXPECT_TRUE(ParseAudioCodecString("audio/mpeg", "mp3", &out_is_ambiguous,
  399. &out_codec));
  400. EXPECT_FALSE(out_is_ambiguous);
  401. EXPECT_EQ(AudioCodec::kMP3, out_codec);
  402. EXPECT_TRUE(
  403. ParseAudioCodecString("audio/mpeg", "", &out_is_ambiguous, &out_codec));
  404. EXPECT_FALSE(out_is_ambiguous);
  405. EXPECT_EQ(AudioCodec::kMP3, out_codec);
  406. EXPECT_TRUE(ParseAudioCodecString("", "mp3", &out_is_ambiguous, &out_codec));
  407. EXPECT_FALSE(out_is_ambiguous);
  408. EXPECT_EQ(AudioCodec::kMP3, out_codec);
  409. EXPECT_TRUE(
  410. ParseAudioCodecString("", "mp4a.69", &out_is_ambiguous, &out_codec));
  411. EXPECT_FALSE(out_is_ambiguous);
  412. EXPECT_EQ(AudioCodec::kMP3, out_codec);
  413. EXPECT_TRUE(
  414. ParseAudioCodecString("", "mp4a.6B", &out_is_ambiguous, &out_codec));
  415. EXPECT_FALSE(out_is_ambiguous);
  416. EXPECT_EQ(AudioCodec::kMP3, out_codec);
  417. }
  418. // These codecs really only have one profile. Ensure that |out_profile| is
  419. // correctly mapped.
  420. TEST(MimeUtilTest, ParseVideoCodecString_SimpleCodecsHaveProfiles) {
  421. bool out_is_ambiguous;
  422. VideoCodec out_codec;
  423. VideoCodecProfile out_profile;
  424. uint8_t out_level;
  425. VideoColorSpace out_colorspace;
  426. // Valid VP8 string.
  427. EXPECT_TRUE(ParseVideoCodecString("video/webm", "vp8", &out_is_ambiguous,
  428. &out_codec, &out_profile, &out_level,
  429. &out_colorspace));
  430. EXPECT_FALSE(out_is_ambiguous);
  431. EXPECT_EQ(VideoCodec::kVP8, out_codec);
  432. EXPECT_EQ(VP8PROFILE_ANY, out_profile);
  433. EXPECT_EQ(0, out_level);
  434. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  435. // Valid Theora string.
  436. #if BUILDFLAG(IS_ANDROID)
  437. // Theora not supported on Android.
  438. EXPECT_FALSE(ParseVideoCodecString("video/ogg", "theora", &out_is_ambiguous,
  439. &out_codec, &out_profile, &out_level,
  440. &out_colorspace));
  441. #else
  442. EXPECT_TRUE(ParseVideoCodecString("video/ogg", "theora", &out_is_ambiguous,
  443. &out_codec, &out_profile, &out_level,
  444. &out_colorspace));
  445. EXPECT_FALSE(out_is_ambiguous);
  446. EXPECT_EQ(VideoCodec::kTheora, out_codec);
  447. EXPECT_EQ(THEORAPROFILE_ANY, out_profile);
  448. EXPECT_EQ(0, out_level);
  449. EXPECT_EQ(VideoColorSpace::REC709(), out_colorspace);
  450. #endif
  451. }
  452. TEST(IsCodecSupportedOnAndroidTest, EncryptedCodecBehavior) {
  453. // Vary all parameters.
  454. MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
  455. MimeUtil::PlatformInfo test_states;
  456. RunCodecSupportTest(
  457. states_to_vary, test_states,
  458. [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
  459. const bool result = MimeUtil::IsCodecSupportedOnAndroid(
  460. codec, kTestMimeType, true, VIDEO_CODEC_PROFILE_UNKNOWN, info);
  461. switch (codec) {
  462. // These codecs are never supported by the Android platform.
  463. case MimeUtil::INVALID_CODEC:
  464. case MimeUtil::MPEG_H_AUDIO:
  465. case MimeUtil::THEORA:
  466. EXPECT_FALSE(result);
  467. break;
  468. // These codecs are always available with platform decoder support.
  469. case MimeUtil::PCM:
  470. case MimeUtil::MP3:
  471. case MimeUtil::MPEG2_AAC:
  472. case MimeUtil::MPEG4_AAC:
  473. case MimeUtil::MPEG4_XHE_AAC:
  474. case MimeUtil::VORBIS:
  475. case MimeUtil::FLAC:
  476. case MimeUtil::H264:
  477. EXPECT_TRUE(result);
  478. break;
  479. // The remaining codecs are not available on all platforms even when
  480. // a platform decoder is available.
  481. case MimeUtil::OPUS:
  482. EXPECT_EQ(info.has_platform_opus_decoder, result);
  483. break;
  484. case MimeUtil::VP8:
  485. EXPECT_EQ(info.has_platform_vp8_decoder, result);
  486. break;
  487. case MimeUtil::VP9:
  488. EXPECT_EQ(info.has_platform_vp9_decoder, result);
  489. break;
  490. case MimeUtil::HEVC:
  491. #if BUILDFLAG(ENABLE_PLATFORM_HEVC)
  492. EXPECT_EQ(info.has_platform_hevc_decoder, result);
  493. #else
  494. EXPECT_FALSE(result);
  495. #endif
  496. break;
  497. case MimeUtil::DOLBY_VISION:
  498. EXPECT_EQ(HasDolbyVisionSupport(), result);
  499. break;
  500. case MimeUtil::AC3:
  501. case MimeUtil::EAC3:
  502. EXPECT_EQ(HasEac3Support(), result);
  503. break;
  504. case MimeUtil::AV1:
  505. EXPECT_EQ(BUILDFLAG(ENABLE_AV1_DECODER), result);
  506. break;
  507. case MimeUtil::DTS:
  508. case MimeUtil::DTSXP2:
  509. EXPECT_EQ(BUILDFLAG(ENABLE_PLATFORM_DTS_AUDIO), result);
  510. break;
  511. }
  512. });
  513. }
  514. TEST(IsCodecSupportedOnAndroidTest, ClearCodecBehavior) {
  515. MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
  516. MimeUtil::PlatformInfo test_states;
  517. RunCodecSupportTest(
  518. states_to_vary, test_states,
  519. [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
  520. const bool result = MimeUtil::IsCodecSupportedOnAndroid(
  521. codec, kTestMimeType, false, VIDEO_CODEC_PROFILE_UNKNOWN, info);
  522. switch (codec) {
  523. // These codecs are never supported by the Android platform.
  524. case MimeUtil::INVALID_CODEC:
  525. case MimeUtil::MPEG_H_AUDIO:
  526. case MimeUtil::THEORA:
  527. EXPECT_FALSE(result);
  528. break;
  529. // These codecs are always supported with the unified pipeline.
  530. case MimeUtil::FLAC:
  531. case MimeUtil::H264:
  532. case MimeUtil::PCM:
  533. case MimeUtil::MP3:
  534. case MimeUtil::MPEG2_AAC:
  535. case MimeUtil::MPEG4_AAC:
  536. case MimeUtil::OPUS:
  537. case MimeUtil::VORBIS:
  538. case MimeUtil::VP8:
  539. case MimeUtil::VP9:
  540. EXPECT_TRUE(result);
  541. break;
  542. // These codecs are only supported if platform decoders are supported.
  543. case MimeUtil::MPEG4_XHE_AAC:
  544. EXPECT_TRUE(result);
  545. break;
  546. case MimeUtil::HEVC:
  547. #if BUILDFLAG(ENABLE_PLATFORM_HEVC)
  548. EXPECT_EQ(info.has_platform_hevc_decoder, result);
  549. #else
  550. EXPECT_FALSE(result);
  551. #endif
  552. break;
  553. case MimeUtil::DOLBY_VISION:
  554. EXPECT_EQ(HasDolbyVisionSupport(), result);
  555. break;
  556. case MimeUtil::AC3:
  557. case MimeUtil::EAC3:
  558. EXPECT_EQ(HasEac3Support(), result);
  559. break;
  560. case MimeUtil::AV1:
  561. EXPECT_EQ(BUILDFLAG(ENABLE_AV1_DECODER), result);
  562. break;
  563. case MimeUtil::DTS:
  564. case MimeUtil::DTSXP2:
  565. EXPECT_EQ(BUILDFLAG(ENABLE_PLATFORM_DTS_AUDIO), result);
  566. break;
  567. }
  568. });
  569. }
  570. TEST(IsCodecSupportedOnAndroidTest, OpusOggSupport) {
  571. // Vary all parameters; thus use default initial state.
  572. MimeUtil::PlatformInfo states_to_vary = VaryAllFields();
  573. MimeUtil::PlatformInfo test_states;
  574. RunCodecSupportTest(
  575. states_to_vary, test_states,
  576. [](const MimeUtil::PlatformInfo& info, MimeUtil::Codec codec) {
  577. EXPECT_TRUE(MimeUtil::IsCodecSupportedOnAndroid(
  578. MimeUtil::OPUS, "audio/ogg", false, VIDEO_CODEC_PROFILE_UNKNOWN,
  579. info));
  580. });
  581. }
  582. #if BUILDFLAG(ENABLE_PLATFORM_HEVC)
  583. TEST(IsCodecSupportedOnAndroidTest, HEVCSupport) {
  584. MimeUtil::PlatformInfo info;
  585. info.has_platform_hevc_decoder = false;
  586. EXPECT_FALSE(MimeUtil::IsCodecSupportedOnAndroid(
  587. MimeUtil::HEVC, kTestMimeType, false, VIDEO_CODEC_PROFILE_UNKNOWN, info));
  588. info.has_platform_hevc_decoder = true;
  589. EXPECT_TRUE(MimeUtil::IsCodecSupportedOnAndroid(
  590. MimeUtil::HEVC, kTestMimeType, false, VIDEO_CODEC_PROFILE_UNKNOWN, info));
  591. }
  592. #endif
  593. TEST(IsCodecSupportedOnAndroidTest, AndroidHLSAAC) {
  594. const std::string hls_mime_types[] = {"application/x-mpegurl",
  595. "application/vnd.apple.mpegurl",
  596. "audio/mpegurl", "audio/x-mpegurl"};
  597. const std::string mpeg2_aac_codec_strings[] = {"mp4a.66", "mp4a.67",
  598. "mp4a.68"};
  599. const std::string mpeg4_aac_codec_strings[] = {
  600. "mp4a.40.2", "mp4a.40.02", "mp4a.40.5", "mp4a.40.05", "mp4a.40.29"};
  601. bool out_is_ambiguous;
  602. AudioCodec out_codec;
  603. for (const auto& hls_mime_type : hls_mime_types) {
  604. // MPEG2_AAC is never supported with HLS. Even when HLS on android is
  605. // supported, MediaPlayer lacks the needed MPEG2_AAC demuxers.
  606. // See https://crbug.com/544268.
  607. for (const auto& mpeg2_aac_string : mpeg2_aac_codec_strings) {
  608. EXPECT_FALSE(ParseAudioCodecString(hls_mime_type, mpeg2_aac_string,
  609. &out_is_ambiguous, &out_codec));
  610. }
  611. // MPEG4_AAC is supported with HLS whenever HLS is supported.
  612. for (const auto& mpeg4_aac_string : mpeg4_aac_codec_strings) {
  613. EXPECT_EQ(kHlsSupported,
  614. ParseAudioCodecString(hls_mime_type, mpeg4_aac_string,
  615. &out_is_ambiguous, &out_codec));
  616. }
  617. }
  618. // NOTE
  619. // We do not call IsCodecSupportedOnAndroid because the following checks
  620. // are made at a higher level in mime code (parsing rather than checks for
  621. // platform support).
  622. }
  623. } // namespace internal
  624. } // namespace media