projects / platform / core / multimedia / mmsvc-player.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 634146a)
[0.2.122] check offload status at some API 35/211735/3
authorEunhye Choi <eunhae1.choi@samsung.com>
Thu, 8 Aug 2019 11:08:11 +0000 (20:08 +0900)
committerEunhye Choi <eunhae1.choi@samsung.com>
Fri, 9 Aug 2019 07:27:53 +0000 (16:27 +0900)
- Check offload status at some API
  which could not be supported if offload is enabled.
- fix coverity issue

Change-Id: I6648c13ab5806f6380795f3fa2bb2572b1227583

legacy/src/legacy_player.c patch | blob | history
packaging/mmsvc-player.spec patch | blob | history

diff --git a/legacy/src/legacy_player.c b/legacy/src/legacy_player.c
index bcd4680..74fe859 100644 (file)
--- a/legacy/src/legacy_player.c
+++ b/legacy/src/legacy_player.c
@@ -646,6 +646,21 @@ __lplayer_convert_audio_pcm_mime_to_str(media_format_mimetype_e mime)
        return NULL;
 }
 
+static int __lplayer_audio_offload_is_enabled(legacy_player_h player, int *enabled)
+{
+       int ret = MM_ERROR_NONE;
+       legacy_player_t *handle = (legacy_player_t *)player;
+
+       ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_OFFLOAD, enabled, (char *)NULL);
+       if (ret != MM_ERROR_NONE) {
+               LOGE("failed to get offload status");
+               return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
+       }
+
+       LOGD("offload enabled : %d", *enabled);
+       return PLAYER_ERROR_NONE;
+}
+
 /*
  * Public Implementation
  */
