1 /*
2 * Copyright (C) 2022 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 #define MLOG_TAG "MtpPacketTool"
16 #include "mtp_packet_tools.h"
17 #include <codecvt>
18 #include <cctype>
19 #include <cinttypes>
20 #include <cstdlib>
21 #include <locale>
22 #include "media_log.h"
23 #include "mtp_packet.h"
24 #include "securec.h"
25 #include "parameters.h"
26 #include "media_mtp_utils.h"
27 namespace OHOS {
28 namespace Media {
29 namespace {
30 // these numbers are defined by protocol, have no exact meaning
31 static const int BUF_07 = 0x07;
32 static const int BUF_0F = 0x0F;
33
34 static const int BEGIN_YEAR = 1900;
35 static const int DUMP_HEXBUF_MAX = 128;
36 static const int DUMP_TXTBUF_MAX = 32;
37 static const int MAX_LENGTH = 255;
38 static const int TIME_LENGTH = 20;
39 static const std::string BLANK_STR = " ";
40 static const std::string INDENT_BLANKSTR = " ";
41 static const int INDENT_SIZE = INDENT_BLANKSTR.length();
42 static const std::string DATE_TIME_INIT = "19700101T080000";
43 static const std::string UNKNOWN_STR = "Unknown";
44 static const char *UTF16_CERROR = "__CONVERSION_ERROR__";
45 static const char16_t *UTF8_CERROR = u"__CONVERSION_ERROR__";
46 static const std::string KEY_MTP_SHOW_DUMP = "multimedia.medialibrary.mtp_show_dump";
47 static const std::string MTP_SHOW_DUMP_DEFAULT = "0";
48 static const std::string ALLOW_SHOW_DUMP = "1";
49
50 static const std::map<uint32_t, std::string> AssociationMap = {
51 { MTP_ASSOCIATION_TYPE_UNDEFINED_CODE, "MTP_ASSOCIATION_TYPE_UNDEFINED" },
52 { MTP_ASSOCIATION_TYPE_GENERIC_FOLDER_CODE, "MTP_ASSOCIATION_TYPE_GENERIC_FOLDER" },
53 };
54
55 static const std::map<uint32_t, std::string> OperationMap = {
56 { MTP_OPERATION_GET_DEVICE_INFO_CODE, "MTP_OPERATION_GET_DEVICE_INFO" },
57 { MTP_OPERATION_OPEN_SESSION_CODE, "MTP_OPERATION_OPEN_SESSION" },
58 { MTP_OPERATION_CLOSE_SESSION_CODE, "MTP_OPERATION_CLOSE_SESSION" },
59 { MTP_OPERATION_GET_STORAGE_IDS_CODE, "MTP_OPERATION_GET_STORAGE_IDS" },
60 { MTP_OPERATION_GET_STORAGE_INFO_CODE, "MTP_OPERATION_GET_STORAGE_INFO" },
61 { MTP_OPERATION_GET_NUM_OBJECTS_CODE, "MTP_OPERATION_GET_NUM_OBJECTS" },
62 { MTP_OPERATION_GET_OBJECT_HANDLES_CODE, "MTP_OPERATION_GET_OBJECT_HANDLES" },
63 { MTP_OPERATION_GET_OBJECT_INFO_CODE, "MTP_OPERATION_GET_OBJECT_INFO" },
64 { MTP_OPERATION_GET_OBJECT_CODE, "MTP_OPERATION_GET_OBJECT" },
65 { MTP_OPERATION_GET_THUMB_CODE, "MTP_OPERATION_GET_THUMB" },
66 { MTP_OPERATION_DELETE_OBJECT_CODE, "MTP_OPERATION_DELETE_OBJECT" },
67 { MTP_OPERATION_SEND_OBJECT_INFO_CODE, "MTP_OPERATION_SEND_OBJECT_INFO" },
68 { MTP_OPERATION_SEND_OBJECT_CODE, "MTP_OPERATION_SEND_OBJECT" },
69 { MTP_OPERATION_INITIATE_CAPTURE_CODE, "MTP_OPERATION_INITIATE_CAPTURE" },
70 { MTP_OPERATION_FORMAT_STORE_CODE, "MTP_OPERATION_FORMAT_STORE" },
71 { MTP_OPERATION_RESET_DEVICE_CODE, "MTP_OPERATION_RESET_DEVICE" },
72 { MTP_OPERATION_SELF_TEST_CODE, "MTP_OPERATION_SELF_TEST" },
73 { MTP_OPERATION_SET_OBJECT_PROTECTION_CODE, "MTP_OPERATION_SET_OBJECT_PROTECTION" },
74 { MTP_OPERATION_POWER_DOWN_CODE, "MTP_OPERATION_POWER_DOWN" },
75 { MTP_OPERATION_GET_DEVICE_PROP_DESC_CODE, "MTP_OPERATION_GET_DEVICE_PROP_DESC" },
76 { MTP_OPERATION_GET_DEVICE_PROP_VALUE_CODE, "MTP_OPERATION_GET_DEVICE_PROP_VALUE" },
77 { MTP_OPERATION_SET_DEVICE_PROP_VALUE_CODE, "MTP_OPERATION_SET_DEVICE_PROP_VALUE" },
78 { MTP_OPERATION_RESET_DEVICE_PROP_VALUE_CODE, "MTP_OPERATION_RESET_DEVICE_PROP_VALUE" },
79 { MTP_OPERATION_TERMINATE_OPEN_CAPTURE_CODE, "MTP_OPERATION_TERMINATE_OPEN_CAPTURE" },
80 { MTP_OPERATION_MOVE_OBJECT_CODE, "MTP_OPERATION_MOVE_OBJECT" },
81 { MTP_OPERATION_COPY_OBJECT_CODE, "MTP_OPERATION_COPY_OBJECT" },
82 { MTP_OPERATION_GET_PARTIAL_OBJECT_CODE, "MTP_OPERATION_GET_PARTIAL_OBJECT" },
83 { MTP_OPERATION_INITIATE_OPEN_CAPTURE_CODE, "MTP_OPERATION_INITIATE_OPEN_CAPTURE" },
84 { MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED_CODE, "MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED" },
85 { MTP_OPERATION_GET_OBJECT_PROP_DESC_CODE, "MTP_OPERATION_GET_OBJECT_PROP_DESC" },
86 { MTP_OPERATION_GET_OBJECT_PROP_VALUE_CODE, "MTP_OPERATION_GET_OBJECT_PROP_VALUE" },
87 { MTP_OPERATION_SET_OBJECT_PROP_VALUE_CODE, "MTP_OPERATION_SET_OBJECT_PROP_VALUE" },
88 { MTP_OPERATION_GET_OBJECT_PROP_LIST_CODE, "MTP_OPERATION_GET_OBJECT_PROP_LIST" },
89 { MTP_OPERATION_SET_OBJECT_PROP_LIST_CODE, "MTP_OPERATION_SET_OBJECT_PROP_LIST" },
90 { MTP_OPERATION_GET_INTERDEPENDENT_PROPDESC_CODE, "MTP_OPERATION_GET_INTERDEPENDENT_PROP_DESC" },
91 { MTP_OPERATION_SEND_OBJECT_PROP_LIST_CODE, "MTP_OPERATION_SEND_OBJECT_PROP_LIST" },
92 { MTP_OPERATION_GET_OBJECT_REFERENCES_CODE, "MTP_OPERATION_GET_OBJECT_REFERENCES" },
93 { MTP_OPERATION_SET_OBJECT_REFERENCES_CODE, "MTP_OPERATION_SET_OBJECT_REFERENCES" },
94 { MTP_OPERATION_SKIP_CODE, "MTP_OPERATION_SKIP" },
95 };
96
97 static const std::map<uint32_t, std::string> FormatMap = {
98 { MTP_FORMAT_UNDEFINED_CODE, "MTP_FORMAT_UNDEFINED" },
99 { MTP_FORMAT_ASSOCIATION_CODE, "MTP_FORMAT_ASSOCIATION" },
100 { MTP_FORMAT_SCRIPT_CODE, "MTP_FORMAT_SCRIPT" },
101 { MTP_FORMAT_EXECUTABLE_CODE, "MTP_FORMAT_EXECUTABLE" },
102 { MTP_FORMAT_TEXT_CODE, "MTP_FORMAT_TEXT" },
103 { MTP_FORMAT_HTML_CODE, "MTP_FORMAT_HTML" },
104 { MTP_FORMAT_DPOF_CODE, "MTP_FORMAT_DPOF" },
105 { MTP_FORMAT_AIFF_CODE, "MTP_FORMAT_AIFF" },
106 { MTP_FORMAT_WAV_CODE, "MTP_FORMAT_WAV" },
107 { MTP_FORMAT_MP3_CODE, "MTP_FORMAT_MP3" },
108 { MTP_FORMAT_AVI_CODE, "MTP_FORMAT_AVI" },
109 { MTP_FORMAT_MPEG_CODE, "MTP_FORMAT_MPEG" },
110 { MTP_FORMAT_ASF_CODE, "MTP_FORMAT_ASF" },
111 { MTP_FORMAT_DEFINED_CODE, "MTP_FORMAT_DEFINED" },
112 { MTP_FORMAT_EXIF_JPEG_CODE, "MTP_FORMAT_EXIF_JPEG" },
113 { MTP_FORMAT_TIFF_EP_CODE, "MTP_FORMAT_TIFF_EP" },
114 { MTP_FORMAT_FLASHPIX_CODE, "MTP_FORMAT_FLASHPIX" },
115 { MTP_FORMAT_BMP_CODE, "MTP_FORMAT_BMP" },
116 { MTP_FORMAT_CIFF_CODE, "MTP_FORMAT_CIFF" },
117 { MTP_FORMAT_GIF_CODE, "MTP_FORMAT_GIF" },
118 { MTP_FORMAT_JFIF_CODE, "MTP_FORMAT_JFIF" },
119 { MTP_FORMAT_CD_CODE, "MTP_FORMAT_CD" },
120 { MTP_FORMAT_PICT_CODE, "MTP_FORMAT_PICT" },
121 { MTP_FORMAT_PNG_CODE, "MTP_FORMAT_PNG" },
122 { MTP_FORMAT_TIFF_CODE, "MTP_FORMAT_TIFF" },
123 { MTP_FORMAT_TIFF_IT_CODE, "MTP_FORMAT_TIFF_IT" },
124 { MTP_FORMAT_JP2_CODE, "MTP_FORMAT_JP2" },
125 { MTP_FORMAT_JPX_CODE, "MTP_FORMAT_JPX" },
126 { MTP_FORMAT_UNDEFINED_FIRMWARE_CODE, "MTP_FORMAT_UNDEFINED_FIRMWARE" },
127 { MTP_FORMAT_WINDOWS_IMAGE_FORMAT_CODE, "MTP_FORMAT_WINDOWS_IMAGE_FORMAT" },
128 { MTP_FORMAT_UNDEFINED_AUDIO_CODE, "MTP_FORMAT_UNDEFINED_AUDIO" },
129 { MTP_FORMAT_WMA_CODE, "MTP_FORMAT_WMA" },
130 { MTP_FORMAT_OGG_CODE, "MTP_FORMAT_OGG" },
131 { MTP_FORMAT_AAC_CODE, "MTP_FORMAT_AAC" },
132 { MTP_FORMAT_AUDIBLE_CODE, "MTP_FORMAT_AUDIBLE" },
133 { MTP_FORMAT_FLAC_CODE, "MTP_FORMAT_FLAC" },
134 { MTP_FORMAT_UNDEFINED_VIDEO_CODE, "MTP_FORMAT_UNDEFINED_VIDEO" },
135 { MTP_FORMAT_WMV_CODE, "MTP_FORMAT_WMV" },
136 { MTP_FORMAT_MP4_CONTAINER_CODE, "MTP_FORMAT_MP4_CONTAINER" },
137 { MTP_FORMAT_MP2_CODE, "MTP_FORMAT_MP2" },
138 { MTP_FORMAT_3GP_CONTAINER_CODE, "MTP_FORMAT_3GP_CONTAINER" },
139 { MTP_FORMAT_UNDEFINED_COLLECTION_CODE, "MTP_FORMAT_UNDEFINED_COLLECTION" },
140 { MTP_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM" },
141 { MTP_FORMAT_ABSTRACT_IMAGE_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_IMAGE_ALBUM" },
142 { MTP_FORMAT_ABSTRACT_AUDIO_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_AUDIO_ALBUM" },
143 { MTP_FORMAT_ABSTRACT_VIDEO_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_VIDEO_ALBUM" },
144 { MTP_FORMAT_ABSTRACT_AUDIO_VIDEO_PLAYLIST_CODE, "MTP_FORMAT_ABSTRACT_AUDIO_VIDEO_PLAYLIST" },
145 { MTP_FORMAT_ABSTRACT_CONTACT_GROUP_CODE, "MTP_FORMAT_ABSTRACT_CONTACT_GROUP" },
146 { MTP_FORMAT_ABSTRACT_MESSAGE_FOLDER_CODE, "MTP_FORMAT_ABSTRACT_MESSAGE_FOLDER" },
147 { MTP_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION_CODE, "MTP_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION" },
148 { MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST_CODE, "MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST" },
149 { MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST_CODE, "MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST" },
150 { MTP_FORMAT_ABSTRACT_MEDIACAST_CODE, "MTP_FORMAT_ABSTRACT_MEDIACAST" },
151 { MTP_FORMAT_WPL_PLAYLIST_CODE, "MTP_FORMAT_WPL_PLAYLIST" },
152 { MTP_FORMAT_M3U_PLAYLIST_CODE, "MTP_FORMAT_M3U_PLAYLIST" },
153 { MTP_FORMAT_MPL_PLAYLIST_CODE, "MTP_FORMAT_MPL_PLAYLIST" },
154 { MTP_FORMAT_ASX_PLAYLIST_CODE, "MTP_FORMAT_ASX_PLAYLIST" },
155 { MTP_FORMAT_PLS_PLAYLIST_CODE, "MTP_FORMAT_PLS_PLAYLIST" },
156 { MTP_FORMAT_UNDEFINED_DOCUMENT_CODE, "MTP_FORMAT_UNDEFINED_DOCUMENT" },
157 { MTP_FORMAT_ABSTRACT_DOCUMENT_CODE, "MTP_FORMAT_ABSTRACT_DOCUMENT" },
158 { MTP_FORMAT_XML_DOCUMENT_CODE, "MTP_FORMAT_XML_DOCUMENT" },
159 { MTP_FORMAT_MICROSOFT_WORD_DOCUMENT_CODE, "MTP_FORMAT_MICROSOFT_WORD_DOCUMENT" },
160 { MTP_FORMAT_MHT_COMPILED_HTML_DOCUMENT_CODE, "MTP_FORMAT_MHT_COMPILED_HTML_DOCUMENT" },
161 { MTP_FORMAT_MICROSOFT_EXCEL_SPREADSHEET_CODE, "MTP_FORMAT_MICROSOFT_EXCEL_SPREADSHEET" },
162 { MTP_FORMAT_MICROSOFT_POWERPOINT_PRESENTATION_CODE, "MTP_FORMAT_MICROSOFT_POWERPOINT_PRESENTATION" },
163 { MTP_FORMAT_UNDEFINED_MESSAGE_CODE, "MTP_FORMAT_UNDEFINED_MESSAGE" },
164 { MTP_FORMAT_ABSTRACT_MESSAGE_CODE, "MTP_FORMAT_ABSTRACT_MESSAGE" },
165 { MTP_FORMAT_UNDEFINED_CONTACT_CODE, "MTP_FORMAT_UNDEFINED_CONTACT" },
166 { MTP_FORMAT_ABSTRACT_CONTACT_CODE, "MTP_FORMAT_ABSTRACT_CONTACT" },
167 { MTP_FORMAT_VCARD_2_CODE, "MTP_FORMAT_VCARD_2" },
168 };
169
170 static const std::map<uint32_t, std::string> ObjectPropMap = {
171 { MTP_PROPERTY_STORAGE_ID_CODE, "MTP_PROPERTY_STORAGE_ID" },
172 { MTP_PROPERTY_OBJECT_FORMAT_CODE, "MTP_PROPERTY_OBJECT_FORMAT" },
173 { MTP_PROPERTY_PROTECTION_STATUS_CODE, "MTP_PROPERTY_PROTECTION_STATUS" },
174 { MTP_PROPERTY_OBJECT_SIZE_CODE, "MTP_PROPERTY_OBJECT_SIZE" },
175 { MTP_PROPERTY_ASSOCIATION_TYPE_CODE, "MTP_PROPERTY_ASSOCIATION_TYPE" },
176 { MTP_PROPERTY_ASSOCIATION_DESC_CODE, "MTP_PROPERTY_ASSOCIATION_DESC" },
177 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, "MTP_PROPERTY_OBJECT_FILE_NAME" },
178 { MTP_PROPERTY_DATE_CREATED_CODE, "MTP_PROPERTY_DATE_CREATED" },
179 { MTP_PROPERTY_DATE_MODIFIED_CODE, "MTP_PROPERTY_DATE_MODIFIED" },
180 { MTP_PROPERTY_KEYWORDS_CODE, "MTP_PROPERTY_KEYWORDS" },
181 { MTP_PROPERTY_PARENT_OBJECT_CODE, "MTP_PROPERTY_PARENT_OBJECT" },
182 { MTP_PROPERTY_ALLOWED_FOLDER_CONTENTS_CODE, "MTP_PROPERTY_ALLOWED_FOLDER_CONTENTS" },
183 { MTP_PROPERTY_HIDDEN_CODE, "MTP_PROPERTY_HIDDEN" },
184 { MTP_PROPERTY_SYSTEM_OBJECT_CODE, "MTP_PROPERTY_SYSTEM_OBJECT" },
185 { MTP_PROPERTY_PERSISTENT_UID_CODE, "MTP_PROPERTY_PERSISTENT_UID" },
186 { MTP_PROPERTY_SYNCID_CODE, "MTP_PROPERTY_SYNCID" },
187 { MTP_PROPERTY_PROPERTY_BAG_CODE, "MTP_PROPERTY_PROPERTY_BAG" },
188 { MTP_PROPERTY_NAME_CODE, "MTP_PROPERTY_NAME" },
189 { MTP_PROPERTY_CREATED_BY_CODE, "MTP_PROPERTY_CREATED_BY" },
190 { MTP_PROPERTY_ARTIST_CODE, "MTP_PROPERTY_ARTIST" },
191 { MTP_PROPERTY_DATE_AUTHORED_CODE, "MTP_PROPERTY_DATE_AUTHORED" },
192 { MTP_PROPERTY_DESCRIPTION_CODE, "MTP_PROPERTY_DESCRIPTION" },
193 { MTP_PROPERTY_URL_REFERENCE_CODE, "MTP_PROPERTY_URL_REFERENCE" },
194 { MTP_PROPERTY_LANGUAG_LOCALE_CODE, "MTP_PROPERTY_LANGUAG_LOCALE" },
195 { MTP_PROPERTY_COPYRIGHT_INFORMATION_CODE, "MTP_PROPERTY_COPYRIGHT_INFORMATION" },
196 { MTP_PROPERTY_SOURCE_CODE, "MTP_PROPERTY_SOURCE" },
197 { MTP_PROPERTY_ORIGIN_LOCATION_CODE, "MTP_PROPERTY_ORIGIN_LOCATION" },
198 { MTP_PROPERTY_DATE_ADDED_CODE, "MTP_PROPERTY_DATE_ADDED" },
199 { MTP_PROPERTY_NO_CONSUMABLE_CODE, "MTP_PROPERTY_NO_CONSUMABLE" },
200 { MTP_PROPERTY_CORRUP_UNPLAYABLE_CODE, "MTP_PROPERTY_CORRUP_UNPLAYABLE" },
201 { MTP_PROPERTY_PRODUCERSERIALNUMBER_CODE, "MTP_PROPERTY_PRODUCERSERIALNUMBER" },
202 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_FORMAT_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_FORMAT" },
203 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_SIZE_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_SIZE" },
204 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_HEIGHT_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_HEIGHT" },
205 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_WIDTH_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_WIDTH" },
206 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DURATION_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DURATION" },
207 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DATA_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DATA" },
208 { MTP_PROPERTY_WIDTH_CODE, "MTP_PROPERTY_WIDTH" },
209 { MTP_PROPERTY_HEIGHT_CODE, "MTP_PROPERTY_HEIGHT" },
210 { MTP_PROPERTY_DURATION_CODE, "MTP_PROPERTY_DURATION" },
211 { MTP_PROPERTY_RATING_CODE, "MTP_PROPERTY_RATING" },
212 { MTP_PROPERTY_TRACK_CODE, "MTP_PROPERTY_TRACK" },
213 { MTP_PROPERTY_GENRE_CODE, "MTP_PROPERTY_GENRE" },
214 { MTP_PROPERTY_CREDITS_CODE, "MTP_PROPERTY_CREDITS" },
215 { MTP_PROPERTY_LYRICS_CODE, "MTP_PROPERTY_LYRICS" },
216 { MTP_PROPERTY_SUBSCRIPTION_CONTENT_ID_CODE, "MTP_PROPERTY_SUBSCRIPTION_CONTENT_ID" },
217 { MTP_PROPERTY_PRODUCED_BY_CODE, "MTP_PROPERTY_PRODUCED_BY" },
218 { MTP_PROPERTY_USE_COUNT_CODE, "MTP_PROPERTY_USE_COUNT" },
219 { MTP_PROPERTY_SKIP_COUNT_CODE, "MTP_PROPERTY_SKIP_COUNT" },
220 { MTP_PROPERTY_LAST_ACCESSED_CODE, "MTP_PROPERTY_LAST_ACCESSED" },
221 { MTP_PROPERTY_PARENTAL_RATING_CODE, "MTP_PROPERTY_PARENTAL_RATING" },
222 { MTP_PROPERTY_META_GENRE_CODE, "MTP_PROPERTY_META_GENRE" },
223 { MTP_PROPERTY_COMPOSER_CODE, "MTP_PROPERTY_COMPOSER" },
224 { MTP_PROPERTY_EFFECTIVE_RATING_CODE, "MTP_PROPERTY_EFFECTIVE_RATING" },
225 { MTP_PROPERTY_SUBTITLE_CODE, "MTP_PROPERTY_SUBTITLE" },
226 { MTP_PROPERTY_ORIGINAL_RELEASE_DATE_CODE, "MTP_PROPERTY_ORIGINAL_RELEASE_DATE" },
227 { MTP_PROPERTY_ALBUM_NAME_CODE, "MTP_PROPERTY_ALBUM_NAME" },
228 { MTP_PROPERTY_ALBUM_ARTIST_CODE, "MTP_PROPERTY_ALBUM_ARTIST" },
229 { MTP_PROPERTY_MOOD_CODE, "MTP_PROPERTY_MOOD" },
230 { MTP_PROPERTY_DRM_STATUS_CODE, "MTP_PROPERTY_DRM_STATUS" },
231 { MTP_PROPERTY_SUB_DESCRIPTION_CODE, "MTP_PROPERTY_SUB_DESCRIPTION" },
232 { MTP_PROPERTY_IS_CROPPED_CODE, "MTP_PROPERTY_IS_CROPPED" },
233 { MTP_PROPERTY_IS_COLOUR_CORRECTED_CODE, "MTP_PROPERTY_IS_COLOUR_CORRECTED" },
234 { MTP_PROPERTY_IMAGE_BIT_DEPTH_CODE, "MTP_PROPERTY_IMAGE_BIT_DEPTH" },
235 { MTP_PROPERTY_FNUMBER_CODE, "MTP_PROPERTY_FNUMBER" },
236 { MTP_PROPERTY_EXPOSURE_TIME_CODE, "MTP_PROPERTY_EXPOSURE_TIME" },
237 { MTP_PROPERTY_EXPOSURE_INDEX_CODE, "MTP_PROPERTY_EXPOSURE_INDEX" },
238 { MTP_PROPERTY_TOTAL_BITRATE_CODE, "MTP_PROPERTY_TOTAL_BITRATE" },
239 { MTP_PROPERTY_BITRATE_TYPE_CODE, "MTP_PROPERTY_BITRATE_TYPE" },
240 { MTP_PROPERTY_SAMPLE_RATE_CODE, "MTP_PROPERTY_SAMPLE_RATE" },
241 { MTP_PROPERTY_NUMBER_OF_CHANNELS_CODE, "MTP_PROPERTY_NUMBER_OF_CHANNELS" },
242 { MTP_PROPERTY_AUDIO_BITDEPTH_CODE, "MTP_PROPERTY_AUDIO_BITDEPTH" },
243 { MTP_PROPERTY_SCAN_TYPE_CODE, "MTP_PROPERTY_SCAN_TYPE" },
244 { MTP_PROPERTY_AUDIO_WAVE_CODEC_CODE, "MTP_PROPERTY_AUDIO_WAVE_CODEC" },
245 { MTP_PROPERTY_AUDIO_BITRATE_CODE, "MTP_PROPERTY_AUDIO_BITRATE" },
246 { MTP_PROPERTY_VIDEO_FOURCC_CODEC_CODE, "MTP_PROPERTY_VIDEO_FOURCC_CODEC" },
247 { MTP_PROPERTY_VIDEO_BITRATE_CODE, "MTP_PROPERTY_VIDEO_BITRATE" },
248 { MTP_PROPERTY_FRAMES_PER_THOUSAND_SECONDS_CODE, "MTP_PROPERTY_FRAMES_PER_THOUSAND_SECONDS" },
249 { MTP_PROPERTY_KEYFRAME_DISTANCE_CODE, "MTP_PROPERTY_KEYFRAME_DISTANCE" },
250 { MTP_PROPERTY_BUFFER_SIZE_CODE, "MTP_PROPERTY_BUFFER_SIZE" },
251 { MTP_PROPERTY_ENCODING_QUALITY_CODE, "MTP_PROPERTY_ENCODING_QUALITY" },
252 { MTP_PROPERTY_ENCODING_PROFILE_CODE, "MTP_PROPERTY_ENCODING_PROFILE" },
253 { MTP_PROPERTY_DISPLAY_NAME_CODE, "MTP_PROPERTY_DISPLAY_NAME" },
254 { MTP_PROPERTY_BODY_TEXT_CODE, "MTP_PROPERTY_BODY_TEXT" },
255 { MTP_PROPERTY_SUBJECT_CODE, "MTP_PROPERTY_SUBJECT" },
256 { MTP_PROPERTY_PRIORITY_CODE, "MTP_PROPERTY_PRIORITY" },
257 { MTP_PROPERTY_GIVEN_NAME_CODE, "MTP_PROPERTY_GIVEN_NAME" },
258 { MTP_PROPERTY_MIDDLE_NAMES_CODE, "MTP_PROPERTY_MIDDLE_NAMES" },
259 { MTP_PROPERTY_FAMILY_NAME_CODE, "MTP_PROPERTY_FAMILY_NAME" },
260 { MTP_PROPERTY_PREFIX_CODE, "MTP_PROPERTY_PREFIX" },
261 { MTP_PROPERTY_SUFFIX_CODE, "MTP_PROPERTY_SUFFIX" },
262 { MTP_PROPERTY_PHONETIC_GIVEN_NAME_CODE, "MTP_PROPERTY_PHONETIC_GIVEN_NAME" },
263 { MTP_PROPERTY_PHONETIC_FAMILY_NAME_CODE, "MTP_PROPERTY_PHONETIC_FAMILY_NAME" },
264 { MTP_PROPERTY_EMAIL_PRIMARY_CODE, "MTP_PROPERTY_EMAIL_PRIMARY" },
265 { MTP_PROPERTY_EMAIL_PERSONAL_1_CODE, "MTP_PROPERTY_EMAIL_PERSONAL_1" },
266 { MTP_PROPERTY_EMAIL_PERSONAL_2_CODE, "MTP_PROPERTY_EMAIL_PERSONAL_2" },
267 { MTP_PROPERTY_EMAIL_BUSINESS_1_CODE, "MTP_PROPERTY_EMAIL_BUSINESS_1" },
268 { MTP_PROPERTY_EMAIL_BUSINESS_2_CODE, "MTP_PROPERTY_EMAIL_BUSINESS_2" },
269 { MTP_PROPERTY_EMAIL_OTHERS_CODE, "MTP_PROPERTY_EMAIL_OTHERS" },
270 { MTP_PROPERTY_PHONE_NUMBER_PRIMARY_CODE, "MTP_PROPERTY_PHONE_NUMBER_PRIMARY" },
271 { MTP_PROPERTY_PHONE_NUMBER_PERSONAL_CODE, "MTP_PROPERTY_PHONE_NUMBER_PERSONAL" },
272 { MTP_PROPERTY_PHONE_NUMBER_PERSONAL_2_CODE, "MTP_PROPERTY_PHONE_NUMBER_PERSONAL_2" },
273 { MTP_PROPERTY_PHONE_NUMBER_BUSINESS_CODE, "MTP_PROPERTY_PHONE_NUMBER_BUSINESS" },
274 { MTP_PROPERTY_PHONE_NUMBER_BUSINESS_2_CODE, "MTP_PROPERTY_PHONE_NUMBER_BUSINESS_2" },
275 { MTP_PROPERTY_PHONE_NUMBER_MOBILE_CODE, "MTP_PROPERTY_PHONE_NUMBER_MOBILE" },
276 { MTP_PROPERTY_PHONE_NUMBER_MOBILE_2_CODE, "MTP_PROPERTY_PHONE_NUMBER_MOBILE_2" },
277 { MTP_PROPERTY_FAX_NUMBER_PRIMARY_CODE, "MTP_PROPERTY_FAX_NUMBER_PRIMARY" },
278 { MTP_PROPERTY_FAX_NUMBER_PERSONAL_CODE, "MTP_PROPERTY_FAX_NUMBER_PERSONAL" },
279 { MTP_PROPERTY_FAX_NUMBER_BUSINESS_CODE, "MTP_PROPERTY_FAX_NUMBER_BUSINESS" },
280 { MTP_PROPERTY_PAGER_NUMBER_CODE, "MTP_PROPERTY_PAGER_NUMBER" },
281 { MTP_PROPERTY_PHONE_NUMBER_OTHERS_CODE, "MTP_PROPERTY_PHONE_NUMBER_OTHERS" },
282 { MTP_PROPERTY_PRIMARY_WEB_ADDRESS_CODE, "MTP_PROPERTY_PRIMARY_WEB_ADDRESS" },
283 { MTP_PROPERTY_PERSONAL_WEB_ADDRESS_CODE, "MTP_PROPERTY_PERSONAL_WEB_ADDRESS" },
284 { MTP_PROPERTY_BUSINESS_WEB_ADDRESS_CODE, "MTP_PROPERTY_BUSINESS_WEB_ADDRESS" },
285 { MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_CODE, "MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS" },
286 { MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_2_CODE, "MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_2" },
287 { MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_3_CODE, "MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_3" },
288 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_FULL_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_FULL" },
289 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_1_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_1" },
290 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_2_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_2" },
291 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_CITY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_CITY" },
292 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_REGION_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_REGION" },
293 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_POSTAL_CODE_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_POSTAL" },
294 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_COUNTRY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_COUNTRY" },
295 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_FULL_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_FULL" },
296 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_1_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_1" },
297 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_2_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_2" },
298 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_CITY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_CITY" },
299 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_REGION_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_REGION" },
300 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_POSTAL_CODE_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_POSTAL" },
301 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_COUNTRY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_COUNTRY" },
302 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_FULL_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_FULL" },
303 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_1_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_1" },
304 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_2_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_2" },
305 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_CITY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_CITY" },
306 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_REGION_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_REGION" },
307 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_POSTAL_CODE_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_POSTAL" },
308 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_COUNTRY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_COUNTRY" },
309 { MTP_PROPERTY_ORGANIZATION_NAME_CODE, "MTP_PROPERTY_ORGANIZATION_NAME" },
310 { MTP_PROPERTY_PHONETIC_ORGANIZATION_NAME_CODE, "MTP_PROPERTY_PHONETIC_ORGANIZATION_NAME" },
311 { MTP_PROPERTY_ROLE_CODE, "MTP_PROPERTY_ROLE" },
312 { MTP_PROPERTY_BIRTHDATE_CODE, "MTP_PROPERTY_BIRTHDATE" },
313 { MTP_PROPERTY_MESSAGE_TO_CODE, "MTP_PROPERTY_MESSAGE_TO" },
314 { MTP_PROPERTY_MESSAGE_CC_CODE, "MTP_PROPERTY_MESSAGE_CC" },
315 { MTP_PROPERTY_MESSAGE_BCC_CODE, "MTP_PROPERTY_MESSAGE_BCC" },
316 { MTP_PROPERTY_MESSAGE_READ_CODE, "MTP_PROPERTY_MESSAGE_READ" },
317 { MTP_PROPERTY_MESSAGE_RECEIVED_TIME_CODE, "MTP_PROPERTY_MESSAGE_RECEIVED_TIME" },
318 { MTP_PROPERTY_MESSAGE_SENDER_CODE, "MTP_PROPERTY_MESSAGE_SENDER" },
319 { MTP_PROPERTY_ACTIVITY_BEGIN_TIME_CODE, "MTP_PROPERTY_ACTIVITY_BEGIN_TIME" },
320 { MTP_PROPERTY_ACTIVITY_END_TIME_CODE, "MTP_PROPERTY_ACTIVITY_END_TIME" },
321 { MTP_PROPERTY_ACTIVITY_LOCATION_CODE, "MTP_PROPERTY_ACTIVITY_LOCATION" },
322 { MTP_PROPERTY_ACTIVITY_REQUIRED_ATTENDEES_CODE, "MTP_PROPERTY_ACTIVITY_REQUIRED_ATTENDEES" },
323 { MTP_PROPERTY_ACTIVITY_OPTIONAL_ATTENDEES_CODE, "MTP_PROPERTY_ACTIVITY_OPTIONAL_ATTENDEES" },
324 { MTP_PROPERTY_ACTIVITY_RESOURCES_CODE, "MTP_PROPERTY_ACTIVITY_RESOURCES" },
325 { MTP_PROPERTY_ACTIVITY_ACCEPTED_CODE, "MTP_PROPERTY_ACTIVITY_ACCEPTED" },
326 { MTP_PROPERTY_ACTIVITY_TENTATIVE_CODE, "MTP_PROPERTY_ACTIVITY_TENTATIVE" },
327 { MTP_PROPERTY_ACTIVITY_DECLINED_CODE, "MTP_PROPERTY_ACTIVITY_DECLINED" },
328 { MTP_PROPERTY_ACTIVITY_REMINDER_TIME_CODE, "MTP_PROPERTY_ACTIVITY_REMINDER_TIME" },
329 { MTP_PROPERTY_ACTIVITY_OWNER_CODE, "MTP_PROPERTY_ACTIVITY_OWNER" },
330 { MTP_PROPERTY_ACTIVITY_STATUS_CODE, "MTP_PROPERTY_ACTIVITY_STATUS" },
331 { MTP_PROPERTY_OWNER_CODE, "MTP_PROPERTY_OWNER" },
332 { MTP_PROPERTY_EDITOR_CODE, "MTP_PROPERTY_EDITOR" },
333 { MTP_PROPERTY_WEBMASTER_CODE, "MTP_PROPERTY_WEBMASTER" },
334 { MTP_PROPERTY_URL_SOURCE_CODE, "MTP_PROPERTY_URL_SOURCE" },
335 { MTP_PROPERTY_URL_DESTINATION_CODE, "MTP_PROPERTY_URL_DESTINATION" },
336 { MTP_PROPERTY_TIME_BOOKMARK_CODE, "MTP_PROPERTY_TIME_BOOKMARK" },
337 { MTP_PROPERTY_OBJECT_BOOKMARK_CODE, "MTP_PROPERTY_OBJECT_BOOKMARK" },
338 { MTP_PROPERTY_BYTE_BOOKMARK_CODE, "MTP_PROPERTY_BYTE_BOOKMARK" },
339 { MTP_PROPERTY_LAST_BUILD_DATE_CODE, "MTP_PROPERTY_LAST_BUILD_DATE" },
340 { MTP_PROPERTY_TIME_TO_LIVE_CODE, "MTP_PROPERTY_TIME_TO_LIVE" },
341 { MTP_PROPERTY_MEDIA_GUID_CODE, "MTP_PROPERTY_MEDIA_GUID" },
342 };
343
344 static const std::map<int, std::string> DataTypeMap = {
345 { MTP_TYPE_UNDEFINED_CODE, "MTP_TYPE_UNDEFINED" },
346 { MTP_TYPE_INT8_CODE, "MTP_TYPE_INT8" },
347 { MTP_TYPE_UINT8_CODE, "MTP_TYPE_UINT8" },
348 { MTP_TYPE_INT16_CODE, "MTP_TYPE_INT16" },
349 { MTP_TYPE_UINT16_CODE, "MTP_TYPE_UINT16" },
350 { MTP_TYPE_INT32_CODE, "MTP_TYPE_INT32" },
351 { MTP_TYPE_UINT32_CODE, "MTP_TYPE_UINT32" },
352 { MTP_TYPE_INT64_CODE, "MTP_TYPE_INT64" },
353 { MTP_TYPE_UINT64_CODE, "MTP_TYPE_UINT64" },
354 { MTP_TYPE_INT128_CODE, "MTP_TYPE_INT128" },
355 { MTP_TYPE_UINT128_CODE, "MTP_TYPE_UINT128" },
356 { MTP_TYPE_AINT8_CODE, "MTP_TYPE_AINT8" },
357 { MTP_TYPE_AUINT8_CODE, "MTP_TYPE_AUINT8" },
358 { MTP_TYPE_AINT16_CODE, "MTP_TYPE_AINT16" },
359 { MTP_TYPE_AUINT16_CODE, "MTP_TYPE_AUINT16" },
360 { MTP_TYPE_AINT32_CODE, "MTP_TYPE_AINT32" },
361 { MTP_TYPE_AUINT32_CODE, "MTP_TYPE_AUINT32" },
362 { MTP_TYPE_AINT64_CODE, "MTP_TYPE_AINT64" },
363 { MTP_TYPE_AUINT64_CODE, "MTP_TYPE_AUINT64" },
364 { MTP_TYPE_AINT128_CODE, "MTP_TYPE_AINT128" },
365 { MTP_TYPE_AUINT128_CODE, "MTP_TYPE_AUINT128" },
366 { MTP_TYPE_STRING_CODE, "MTP_TYPE_STRING" },
367 };
368
369 static const std::map<uint32_t, std::string> EventMap = {
370 { MTP_EVENT_UNDEFINED_CODE, "MTP_EVENT_UNDEFINED" },
371 { MTP_EVENT_CANCEL_TRANSACTION_CODE, "MTP_EVENT_CANCEL_TRANSACTION" },
372 { MTP_EVENT_OBJECT_ADDED_CODE, "MTP_EVENT_OBJECT_ADDED" },
373 { MTP_EVENT_OBJECT_REMOVED_CODE, "MTP_EVENT_OBJECT_REMOVED" },
374 { MTP_EVENT_STORE_ADDED_CODE, "MTP_EVENT_STORE_ADDED" },
375 { MTP_EVENT_STORE_REMOVED_CODE, "MTP_EVENT_STORE_REMOVED" },
376 { MTP_EVENT_DEVICE_PROP_CHANGED_CODE, "MTP_EVENT_DEVICE_PROP_CHANGED" },
377 { MTP_EVENT_OBJECT_INFO_CHANGED_CODE, "MTP_EVENT_OBJECT_INFO_CHANGED" },
378 { MTP_EVENT_DEVICE_INFO_CHANGED_CODE, "MTP_EVENT_DEVICE_INFO_CHANGED" },
379 { MTP_EVENT_REQUEST_OBJECT_TRANSFER_CODE, "MTP_EVENT_REQUEST_OBJECT_TRANSFER" },
380 { MTP_EVENT_STORE_FULL_CODE, "MTP_EVENT_STORE_FULL" },
381 { MTP_EVENT_DEVICE_RESET_CODE, "MTP_EVENT_DEVICE_RESET" },
382 { MTP_EVENT_STORAGE_INFO_CHANGED_CODE, "MTP_EVENT_STORAGE_INFO_CHANGED" },
383 { MTP_EVENT_CAPTURE_COMPLETE_CODE, "MTP_EVENT_CAPTURE_COMPLETE" },
384 { MTP_EVENT_UNREPORTED_STATUS_CODE, "MTP_EVENT_UNREPORTED_STATUS" },
385 { MTP_EVENT_OBJECT_PROP_CHANGED_CODE, "MTP_EVENT_OBJECT_PROP_CHANGED" },
386 { MTP_EVENT_OBJECT_PROP_DESC_CHANGED_CODE, "MTP_EVENT_OBJECT_PROP_DESC_CHANGED" },
387 { MTP_EVENT_OBJECT_REFERENCES_CHANGED_CODE, "MTP_EVENT_OBJECT_REFERENCES_CHANGED" },
388 };
389
390 static const std::map<uint16_t, int> ObjectPropTypeMap = {
391 { MTP_PROPERTY_STORAGE_ID_CODE, MTP_TYPE_UINT32_CODE },
392 { MTP_PROPERTY_OBJECT_FORMAT_CODE, MTP_TYPE_UINT16_CODE },
393 { MTP_PROPERTY_PROTECTION_STATUS_CODE, MTP_TYPE_UINT16_CODE },
394 { MTP_PROPERTY_OBJECT_SIZE_CODE, MTP_TYPE_UINT64_CODE },
395 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, MTP_TYPE_STRING_CODE },
396 { MTP_PROPERTY_DATE_MODIFIED_CODE, MTP_TYPE_STRING_CODE },
397 { MTP_PROPERTY_PARENT_OBJECT_CODE, MTP_TYPE_UINT32_CODE },
398 { MTP_PROPERTY_PERSISTENT_UID_CODE, MTP_TYPE_UINT128_CODE },
399 { MTP_PROPERTY_NAME_CODE, MTP_TYPE_STRING_CODE },
400 { MTP_PROPERTY_DISPLAY_NAME_CODE, MTP_TYPE_STRING_CODE },
401 { MTP_PROPERTY_DATE_ADDED_CODE, MTP_TYPE_STRING_CODE },
402 { MTP_PROPERTY_ARTIST_CODE, MTP_TYPE_STRING_CODE },
403 { MTP_PROPERTY_ALBUM_NAME_CODE, MTP_TYPE_STRING_CODE },
404 { MTP_PROPERTY_ALBUM_ARTIST_CODE, MTP_TYPE_STRING_CODE },
405 { MTP_PROPERTY_TRACK_CODE, MTP_TYPE_UINT16_CODE },
406 { MTP_PROPERTY_ORIGINAL_RELEASE_DATE_CODE, MTP_TYPE_STRING_CODE },
407 { MTP_PROPERTY_GENRE_CODE, MTP_TYPE_STRING_CODE },
408 { MTP_PROPERTY_COMPOSER_CODE, MTP_TYPE_STRING_CODE },
409 { MTP_PROPERTY_DURATION_CODE, MTP_TYPE_UINT32_CODE },
410 { MTP_PROPERTY_DESCRIPTION_CODE, MTP_TYPE_STRING_CODE },
411 { MTP_PROPERTY_AUDIO_WAVE_CODEC_CODE, MTP_TYPE_UINT32_CODE },
412 { MTP_PROPERTY_BITRATE_TYPE_CODE, MTP_TYPE_UINT16_CODE },
413 { MTP_PROPERTY_AUDIO_BITRATE_CODE, MTP_TYPE_UINT32_CODE },
414 { MTP_PROPERTY_NUMBER_OF_CHANNELS_CODE, MTP_TYPE_UINT16_CODE },
415 { MTP_PROPERTY_SAMPLE_RATE_CODE, MTP_TYPE_UINT32_CODE },
416 };
417 }
418
MtpPacketTool()419 MtpPacketTool::MtpPacketTool()
420 {
421 }
422
~MtpPacketTool()423 MtpPacketTool::~MtpPacketTool()
424 {
425 }
426
GetUInt16(uint8_t numFirst,uint8_t numSecond)427 uint16_t MtpPacketTool::GetUInt16(uint8_t numFirst, uint8_t numSecond)
428 {
429 return ((uint16_t)numSecond << BIT_8) | (uint16_t)numFirst;
430 }
431
GetUInt32(uint8_t numFirst,uint8_t numSecond,uint8_t numThird,uint8_t numFourth)432 uint32_t MtpPacketTool::GetUInt32(uint8_t numFirst, uint8_t numSecond, uint8_t numThird, uint8_t numFourth)
433 {
434 return ((uint32_t)numFourth << BIT_24) | ((uint32_t)numThird << BIT_16) | ((uint32_t)numSecond << BIT_8) |
435 (uint32_t)numFirst;
436 }
437
PutUInt8(std::vector<uint8_t> & outBuffer,uint16_t value)438 void MtpPacketTool::PutUInt8(std::vector<uint8_t> &outBuffer, uint16_t value)
439 {
440 outBuffer.push_back((uint8_t)(value & 0xFF));
441 }
442
PutUInt16(std::vector<uint8_t> & outBuffer,uint16_t value)443 void MtpPacketTool::PutUInt16(std::vector<uint8_t> &outBuffer, uint16_t value)
444 {
445 outBuffer.push_back((uint8_t)(value & 0xFF));
446 outBuffer.push_back((uint8_t)((value >> BIT_8) & 0xFF));
447 }
448
PutUInt32(std::vector<uint8_t> & outBuffer,uint32_t value)449 void MtpPacketTool::PutUInt32(std::vector<uint8_t> &outBuffer, uint32_t value)
450 {
451 outBuffer.push_back((uint8_t)(value & 0xFF));
452 outBuffer.push_back((uint8_t)((value >> BIT_8) & 0xFF));
453 outBuffer.push_back((uint8_t)((value >> BIT_16) & 0xFF));
454 outBuffer.push_back((uint8_t)((value >> BIT_24) & 0xFF));
455 }
456
PutUInt64(std::vector<uint8_t> & outBuffer,uint64_t value)457 void MtpPacketTool::PutUInt64(std::vector<uint8_t> &outBuffer, uint64_t value)
458 {
459 outBuffer.push_back((uint8_t)(value & 0xFF));
460 outBuffer.push_back((uint8_t)((value >> BIT_8) & 0xFF));
461 outBuffer.push_back((uint8_t)((value >> BIT_16) & 0xFF));
462 outBuffer.push_back((uint8_t)((value >> BIT_24) & 0xFF));
463 outBuffer.push_back((uint8_t)((value >> BIT_32) & 0xFF));
464 outBuffer.push_back((uint8_t)((value >> BIT_40) & 0xFF));
465 outBuffer.push_back((uint8_t)((value >> BIT_48) & 0xFF));
466 outBuffer.push_back((uint8_t)((value >> BIT_56) & 0xFF));
467 }
468
PutUInt128(std::vector<uint8_t> & outBuffer,uint64_t value)469 void MtpPacketTool::PutUInt128(std::vector<uint8_t> &outBuffer, uint64_t value)
470 {
471 PutUInt64(outBuffer, value);
472 PutUInt64(outBuffer, 0);
473 }
474
PutUInt128(std::vector<uint8_t> & outBuffer,const uint128_t value)475 void MtpPacketTool::PutUInt128(std::vector<uint8_t> &outBuffer, const uint128_t value)
476 {
477 PutUInt32(outBuffer, value[OFFSET_0]);
478 PutUInt32(outBuffer, value[OFFSET_1]);
479 PutUInt32(outBuffer, value[OFFSET_2]);
480 PutUInt32(outBuffer, value[OFFSET_3]);
481 }
482
PutAUInt16(std::vector<uint8_t> & outBuffer,const uint16_t * values,int count)483 void MtpPacketTool::PutAUInt16(std::vector<uint8_t> &outBuffer, const uint16_t *values, int count)
484 {
485 PutUInt32(outBuffer, count);
486 for (int i = 0; i < count; i++) {
487 PutUInt16(outBuffer, *values++);
488 }
489 }
490
PutAUInt32(std::vector<uint8_t> & outBuffer,const uint32_t * values,int count)491 void MtpPacketTool::PutAUInt32(std::vector<uint8_t> &outBuffer, const uint32_t *values, int count)
492 {
493 PutUInt32(outBuffer, count);
494 for (int i = 0; i < count; i++) {
495 PutUInt32(outBuffer, *values++);
496 }
497 }
498
PutInt8(std::vector<uint8_t> & outBuffer,int8_t value)499 void MtpPacketTool::PutInt8(std::vector<uint8_t> &outBuffer, int8_t value)
500 {
501 outBuffer.push_back(static_cast<uint8_t>(value));
502 }
503
PutInt16(std::vector<uint8_t> & outBuffer,int16_t value)504 void MtpPacketTool::PutInt16(std::vector<uint8_t> &outBuffer, int16_t value)
505 {
506 PutUInt16(outBuffer, static_cast<uint16_t>(value));
507 }
508
PutInt32(std::vector<uint8_t> & outBuffer,int32_t value)509 void MtpPacketTool::PutInt32(std::vector<uint8_t> &outBuffer, int32_t value)
510 {
511 PutUInt32(outBuffer, static_cast<uint32_t>(value));
512 }
513
PutInt64(std::vector<uint8_t> & outBuffer,int64_t value)514 void MtpPacketTool::PutInt64(std::vector<uint8_t> &outBuffer, int64_t value)
515 {
516 PutUInt64(outBuffer, static_cast<uint64_t>(value));
517 }
518
PutInt128(std::vector<uint8_t> & outBuffer,int64_t value)519 void MtpPacketTool::PutInt128(std::vector<uint8_t> &outBuffer, int64_t value)
520 {
521 PutUInt64(outBuffer, static_cast<uint64_t>(value));
522 PutUInt64(outBuffer, static_cast<uint64_t>(value < 0 ? -1 : 0));
523 }
524
PutInt128(std::vector<uint8_t> & outBuffer,const int128_t value)525 void MtpPacketTool::PutInt128(std::vector<uint8_t> &outBuffer, const int128_t value)
526 {
527 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_0]));
528 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_1]));
529 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_2]));
530 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_3]));
531 }
532
PutString(std::vector<uint8_t> & outBuffer,const std::string & string)533 void MtpPacketTool::PutString(std::vector<uint8_t> &outBuffer, const std::string &string)
534 {
535 std::u16string src16 = Utf8ToUtf16(string);
536
537 uint16_t count = src16.length();
538 if (count == 0) {
539 PutUInt8(outBuffer, 0);
540 return;
541 }
542 PutUInt8(outBuffer, std::min(count + 1, MAX_LENGTH));
543
544 int i = 0;
545 for (char16_t &c : src16) {
546 if (i == MAX_LENGTH - 1) {
547 break;
548 }
549 PutUInt16(outBuffer, c);
550 i++;
551 }
552 PutUInt16(outBuffer, 0);
553 }
554
555 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> gConvert(UTF16_CERROR, UTF8_CERROR);
556
Utf8ToUtf16(const std::string & inputStr)557 std::u16string MtpPacketTool::Utf8ToUtf16(const std::string &inputStr)
558 {
559 std::u16string conversion = gConvert.from_bytes(inputStr);
560 if (conversion == UTF8_CERROR) {
561 return u"";
562 } else {
563 return conversion;
564 }
565 }
566
Utf16ToUtf8(const std::u16string & inputStr)567 std::string MtpPacketTool::Utf16ToUtf8(const std::u16string &inputStr)
568 {
569 std::string conversion = gConvert.to_bytes(inputStr);
570 if (conversion == UTF16_CERROR) {
571 return "";
572 } else {
573 return conversion;
574 }
575 }
576
GetUInt8(const std::vector<uint8_t> & buffer,size_t & offset)577 uint8_t MtpPacketTool::GetUInt8(const std::vector<uint8_t> &buffer, size_t &offset)
578 {
579 uint8_t value = (uint16_t)buffer[offset];
580 offset += sizeof(uint8_t);
581 return value;
582 }
583
GetUInt16(const std::vector<uint8_t> & buffer,size_t & offset)584 uint16_t MtpPacketTool::GetUInt16(const std::vector<uint8_t> &buffer, size_t &offset)
585 {
586 uint16_t value = (uint16_t)buffer[offset] | ((uint16_t)buffer[offset + OFFSET_1] << BIT_8);
587 offset += sizeof(uint16_t);
588 return value;
589 }
590
GetUInt32(const std::vector<uint8_t> & buffer,size_t & offset)591 uint32_t MtpPacketTool::GetUInt32(const std::vector<uint8_t> &buffer, size_t &offset)
592 {
593 uint32_t value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8) |
594 ((uint32_t)buffer[offset + OFFSET_2] << BIT_16) | ((uint32_t)buffer[offset + OFFSET_3] << BIT_24);
595 offset += sizeof(uint32_t);
596 return value;
597 }
598
GetUInt8(const std::vector<uint8_t> & buffer,size_t & offset,uint8_t & value)599 bool MtpPacketTool::GetUInt8(const std::vector<uint8_t> &buffer, size_t &offset, uint8_t &value)
600 {
601 if (buffer.size() < sizeof(uint8_t) + offset) {
602 MEDIA_ERR_LOG("MtpPacketTool::GetUInt8, size incorrect");
603 return false;
604 }
605
606 value = buffer[offset];
607 offset += sizeof(uint8_t);
608 return true;
609 }
610
GetUInt16(const std::vector<uint8_t> & buffer,size_t & offset,uint16_t & value)611 bool MtpPacketTool::GetUInt16(const std::vector<uint8_t> &buffer, size_t &offset, uint16_t &value)
612 {
613 if (buffer.size() < sizeof(uint16_t) + offset) {
614 MEDIA_ERR_LOG("MtpPacketTool::GetUInt16, size incorrect");
615 return false;
616 }
617
618 value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8);
619 offset += sizeof(uint16_t);
620 return true;
621 }
622
GetUInt32(const std::vector<uint8_t> & buffer,size_t & offset,uint32_t & value)623 bool MtpPacketTool::GetUInt32(const std::vector<uint8_t> &buffer, size_t &offset, uint32_t &value)
624 {
625 if (buffer.size() < sizeof(uint32_t) + offset) {
626 MEDIA_ERR_LOG("MtpPacketTool::GetUInt32, size incorrect");
627 return false;
628 }
629
630 value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8) |
631 ((uint32_t)buffer[offset + OFFSET_2] << BIT_16) | ((uint32_t)buffer[offset + OFFSET_3] << BIT_24);
632 offset += sizeof(uint32_t);
633 return true;
634 }
635
GetUInt64(const std::vector<uint8_t> & buffer,size_t & offset,uint64_t & value)636 bool MtpPacketTool::GetUInt64(const std::vector<uint8_t> &buffer, size_t &offset, uint64_t &value)
637 {
638 if (buffer.size() < sizeof(uint64_t) + offset) {
639 MEDIA_ERR_LOG("MtpPacketTool::GetUInt64, size incorrect");
640 return false;
641 }
642
643 value = buffer[offset] | (buffer[offset + OFFSET_1] << BIT_8) | (buffer[offset + OFFSET_2] << BIT_16) |
644 (buffer[offset + OFFSET_3] << BIT_24) | (static_cast<uint64_t>(buffer[offset + OFFSET_4]) << BIT_32) |
645 (static_cast<uint64_t>(buffer[offset + OFFSET_5]) << BIT_40) |
646 (static_cast<uint64_t>(buffer[offset + OFFSET_6]) << BIT_48) |
647 (static_cast<uint64_t>(buffer[offset + OFFSET_7]) << BIT_56);
648 offset += sizeof(uint64_t);
649 return true;
650 }
651
GetUInt128(const std::vector<uint8_t> & buffer,size_t & offset,uint128_t & value)652 bool MtpPacketTool::GetUInt128(const std::vector<uint8_t> &buffer, size_t &offset, uint128_t &value)
653 {
654 bool cond = (!GetUInt32(buffer, offset, value[OFFSET_0]) || !GetUInt32(buffer, offset, value[OFFSET_1]) ||
655 !GetUInt32(buffer, offset, value[OFFSET_2]) || !GetUInt32(buffer, offset, value[OFFSET_3]));
656 CHECK_AND_RETURN_RET(!cond, false);
657 return true;
658 }
659
GetInt8(const std::vector<uint8_t> & buffer,size_t & offset,int8_t & value)660 bool MtpPacketTool::GetInt8(const std::vector<uint8_t> &buffer, size_t &offset, int8_t &value)
661 {
662 uint8_t uValue = 0;
663 if (!GetUInt8(buffer, offset, uValue)) {
664 return false;
665 }
666 value = static_cast<int8_t>(uValue);
667 return true;
668 }
669
GetInt16(const std::vector<uint8_t> & buffer,size_t & offset,int16_t & value)670 bool MtpPacketTool::GetInt16(const std::vector<uint8_t> &buffer, size_t &offset, int16_t &value)
671 {
672 uint16_t uValue = 0;
673 if (!GetUInt16(buffer, offset, uValue)) {
674 return false;
675 }
676 value = static_cast<int16_t>(uValue);
677 return true;
678 }
679
GetInt32(const std::vector<uint8_t> & buffer,size_t & offset,int32_t & value)680 bool MtpPacketTool::GetInt32(const std::vector<uint8_t> &buffer, size_t &offset, int32_t &value)
681 {
682 uint32_t uValue = 0;
683 if (!GetUInt32(buffer, offset, uValue)) {
684 return false;
685 }
686 value = static_cast<int32_t>(uValue);
687 return true;
688 }
GetInt64(const std::vector<uint8_t> & buffer,size_t & offset,int64_t & value)689 bool MtpPacketTool::GetInt64(const std::vector<uint8_t> &buffer, size_t &offset, int64_t &value)
690 {
691 uint64_t uValue = 0;
692 if (!GetUInt64(buffer, offset, uValue)) {
693 return false;
694 }
695 value = static_cast<int64_t>(uValue);
696 return true;
697 }
698
GetInt128(const std::vector<uint8_t> & buffer,size_t & offset,int128_t & value)699 bool MtpPacketTool::GetInt128(const std::vector<uint8_t> &buffer, size_t &offset, int128_t &value)
700 {
701 uint128_t uValue = {0};
702 bool cond = (!GetUInt32(buffer, offset, uValue[OFFSET_0]) || !GetUInt32(buffer, offset, uValue[OFFSET_1]) ||
703 !GetUInt32(buffer, offset, uValue[OFFSET_2]) || !GetUInt32(buffer, offset, uValue[OFFSET_3]));
704 CHECK_AND_RETURN_RET(!cond, false);
705
706 value[OFFSET_0] = static_cast<int32_t>(uValue[OFFSET_0]);
707 value[OFFSET_1] = static_cast<int32_t>(uValue[OFFSET_1]);
708 value[OFFSET_2] = static_cast<int32_t>(uValue[OFFSET_2]);
709 value[OFFSET_3] = static_cast<int32_t>(uValue[OFFSET_3]);
710 return true;
711 }
712
GetAUInt16(const std::vector<uint8_t> & buffer,size_t & offset)713 std::shared_ptr<UInt16List> MtpPacketTool::GetAUInt16(const std::vector<uint8_t> &buffer, size_t &offset)
714 {
715 std::shared_ptr<UInt16List> result = std::make_shared<UInt16List>();
716
717 uint32_t count = GetUInt32(buffer, offset);
718 uint16_t value = 0;
719 for (uint32_t i = 0; i < count; i++) {
720 if (!GetUInt16(buffer, offset, value)) {
721 MEDIA_ERR_LOG("MtpPacketTool::GetAUInt16, count=%{public}d, i=%{public}d", count, i);
722 break;
723 }
724 result->push_back(value);
725 }
726
727 return result;
728 }
729
GetAUInt32(const std::vector<uint8_t> & buffer,size_t & offset)730 std::shared_ptr<UInt32List> MtpPacketTool::GetAUInt32(const std::vector<uint8_t> &buffer, size_t &offset)
731 {
732 std::shared_ptr<UInt32List> result = std::make_shared<UInt32List>();
733
734 uint32_t count = GetUInt32(buffer, offset);
735 uint32_t value = 0;
736 for (uint32_t i = 0; i < count; i++) {
737 if (!GetUInt32(buffer, offset, value)) {
738 MEDIA_ERR_LOG("MtpPacketTool::GetAUInt32, count=%{public}d, i=%{public}d", count, i);
739 break;
740 }
741 result->push_back(value);
742 }
743
744 return result;
745 }
746
GetString(const std::vector<uint8_t> & buffer,size_t & offset)747 std::string MtpPacketTool::GetString(const std::vector<uint8_t> &buffer, size_t &offset)
748 {
749 uint8_t count = GetUInt8(buffer, offset);
750 if (count < 1) {
751 return std::string();
752 }
753 std::vector<char16_t> tmpbuf(count);
754 uint16_t ch = 0;
755 for (int i = 0; i < count; i++) {
756 ch = GetUInt16(buffer, offset);
757 tmpbuf[i] = ch;
758 }
759 std::string String = Utf16ToUtf8(std::u16string(tmpbuf.data()));
760 return String;
761 }
762
GetString(const std::vector<uint8_t> & buffer,size_t & offset,std::string & str)763 bool MtpPacketTool::GetString(const std::vector<uint8_t> &buffer, size_t &offset, std::string &str)
764 {
765 uint8_t count = 0;
766 if (!GetUInt8(buffer, offset, count)) {
767 return false;
768 }
769
770 if (count < 1) {
771 str = std::string();
772 return true;
773 }
774
775 std::vector<char16_t> tmpbuf(count);
776 uint16_t ch = 0;
777 for (int i = 0; ((i < count) && ((offset + sizeof(uint16_t) - 1) < buffer.size())); i++) {
778 if (!GetUInt16(buffer, offset, ch)) {
779 return false;
780 }
781 tmpbuf[i] = ch;
782 }
783
784 str = Utf16ToUtf8(std::u16string(tmpbuf.data()));
785 return true;
786 }
787
FormatDateTime(time_t sec)788 std::string MtpPacketTool::FormatDateTime(time_t sec)
789 {
790 struct tm tm;
791 char buffer[TIME_LENGTH] = {0};
792 localtime_r(&sec, &tm);
793 if (sprintf_s(buffer, sizeof(buffer), "%04d%02d%02dT%02d%02d%02d", tm.tm_year + BEGIN_YEAR, tm.tm_mon + 1,
794 tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec) == -1) {
795 return "";
796 }
797 return std::string(buffer);
798 }
799
GetOperationName(uint16_t code)800 const std::string &MtpPacketTool::GetOperationName(uint16_t code)
801 {
802 return CodeToStrByMap(code, OperationMap);
803 }
804
GetFormatName(uint16_t code)805 const std::string &MtpPacketTool::GetFormatName(uint16_t code)
806 {
807 return CodeToStrByMap(code, FormatMap);
808 }
809
GetObjectPropName(uint16_t code)810 const std::string &MtpPacketTool::GetObjectPropName(uint16_t code)
811 {
812 return CodeToStrByMap(code, ObjectPropMap);
813 }
814
GetDataTypeName(int type)815 const std::string &MtpPacketTool::GetDataTypeName(int type)
816 {
817 return CodeToStrByMap(type, DataTypeMap);
818 }
819
GetEventName(uint16_t code)820 const std::string &MtpPacketTool::GetEventName(uint16_t code)
821 {
822 return CodeToStrByMap(code, EventMap);
823 }
824
GetAssociationName(int type)825 const std::string &MtpPacketTool::GetAssociationName(int type)
826 {
827 return CodeToStrByMap(type, AssociationMap);
828 }
829
CodeToStrByMap(int type,const std::map<int,std::string> & theMap)830 const std::string &MtpPacketTool::CodeToStrByMap(int type, const std::map<int, std::string> &theMap)
831 {
832 auto codeSearch = theMap.find(type);
833 return (codeSearch != theMap.end()) ? codeSearch->second : UNKNOWN_STR;
834 }
835
CodeToStrByMap(uint32_t code,const std::map<uint32_t,std::string> & theMap)836 const std::string &MtpPacketTool::CodeToStrByMap(uint32_t code, const std::map<uint32_t, std::string> &theMap)
837 {
838 auto codeSearch = theMap.find(code);
839 return (codeSearch != theMap.end()) ? codeSearch->second : UNKNOWN_STR;
840 }
841
GetObjectPropTypeByPropCode(uint16_t propCode)842 int MtpPacketTool::GetObjectPropTypeByPropCode(uint16_t propCode)
843 {
844 auto propCodeSearch = ObjectPropTypeMap.find(propCode);
845 return (propCodeSearch != ObjectPropTypeMap.end()) ? propCodeSearch->second : MTP_TYPE_UNDEFINED_CODE;
846 }
847
Int8ToString(const int8_t & value,std::string & outStr)848 bool MtpPacketTool::Int8ToString(const int8_t &value, std::string &outStr)
849 {
850 char tmpbuf[BIT_32] = {0};
851 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%02x, dec=%d", value, value) != -1, false);
852 outStr.assign(tmpbuf);
853 return true;
854 }
855
UInt8ToString(const uint8_t & value,std::string & outStr)856 bool MtpPacketTool::UInt8ToString(const uint8_t &value, std::string &outStr)
857 {
858 char tmpbuf[BIT_32] = {0};
859 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%02x, dec=%u", value, value) != -1, false);
860 outStr.assign(tmpbuf);
861 return true;
862 }
863
Int16ToString(const int16_t & value,std::string & outStr)864 bool MtpPacketTool::Int16ToString(const int16_t &value, std::string &outStr)
865 {
866 char tmpbuf[BIT_32] = {0};
867 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%04x, dec=%d", value, value) != -1, false);
868 outStr.assign(tmpbuf);
869 return true;
870 }
871
UInt16ToString(const uint16_t & value,std::string & outStr)872 bool MtpPacketTool::UInt16ToString(const uint16_t &value, std::string &outStr)
873 {
874 char tmpbuf[BIT_32] = {0};
875 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%04x, dec=%u", value, value) != -1, false);
876 outStr.assign(tmpbuf);
877 return true;
878 }
879
Int32ToString(const int32_t & value,std::string & outStr)880 bool MtpPacketTool::Int32ToString(const int32_t &value, std::string &outStr)
881 {
882 char tmpbuf[BIT_64] = {0};
883 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%08x, dec=%d", value, value) != -1, false);
884 outStr.assign(tmpbuf);
885 return true;
886 }
887
UInt32ToString(const uint32_t & value,std::string & outStr)888 bool MtpPacketTool::UInt32ToString(const uint32_t &value, std::string &outStr)
889 {
890 char tmpbuf[BIT_64] = {0};
891 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%08x, dec=%u", value, value) != -1, false);
892 outStr.assign(tmpbuf);
893 return true;
894 }
895
Int64ToString(const int64_t & value,std::string & outStr)896 bool MtpPacketTool::Int64ToString(const int64_t &value, std::string &outStr)
897 {
898 char tmpbuf[BIT_64] = {0};
899 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%016" PRIx64 ", dec=%" PRIi64 "",
900 value, value) != -1, false);
901 outStr.assign(tmpbuf);
902 return true;
903 }
904
UInt64ToString(const uint64_t & value,std::string & outStr)905 bool MtpPacketTool::UInt64ToString(const uint64_t &value, std::string &outStr)
906 {
907 char tmpbuf[BIT_64] = {0};
908 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%016" PRIx64 ", dec=%" PRIu64 "",
909 value, value) != -1, false);
910 outStr.assign(tmpbuf);
911 return true;
912 }
913
Int128ToString(const int128_t & value,std::string & outStr)914 bool MtpPacketTool::Int128ToString(const int128_t &value, std::string &outStr)
915 {
916 char tmpbuf[BIT_128] = {0};
917 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=(%08x,%08x,%08x,%08x), dec=(%d,%d,%d,%d)",
918 value[OFFSET_0], value[OFFSET_1], value[OFFSET_2], value[OFFSET_3], value[OFFSET_0], value[OFFSET_1],
919 value[OFFSET_2], value[OFFSET_3]) != -1, false);
920 outStr.assign(tmpbuf);
921 return true;
922 }
923
UInt128ToString(const uint128_t & value,std::string & outStr)924 bool MtpPacketTool::UInt128ToString(const uint128_t &value, std::string &outStr)
925 {
926 char tmpbuf[BIT_128] = {0};
927 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=(%08x,%08x,%08x,%08x), dec=(%u,%u,%u,%u)", value[OFFSET_0],
928 value[OFFSET_1], value[OFFSET_2], value[OFFSET_3], value[OFFSET_0], value[OFFSET_1], value[OFFSET_2],
929 value[OFFSET_3]) == -1) {
930 return false;
931 }
932 outStr.assign(tmpbuf);
933 return true;
934 }
935
StrToString(const std::string & value)936 std::string MtpPacketTool::StrToString(const std::string &value)
937 {
938 std::string str;
939 str.append("length:");
940 str.append(std::to_string(value.length()));
941 str.append(", content:[");
942 str.append(value);
943 str.append("]");
944 return str;
945 }
946
GetIndentBlank()947 const std::string &MtpPacketTool::GetIndentBlank()
948 {
949 return INDENT_BLANKSTR;
950 }
951
GetIndentBlank(size_t indent)952 std::string MtpPacketTool::GetIndentBlank(size_t indent)
953 {
954 size_t maxNum = BLANK_STR.length();
955 size_t num = indent * INDENT_SIZE;
956
957 std::string indentStr = BLANK_STR.substr(0, ((num > maxNum) ? maxNum : num));
958 return indentStr;
959 }
960
CanDump()961 bool MtpPacketTool::CanDump()
962 {
963 std::string mtpShowDump = OHOS::system::GetParameter(KEY_MTP_SHOW_DUMP, MTP_SHOW_DUMP_DEFAULT);
964 return mtpShowDump.compare(ALLOW_SHOW_DUMP) == 0;
965 }
966
DumpPacket(const std::vector<uint8_t> & outBuffer)967 void MtpPacketTool::DumpPacket(const std::vector<uint8_t> &outBuffer)
968 {
969 if (!MtpPacketTool::CanDump()) {
970 MEDIA_DEBUG_LOG("MtpPacketTool::CanDump return false");
971 return;
972 }
973 int offset = 0;
974 uint32_t containerLength = MtpPacketTool::GetUInt32(outBuffer[offset], outBuffer[offset + OFFSET_1],
975 outBuffer[offset + OFFSET_2], outBuffer[offset + OFFSET_3]);
976 uint16_t containerType = MtpPacketTool::GetUInt16(outBuffer[offset + OFFSET_4],
977 outBuffer[offset + OFFSET_5]);
978 if (containerType == DATA_CONTAINER_TYPE) {
979 MEDIA_DEBUG_LOG("Packet type: %{public}d, Payload Size: %{public}d",
980 DATA_CONTAINER_TYPE, containerLength - PACKET_HEADER_LENGETH);
981 MtpPacketTool::Dump(outBuffer, 0, PACKET_HEADER_LENGETH);
982 } else {
983 MEDIA_DEBUG_LOG("Packet type: %{public}d, Packet size: %{public}d",
984 containerType, containerLength);
985 MtpPacketTool::Dump(outBuffer);
986 }
987 }
988
Dump(const std::vector<uint8_t> & data,uint32_t offset,uint32_t sum)989 void MtpPacketTool::Dump(const std::vector<uint8_t> &data, uint32_t offset, uint32_t sum)
990 {
991 CHECK_AND_RETURN_LOG(data.size() > 0, "Dump data is empty");
992
993 std::unique_ptr<char[]> hexBuf = std::make_unique<char[]>(DUMP_HEXBUF_MAX);
994 std::unique_ptr<char[]> txtBuf = std::make_unique<char[]>(DUMP_TXTBUF_MAX);
995 if (!DumpClear(offset, hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
996 return;
997 }
998 const size_t datasize = data.size();
999 for (size_t loc = 0, cur = offset; ((loc < sum) && (cur < datasize)); loc++, cur++) {
1000 if (!DumpChar(data[cur], hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
1001 return;
1002 }
1003 size_t idx = (loc & BUF_0F);
1004 if (strcat_s(hexBuf.get(), DUMP_HEXBUF_MAX, ((idx != BUF_07) ? " " : "-")) != EOK) {
1005 return;
1006 }
1007 if (idx != BUF_0F) {
1008 continue;
1009 }
1010 DumpShow(hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX);
1011 if (!DumpClear(loc + 1, hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
1012 return;
1013 }
1014 }
1015 DumpShow(hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX);
1016 }
1017
DumpClear(size_t loc,std::unique_ptr<char[]> & hexBuf,int hexBufSize,std::unique_ptr<char[]> & txtBuf,int txtBufSize)1018 bool MtpPacketTool::DumpClear(size_t loc, std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1019 std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1020 {
1021 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1022 return false;
1023 }
1024
1025 if (sprintf_s(hexBuf.get(), hexBufSize, "%08X : ", static_cast<uint32_t>(loc)) == -1) {
1026 return false;
1027 }
1028 if (sprintf_s(txtBuf.get(), txtBufSize, "%s", "") == -1) {
1029 return false;
1030 }
1031 return true;
1032 }
1033
DumpChar(uint8_t u8,std::unique_ptr<char[]> & hexBuf,int hexBufSize,std::unique_ptr<char[]> & txtBuf,int txtBufSize)1034 bool MtpPacketTool::DumpChar(uint8_t u8, std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1035 std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1036 {
1037 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1038 return false;
1039 }
1040
1041 char hexTmp[BIT_4] = {0};
1042 if (sprintf_s(hexTmp, sizeof(hexTmp), "%02X", u8) == -1) {
1043 return false;
1044 }
1045
1046 int intData = static_cast<int>(u8);
1047 char txtTmp[BIT_4] = {0};
1048 if (isprint(intData)) {
1049 if (sprintf_s(txtTmp, sizeof(txtTmp), "%d", intData) == -1) {
1050 return false;
1051 }
1052 } else {
1053 if (sprintf_s(txtTmp, sizeof(txtTmp), "%c", '.') == -1) {
1054 return false;
1055 }
1056 }
1057
1058 if (strcat_s(hexBuf.get(), hexBufSize, hexTmp) != EOK) {
1059 return false;
1060 }
1061 if (strcat_s(txtBuf.get(), txtBufSize, txtTmp) != EOK) {
1062 return false;
1063 }
1064 return true;
1065 }
1066
DumpShow(const std::unique_ptr<char[]> & hexBuf,int hexBufSize,const std::unique_ptr<char[]> & txtBuf,int txtBufSize)1067 void MtpPacketTool::DumpShow(const std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1068 const std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1069 {
1070 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1071 return;
1072 }
1073 if ((hexBuf[OFFSET_0] == '\0') || (txtBuf[OFFSET_0] == '\0')) {
1074 return;
1075 }
1076
1077 MEDIA_DEBUG_LOG("%-60s %s", hexBuf.get(), txtBuf.get());
1078 }
1079 } // namespace Media
1080 } // namespace OHOS