1 /*
2 * Copyright (c) 2021-2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "media_utils.h"
17 #include <cmath>
18 #include <media_errors.h>
19
20 namespace OHOS {
21 namespace Media {
22 namespace {
23 struct ErrorCodePair {
24 ErrorCode errorCode;
25 int serviceErrCode;
26 };
27 const ErrorCodePair g_errorCodePair[] = {
28 {ErrorCode::SUCCESS, MSERR_OK},
29 {ErrorCode::ERROR_UNKNOWN, MSERR_UNKNOWN},
30 {ErrorCode::ERROR_AGAIN, MSERR_UNKNOWN},
31 {ErrorCode::ERROR_UNIMPLEMENTED, MSERR_UNSUPPORT},
32 {ErrorCode::ERROR_INVALID_PARAMETER_VALUE, MSERR_INVALID_VAL},
33 {ErrorCode::ERROR_INVALID_PARAMETER_TYPE, MSERR_INVALID_VAL},
34 {ErrorCode::ERROR_INVALID_OPERATION, MSERR_INVALID_OPERATION},
35 {ErrorCode::ERROR_UNSUPPORTED_FORMAT, MSERR_UNSUPPORT_CONTAINER_TYPE},
36 {ErrorCode::ERROR_NOT_EXISTED, MSERR_OPEN_FILE_FAILED},
37 {ErrorCode::ERROR_TIMED_OUT, MSERR_EXT_TIMEOUT},
38 {ErrorCode::ERROR_NO_MEMORY, MSERR_EXT_NO_MEMORY},
39 {ErrorCode::ERROR_INVALID_STATE, MSERR_INVALID_STATE},
40 };
41 const std::array<std::pair<PlaybackRateMode, float>, 5> PLAY_RATE_REFS = {
42 std::make_pair(PlaybackRateMode::SPEED_FORWARD_0_75_X, 0.75),
43 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_00_X, 1.0),
44 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_25_X, 1.25),
45 std::make_pair(PlaybackRateMode::SPEED_FORWARD_1_75_X, 1.75),
46 std::make_pair(PlaybackRateMode::SPEED_FORWARD_2_00_X, 2.00),
47 };
48 } // namespace
49
TransErrorCode(ErrorCode errorCode)50 int TransErrorCode(ErrorCode errorCode)
51 {
52 for (const auto& errPair : g_errorCodePair) {
53 if (errPair.errorCode == errorCode) {
54 return errPair.serviceErrCode;
55 }
56 }
57 return MSERR_UNKNOWN;
58 }
59
TransStateId2PlayerState(StateId state)60 PlayerStates TransStateId2PlayerState(StateId state)
61 {
62 PlayerStates playerState = PLAYER_STATE_ERROR;
63 switch (state) {
64 case StateId::IDLE:
65 playerState = PLAYER_IDLE;
66 break;
67 case StateId::INIT:
68 playerState = PLAYER_INITIALIZED;
69 break;
70 case StateId::PREPARING:
71 playerState = PLAYER_PREPARING;
72 break;
73 case StateId::READY:
74 playerState = PLAYER_PREPARED;
75 break;
76 case StateId::PAUSE:
77 playerState = PLAYER_PAUSED;
78 break;
79 case StateId::PLAYING:
80 playerState = PLAYER_STARTED;
81 break;
82 case StateId::STOPPED:
83 playerState = PLAYER_STOPPED;
84 break;
85 case StateId::EOS:
86 playerState = PLAYER_PLAYBACK_COMPLETE;
87 break;
88 default:
89 break;
90 }
91 return playerState;
92 }
93
Transform2SeekMode(PlayerSeekMode mode)94 Plugin::SeekMode Transform2SeekMode(PlayerSeekMode mode)
95 {
96 switch (mode) {
97 case PlayerSeekMode::SEEK_NEXT_SYNC:
98 return Plugin::SeekMode::SEEK_NEXT_SYNC;
99 case PlayerSeekMode::SEEK_PREVIOUS_SYNC:
100 return Plugin::SeekMode::SEEK_PREVIOUS_SYNC;
101 case PlayerSeekMode::SEEK_CLOSEST_SYNC:
102 return Plugin::SeekMode::SEEK_CLOSEST_SYNC;
103 case PlayerSeekMode::SEEK_CLOSEST:
104 default:
105 return Plugin::SeekMode::SEEK_CLOSEST;
106 }
107 }
StringnessPlayerState(PlayerStates state)108 const std::string& StringnessPlayerState(PlayerStates state)
109 {
110 using StateString = std::pair<PlayerStates, std::string>;
111 const static std::array<StateString, 9> maps = { // array size
112 std::make_pair(PlayerStates::PLAYER_STATE_ERROR, "state error"),
113 std::make_pair(PlayerStates::PLAYER_IDLE, "idle"),
114 std::make_pair(PlayerStates::PLAYER_INITIALIZED, "init"),
115 std::make_pair(PlayerStates::PLAYER_PREPARING, "preparing"),
116 std::make_pair(PlayerStates::PLAYER_PREPARED, "prepared"),
117 std::make_pair(PlayerStates::PLAYER_STARTED, "started"),
118 std::make_pair(PlayerStates::PLAYER_PAUSED, "paused"),
119 std::make_pair(PlayerStates::PLAYER_STOPPED, "stopped"),
120 std::make_pair(PlayerStates::PLAYER_PLAYBACK_COMPLETE, "completed"),
121 };
122 const static std::string UNKNOWN = "unknown";
123 auto ite = std::find_if(maps.begin(), maps.end(), [&] (const StateString& item) -> bool {
124 return item.first == state;
125 });
126 if (ite == maps.end()) {
127 return UNKNOWN;
128 }
129 return ite->second;
130 }
TransformPlayRate2Float(PlaybackRateMode rateMode)131 float TransformPlayRate2Float(PlaybackRateMode rateMode)
132 {
133 auto ite = std::find_if(PLAY_RATE_REFS.begin(), PLAY_RATE_REFS.end(), [&](const auto& pair) ->bool {
134 return pair.first == rateMode;
135 });
136 if (ite == PLAY_RATE_REFS.end()) {
137 return 1.0f;
138 }
139 return ite->second;
140 }
TransformFloat2PlayRate(float rate)141 PlaybackRateMode TransformFloat2PlayRate(float rate)
142 {
143 auto ite = std::find_if(PLAY_RATE_REFS.begin(), PLAY_RATE_REFS.end(), [&](const auto& pair) ->bool {
144 return std::fabs(rate - pair.second) < 1e-3;
145 });
146 if (ite == PLAY_RATE_REFS.end()) {
147 return PlaybackRateMode::SPEED_FORWARD_1_00_X;
148 }
149 return ite->first;
150 }
151 } // namespace Media
152 } // namespace OHOS