@@ -1089,8 +1104,14 @@ int legacy_player_set_audio_latency_mode(legacy_player_h player, audio_latency_m
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1102,9 +1123,15 @@ int legacy_player_get_audio_latency_mode(legacy_player_h player, audio_latency_m
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(latency_mode);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_get_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1390,10 +1417,16 @@ int legacy_player_set_playback_rate(legacy_player_h player, float rate)
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        LOGI("<ENTER: rate %0.1f>", rate);
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_CHECK_CONDITION(rate >= -5.0 && rate <= 5.0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -1656,9 +1689,15 @@ int legacy_player_audio_effect_get_equalizer_bands_count(legacy_player_h player,
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(count);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_get_eq_bands_number(handle->mm_handle, count);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1670,9 +1709,15 @@ int legacy_player_audio_effect_set_equalizer_all_bands(legacy_player_h player, i
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(band_levels);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_set_level_eq_from_list(handle->mm_handle, band_levels, length);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1685,8 +1730,14 @@ int legacy_player_audio_effect_set_equalizer_band_level(legacy_player_h player,
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_set_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1702,9 +1753,15 @@ int legacy_player_audio_effect_get_equalizer_band_level(legacy_player_h player,
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(level);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_get_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1716,9 +1773,14 @@ int legacy_player_audio_effect_get_equalizer_level_range(legacy_player_h player,
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
-       PLAYER_NULL_ARG_CHECK(min);
-       PLAYER_NULL_ARG_CHECK(max);
+       PLAYER_NULL_ARG_CHECK(min && max);
+
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
 
        ret = mm_player_audio_effect_custom_get_level_range(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, min, max);
        if (ret != MM_ERROR_NONE)
@@ -1731,9 +1793,15 @@ int legacy_player_audio_effect_get_equalizer_band_frequency(legacy_player_h play
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(frequency);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_get_eq_bands_freq(handle->mm_handle, index, frequency);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1745,9 +1813,15 @@ int legacy_player_audio_effect_get_equalizer_band_frequency_range(legacy_player_
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(range);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_get_eq_bands_width(handle->mm_handle, index, range);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1759,8 +1833,14 @@ int legacy_player_audio_effect_equalizer_clear(legacy_player_h player)
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        ret = mm_player_audio_effect_custom_clear_eq_all(handle->mm_handle);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
@@ -1776,8 +1856,15 @@ int legacy_player_audio_effect_equalizer_is_available(legacy_player_h player, bo
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(available);
+
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -1988,11 +2075,17 @@ int legacy_player_set_media_packet_audio_frame_decoded_cb(legacy_player_h player
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       const char *audio_pcm_format = __lplayer_convert_audio_pcm_mime_to_str(mimetype);
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(callback);
-       PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 
-       const char *audio_pcm_format = __lplayer_convert_audio_pcm_mime_to_str(mimetype);
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
+       PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 
        if (audio_pcm_format && (samplerate > 0) && (channel > 0)) {
                ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PCM_EXT_FORMAT, audio_pcm_format, strlen(audio_pcm_format), NULL);
@@ -2062,7 +2155,10 @@ static int __lplayer_check_supported_format(media_format_h format, mmplayer_attr
        media_format_type_e format_type = MEDIA_FORMAT_NONE;
        media_format_mimetype_e mimetype = MEDIA_FORMAT_MAX;
 
-       media_format_get_type(format, &format_type);
+       if (media_format_get_type(format, &format_type) != MEDIA_FORMAT_ERROR_NONE) {
+               LOGE("failed to get format type");
+               return PLAYER_ERROR_INVALID_OPERATION;
+       }
 
        if (format_type == MEDIA_FORMAT_AUDIO) {
                if (media_format_get_audio_info(format, &mimetype,
@@ -2202,9 +2298,15 @@ int legacy_player_get_track_count(legacy_player_h player, player_stream_type_e t
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
        mmplayer_track_type_e track_type = 0;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(count);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -2234,8 +2336,15 @@ int legacy_player_get_current_track(legacy_player_h player, player_stream_type_e
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
        mmplayer_track_type_e track_type = 0;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(index);
+
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -2265,10 +2374,16 @@ int legacy_player_select_track(legacy_player_h player, player_stream_type_e type
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
        mmplayer_track_type_e track_type = 0;
+       int enabled = 0;
 
        LPLAYER_FENTER();
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_CHECK_CONDITION(index >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
+
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -2299,9 +2414,15 @@ int legacy_player_get_track_language_code(legacy_player_h player, player_stream_
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
        mmplayer_track_type_e track_type = 0;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
-       PLAYER_NULL_ARG_CHECK(code);
-       PLAYER_NULL_ARG_CHECK(len);
+       PLAYER_NULL_ARG_CHECK(code && len);
+
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_READY)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -2440,9 +2561,8 @@ int legacy_player_set_sound_stream_info_for_mused(legacy_player_h player, char *
        if (strncmp(stream_type, "media", strlen("media"))) {
                int enabled = 0;
 
-               ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_OFFLOAD, &enabled, (char *)NULL);
-               if (ret != MM_ERROR_NONE)
-                       return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
+               if (__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+                       return PLAYER_ERROR_INVALID_OPERATION;
 
                if (enabled) {
                        LOGW("audio offload will be disabled to support sound stream type: %s", stream_type);
@@ -2826,8 +2946,14 @@ int legacy_player_set_replaygain_enabled(legacy_player_h player, bool enabled)
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int offload_enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &offload_enabled) != PLAYER_ERROR_NONE)
+               || (offload_enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -2844,20 +2970,26 @@ int legacy_player_is_replaygain_enabled(legacy_player_h player, bool *enabled)
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
-       bool _enable;
+       bool replaygain_enabled = false;
+       int offload_enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(enabled);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &offload_enabled) != PLAYER_ERROR_NONE)
+               || (offload_enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
-       ret = mm_player_is_replaygain_enabled(handle->mm_handle, &_enable);
+       ret = mm_player_is_replaygain_enabled(handle->mm_handle, &replaygain_enabled);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
 
-       *enabled = _enable;
+       *enabled = replaygain_enabled;
        return PLAYER_ERROR_NONE;
 }
 
@@ -2959,7 +3091,14 @@ int legacy_player_pitch_set_enabled(legacy_player_h player, bool enabled)
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
+       int offload_enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
+
+       if ((__lplayer_audio_offload_is_enabled(player, &offload_enabled) != PLAYER_ERROR_NONE)
+               || (offload_enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 
        LOGD("set pitch control %d", enabled);
@@ -2976,9 +3115,15 @@ int legacy_player_pitch_is_enabled(legacy_player_h player, bool *enabled)
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
        int val = 0;
+       int offload_enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(enabled);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &offload_enabled) != PLAYER_ERROR_NONE)
+               || (offload_enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
@@ -2997,20 +3142,25 @@ int legacy_player_pitch_set_value(legacy_player_h player, float pitch)
 {
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
-       int is_enabled = 0;
+       int pitch_enabled = 0;
+       int offload_enabled = 0;
 
        PLAYER_INSTANCE_CHECK(player);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &offload_enabled) != PLAYER_ERROR_NONE)
+               || (offload_enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
        }
 
-       ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, &is_enabled, (char *)NULL);
+       ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, &pitch_enabled, (char *)NULL);
        if (ret != MM_ERROR_NONE)
                return _lplayer_convert_error_code(ret, (char *)__FUNCTION__);
 
-       if (!is_enabled) {
+       if (!pitch_enabled) {
                LOGE("pitch is not enabled");
                return PLAYER_ERROR_INVALID_OPERATION;
        }
@@ -3028,9 +3178,15 @@ int legacy_player_pitch_get_value(legacy_player_h player, float *pitch)
        legacy_player_t *handle = (legacy_player_t *)player;
        int ret = MM_ERROR_NONE;
        double value = 0.0;
+       int enabled = 0;
+
        PLAYER_INSTANCE_CHECK(player);
        PLAYER_NULL_ARG_CHECK(pitch);
 
+       if ((__lplayer_audio_offload_is_enabled(player, &enabled) != PLAYER_ERROR_NONE)
+               || (enabled))
+               return PLAYER_ERROR_INVALID_OPERATION;
+
        if (!_lplayer_state_validate(handle, PLAYER_STATE_IDLE)) {
                LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
                return PLAYER_ERROR_INVALID_STATE;
diff --git a/packaging/mmsvc-player.spec b/packaging/mmsvc-player.spec
index 168ca42..cffbf2e 100644 (file)
--- a/packaging/mmsvc-player.spec
+++ b/packaging/mmsvc-player.spec
@@ -1,6 +1,6 @@
 Name:       mmsvc-player
 Summary:    A Media Player module for muse server
-Version:    0.2.121
+Version:    0.2.122
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0
Domain: Multimedia / Media Playback;