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 CHECK_AND_RETURN_RET_LOG(buffer.size() >= sizeof(uint8_t) + offset, false,
602 "MtpPacketTool::GetUInt8, size incorrect");
603
604 value = buffer[offset];
605 offset += sizeof(uint8_t);
606 return true;
607 }
608
GetUInt16(const std::vector<uint8_t> & buffer,size_t & offset,uint16_t & value)609 bool MtpPacketTool::GetUInt16(const std::vector<uint8_t> &buffer, size_t &offset, uint16_t &value)
610 {
611 CHECK_AND_RETURN_RET_LOG(buffer.size() >= sizeof(uint16_t) + offset, false,
612 "MtpPacketTool::GetUInt16, size incorrect");
613
614 value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8);
615 offset += sizeof(uint16_t);
616 return true;
617 }
618
GetUInt32(const std::vector<uint8_t> & buffer,size_t & offset,uint32_t & value)619 bool MtpPacketTool::GetUInt32(const std::vector<uint8_t> &buffer, size_t &offset, uint32_t &value)
620 {
621 CHECK_AND_RETURN_RET_LOG(buffer.size() >= sizeof(uint32_t) + offset, false,
622 "MtpPacketTool::GetUInt32, size incorrect");
623
624 value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8) |
625 ((uint32_t)buffer[offset + OFFSET_2] << BIT_16) | ((uint32_t)buffer[offset + OFFSET_3] << BIT_24);
626 offset += sizeof(uint32_t);
627 return true;
628 }
629
GetUInt64(const std::vector<uint8_t> & buffer,size_t & offset,uint64_t & value)630 bool MtpPacketTool::GetUInt64(const std::vector<uint8_t> &buffer, size_t &offset, uint64_t &value)
631 {
632 CHECK_AND_RETURN_RET_LOG(buffer.size() >= sizeof(uint64_t) + offset, false,
633 "MtpPacketTool::GetUInt64, size incorrect");
634
635 value = buffer[offset] | (buffer[offset + OFFSET_1] << BIT_8) | (buffer[offset + OFFSET_2] << BIT_16) |
636 (buffer[offset + OFFSET_3] << BIT_24) | (static_cast<uint64_t>(buffer[offset + OFFSET_4]) << BIT_32) |
637 (static_cast<uint64_t>(buffer[offset + OFFSET_5]) << BIT_40) |
638 (static_cast<uint64_t>(buffer[offset + OFFSET_6]) << BIT_48) |
639 (static_cast<uint64_t>(buffer[offset + OFFSET_7]) << BIT_56);
640 offset += sizeof(uint64_t);
641 return true;
642 }
643
GetUInt128(const std::vector<uint8_t> & buffer,size_t & offset,uint128_t & value)644 bool MtpPacketTool::GetUInt128(const std::vector<uint8_t> &buffer, size_t &offset, uint128_t &value)
645 {
646 bool cond = (!GetUInt32(buffer, offset, value[OFFSET_0]) || !GetUInt32(buffer, offset, value[OFFSET_1]) ||
647 !GetUInt32(buffer, offset, value[OFFSET_2]) || !GetUInt32(buffer, offset, value[OFFSET_3]));
648 CHECK_AND_RETURN_RET(!cond, false);
649 return true;
650 }
651
GetInt8(const std::vector<uint8_t> & buffer,size_t & offset,int8_t & value)652 bool MtpPacketTool::GetInt8(const std::vector<uint8_t> &buffer, size_t &offset, int8_t &value)
653 {
654 uint8_t uValue = 0;
655 CHECK_AND_RETURN_RET(GetUInt8(buffer, offset, uValue), false);
656 value = static_cast<int8_t>(uValue);
657 return true;
658 }
659
GetInt16(const std::vector<uint8_t> & buffer,size_t & offset,int16_t & value)660 bool MtpPacketTool::GetInt16(const std::vector<uint8_t> &buffer, size_t &offset, int16_t &value)
661 {
662 uint16_t uValue = 0;
663 CHECK_AND_RETURN_RET(GetUInt16(buffer, offset, uValue), false);
664 value = static_cast<int16_t>(uValue);
665 return true;
666 }
667
GetInt32(const std::vector<uint8_t> & buffer,size_t & offset,int32_t & value)668 bool MtpPacketTool::GetInt32(const std::vector<uint8_t> &buffer, size_t &offset, int32_t &value)
669 {
670 uint32_t uValue = 0;
671 CHECK_AND_RETURN_RET(GetUInt32(buffer, offset, uValue), false);
672 value = static_cast<int32_t>(uValue);
673 return true;
674 }
GetInt64(const std::vector<uint8_t> & buffer,size_t & offset,int64_t & value)675 bool MtpPacketTool::GetInt64(const std::vector<uint8_t> &buffer, size_t &offset, int64_t &value)
676 {
677 uint64_t uValue = 0;
678 CHECK_AND_RETURN_RET(GetUInt64(buffer, offset, uValue), false);
679 value = static_cast<int64_t>(uValue);
680 return true;
681 }
682
GetInt128(const std::vector<uint8_t> & buffer,size_t & offset,int128_t & value)683 bool MtpPacketTool::GetInt128(const std::vector<uint8_t> &buffer, size_t &offset, int128_t &value)
684 {
685 uint128_t uValue = {0};
686 bool cond = (!GetUInt32(buffer, offset, uValue[OFFSET_0]) || !GetUInt32(buffer, offset, uValue[OFFSET_1]) ||
687 !GetUInt32(buffer, offset, uValue[OFFSET_2]) || !GetUInt32(buffer, offset, uValue[OFFSET_3]));
688 CHECK_AND_RETURN_RET(!cond, false);
689
690 value[OFFSET_0] = static_cast<int32_t>(uValue[OFFSET_0]);
691 value[OFFSET_1] = static_cast<int32_t>(uValue[OFFSET_1]);
692 value[OFFSET_2] = static_cast<int32_t>(uValue[OFFSET_2]);
693 value[OFFSET_3] = static_cast<int32_t>(uValue[OFFSET_3]);
694 return true;
695 }
696
GetAUInt16(const std::vector<uint8_t> & buffer,size_t & offset)697 std::shared_ptr<UInt16List> MtpPacketTool::GetAUInt16(const std::vector<uint8_t> &buffer, size_t &offset)
698 {
699 std::shared_ptr<UInt16List> result = std::make_shared<UInt16List>();
700
701 uint32_t count = GetUInt32(buffer, offset);
702 uint16_t value = 0;
703 for (uint32_t i = 0; i < count; i++) {
704 if (!GetUInt16(buffer, offset, value)) {
705 MEDIA_ERR_LOG("MtpPacketTool::GetAUInt16, count=%{public}d, i=%{public}d", count, i);
706 break;
707 }
708 result->push_back(value);
709 }
710
711 return result;
712 }
713
GetAUInt32(const std::vector<uint8_t> & buffer,size_t & offset)714 std::shared_ptr<UInt32List> MtpPacketTool::GetAUInt32(const std::vector<uint8_t> &buffer, size_t &offset)
715 {
716 std::shared_ptr<UInt32List> result = std::make_shared<UInt32List>();
717
718 uint32_t count = GetUInt32(buffer, offset);
719 uint32_t value = 0;
720 for (uint32_t i = 0; i < count; i++) {
721 if (!GetUInt32(buffer, offset, value)) {
722 MEDIA_ERR_LOG("MtpPacketTool::GetAUInt32, count=%{public}d, i=%{public}d", count, i);
723 break;
724 }
725 result->push_back(value);
726 }
727
728 return result;
729 }
730
GetString(const std::vector<uint8_t> & buffer,size_t & offset)731 std::string MtpPacketTool::GetString(const std::vector<uint8_t> &buffer, size_t &offset)
732 {
733 uint8_t count = GetUInt8(buffer, offset);
734 if (count < 1) {
735 return std::string();
736 }
737 std::vector<char16_t> tmpbuf(count);
738 uint16_t ch = 0;
739 for (int i = 0; i < count; i++) {
740 ch = GetUInt16(buffer, offset);
741 tmpbuf[i] = ch;
742 }
743 std::string String = Utf16ToUtf8(std::u16string(tmpbuf.data()));
744 return String;
745 }
746
GetString(const std::vector<uint8_t> & buffer,size_t & offset,std::string & str)747 bool MtpPacketTool::GetString(const std::vector<uint8_t> &buffer, size_t &offset, std::string &str)
748 {
749 uint8_t count = 0;
750 CHECK_AND_RETURN_RET(GetUInt8(buffer, offset, count), false);
751
752 if (count < 1) {
753 str = std::string();
754 return true;
755 }
756
757 std::vector<char16_t> tmpbuf(count);
758 uint16_t ch = 0;
759 for (int i = 0; ((i < count) && ((offset + sizeof(uint16_t) - 1) < buffer.size())); i++) {
760 CHECK_AND_RETURN_RET(GetUInt16(buffer, offset, ch), false);
761 tmpbuf[i] = ch;
762 }
763
764 str = Utf16ToUtf8(std::u16string(tmpbuf.data()));
765 return true;
766 }
767
FormatDateTime(time_t sec)768 std::string MtpPacketTool::FormatDateTime(time_t sec)
769 {
770 struct tm tm;
771 char buffer[TIME_LENGTH] = {0};
772 localtime_r(&sec, &tm);
773 if (sprintf_s(buffer, sizeof(buffer), "%04d%02d%02dT%02d%02d%02d", tm.tm_year + BEGIN_YEAR, tm.tm_mon + 1,
774 tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec) == -1) {
775 return "";
776 }
777 return std::string(buffer);
778 }
779
GetOperationName(uint16_t code)780 const std::string &MtpPacketTool::GetOperationName(uint16_t code)
781 {
782 return CodeToStrByMap(code, OperationMap);
783 }
784
GetFormatName(uint16_t code)785 const std::string &MtpPacketTool::GetFormatName(uint16_t code)
786 {
787 return CodeToStrByMap(code, FormatMap);
788 }
789
GetObjectPropName(uint16_t code)790 const std::string &MtpPacketTool::GetObjectPropName(uint16_t code)
791 {
792 return CodeToStrByMap(code, ObjectPropMap);
793 }
794
GetDataTypeName(int type)795 const std::string &MtpPacketTool::GetDataTypeName(int type)
796 {
797 return CodeToStrByMap(type, DataTypeMap);
798 }
799
GetEventName(uint16_t code)800 const std::string &MtpPacketTool::GetEventName(uint16_t code)
801 {
802 return CodeToStrByMap(code, EventMap);
803 }
804
GetAssociationName(int type)805 const std::string &MtpPacketTool::GetAssociationName(int type)
806 {
807 return CodeToStrByMap(type, AssociationMap);
808 }
809
CodeToStrByMap(int type,const std::map<int,std::string> & theMap)810 const std::string &MtpPacketTool::CodeToStrByMap(int type, const std::map<int, std::string> &theMap)
811 {
812 auto codeSearch = theMap.find(type);
813 return (codeSearch != theMap.end()) ? codeSearch->second : UNKNOWN_STR;
814 }
815
CodeToStrByMap(uint32_t code,const std::map<uint32_t,std::string> & theMap)816 const std::string &MtpPacketTool::CodeToStrByMap(uint32_t code, const std::map<uint32_t, std::string> &theMap)
817 {
818 auto codeSearch = theMap.find(code);
819 return (codeSearch != theMap.end()) ? codeSearch->second : UNKNOWN_STR;
820 }
821
GetObjectPropTypeByPropCode(uint16_t propCode)822 int MtpPacketTool::GetObjectPropTypeByPropCode(uint16_t propCode)
823 {
824 auto propCodeSearch = ObjectPropTypeMap.find(propCode);
825 return (propCodeSearch != ObjectPropTypeMap.end()) ? propCodeSearch->second : MTP_TYPE_UNDEFINED_CODE;
826 }
827
Int8ToString(const int8_t & value,std::string & outStr)828 bool MtpPacketTool::Int8ToString(const int8_t &value, std::string &outStr)
829 {
830 char tmpbuf[BIT_32] = {0};
831 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%02x, dec=%d", value, value) != -1, false);
832 outStr.assign(tmpbuf);
833 return true;
834 }
835
UInt8ToString(const uint8_t & value,std::string & outStr)836 bool MtpPacketTool::UInt8ToString(const uint8_t &value, std::string &outStr)
837 {
838 char tmpbuf[BIT_32] = {0};
839 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%02x, dec=%u", value, value) != -1, false);
840 outStr.assign(tmpbuf);
841 return true;
842 }
843
Int16ToString(const int16_t & value,std::string & outStr)844 bool MtpPacketTool::Int16ToString(const int16_t &value, std::string &outStr)
845 {
846 char tmpbuf[BIT_32] = {0};
847 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%04x, dec=%d", value, value) != -1, false);
848 outStr.assign(tmpbuf);
849 return true;
850 }
851
UInt16ToString(const uint16_t & value,std::string & outStr)852 bool MtpPacketTool::UInt16ToString(const uint16_t &value, std::string &outStr)
853 {
854 char tmpbuf[BIT_32] = {0};
855 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%04x, dec=%u", value, value) != -1, false);
856 outStr.assign(tmpbuf);
857 return true;
858 }
859
Int32ToString(const int32_t & value,std::string & outStr)860 bool MtpPacketTool::Int32ToString(const int32_t &value, std::string &outStr)
861 {
862 char tmpbuf[BIT_64] = {0};
863 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%08x, dec=%d", value, value) != -1, false);
864 outStr.assign(tmpbuf);
865 return true;
866 }
867
UInt32ToString(const uint32_t & value,std::string & outStr)868 bool MtpPacketTool::UInt32ToString(const uint32_t &value, std::string &outStr)
869 {
870 char tmpbuf[BIT_64] = {0};
871 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%08x, dec=%u", value, value) != -1, false);
872 outStr.assign(tmpbuf);
873 return true;
874 }
875
Int64ToString(const int64_t & value,std::string & outStr)876 bool MtpPacketTool::Int64ToString(const int64_t &value, std::string &outStr)
877 {
878 char tmpbuf[BIT_64] = {0};
879 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%016" PRIx64 ", dec=%" PRIi64 "",
880 value, value) != -1, false);
881 outStr.assign(tmpbuf);
882 return true;
883 }
884
UInt64ToString(const uint64_t & value,std::string & outStr)885 bool MtpPacketTool::UInt64ToString(const uint64_t &value, std::string &outStr)
886 {
887 char tmpbuf[BIT_64] = {0};
888 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%016" PRIx64 ", dec=%" PRIu64 "",
889 value, value) != -1, false);
890 outStr.assign(tmpbuf);
891 return true;
892 }
893
Int128ToString(const int128_t & value,std::string & outStr)894 bool MtpPacketTool::Int128ToString(const int128_t &value, std::string &outStr)
895 {
896 char tmpbuf[BIT_128] = {0};
897 CHECK_AND_RETURN_RET(sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=(%08x,%08x,%08x,%08x), dec=(%d,%d,%d,%d)",
898 value[OFFSET_0], value[OFFSET_1], value[OFFSET_2], value[OFFSET_3], value[OFFSET_0], value[OFFSET_1],
899 value[OFFSET_2], value[OFFSET_3]) != -1, false);
900 outStr.assign(tmpbuf);
901 return true;
902 }
903
UInt128ToString(const uint128_t & value,std::string & outStr)904 bool MtpPacketTool::UInt128ToString(const uint128_t &value, std::string &outStr)
905 {
906 char tmpbuf[BIT_128] = {0};
907 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=(%08x,%08x,%08x,%08x), dec=(%u,%u,%u,%u)", value[OFFSET_0],
908 value[OFFSET_1], value[OFFSET_2], value[OFFSET_3], value[OFFSET_0], value[OFFSET_1], value[OFFSET_2],
909 value[OFFSET_3]) == -1) {
910 return false;
911 }
912 outStr.assign(tmpbuf);
913 return true;
914 }
915
StrToString(const std::string & value)916 std::string MtpPacketTool::StrToString(const std::string &value)
917 {
918 std::string str;
919 str.append("length:");
920 str.append(std::to_string(value.length()));
921 str.append(", content:[");
922 str.append(value);
923 str.append("]");
924 return str;
925 }
926
GetIndentBlank()927 const std::string &MtpPacketTool::GetIndentBlank()
928 {
929 return INDENT_BLANKSTR;
930 }
931
GetIndentBlank(size_t indent)932 std::string MtpPacketTool::GetIndentBlank(size_t indent)
933 {
934 size_t maxNum = BLANK_STR.length();
935 size_t num = indent * INDENT_SIZE;
936
937 std::string indentStr = BLANK_STR.substr(0, ((num > maxNum) ? maxNum : num));
938 return indentStr;
939 }
940
CanDump()941 bool MtpPacketTool::CanDump()
942 {
943 std::string mtpShowDump = OHOS::system::GetParameter(KEY_MTP_SHOW_DUMP, MTP_SHOW_DUMP_DEFAULT);
944 return mtpShowDump.compare(ALLOW_SHOW_DUMP) == 0;
945 }
946
DumpPacket(const std::vector<uint8_t> & outBuffer)947 void MtpPacketTool::DumpPacket(const std::vector<uint8_t> &outBuffer)
948 {
949 if (!MtpPacketTool::CanDump()) {
950 MEDIA_DEBUG_LOG("MtpPacketTool::CanDump return false");
951 return;
952 }
953 int offset = 0;
954 uint32_t containerLength = MtpPacketTool::GetUInt32(outBuffer[offset], outBuffer[offset + OFFSET_1],
955 outBuffer[offset + OFFSET_2], outBuffer[offset + OFFSET_3]);
956 uint16_t containerType = MtpPacketTool::GetUInt16(outBuffer[offset + OFFSET_4],
957 outBuffer[offset + OFFSET_5]);
958 if (containerType == DATA_CONTAINER_TYPE) {
959 MEDIA_DEBUG_LOG("Packet type: %{public}d, Payload Size: %{public}d",
960 DATA_CONTAINER_TYPE, containerLength - PACKET_HEADER_LENGETH);
961 MtpPacketTool::Dump(outBuffer, 0, PACKET_HEADER_LENGETH);
962 } else {
963 MEDIA_DEBUG_LOG("Packet type: %{public}d, Packet size: %{public}d",
964 containerType, containerLength);
965 MtpPacketTool::Dump(outBuffer);
966 }
967 }
968
Dump(const std::vector<uint8_t> & data,uint32_t offset,uint32_t sum)969 void MtpPacketTool::Dump(const std::vector<uint8_t> &data, uint32_t offset, uint32_t sum)
970 {
971 CHECK_AND_RETURN_LOG(data.size() > 0, "Dump data is empty");
972
973 std::unique_ptr<char[]> hexBuf = std::make_unique<char[]>(DUMP_HEXBUF_MAX);
974 std::unique_ptr<char[]> txtBuf = std::make_unique<char[]>(DUMP_TXTBUF_MAX);
975 if (!DumpClear(offset, hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
976 return;
977 }
978 const size_t datasize = data.size();
979 for (size_t loc = 0, cur = offset; ((loc < sum) && (cur < datasize)); loc++, cur++) {
980 if (!DumpChar(data[cur], hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
981 return;
982 }
983 size_t idx = (loc & BUF_0F);
984 if (strcat_s(hexBuf.get(), DUMP_HEXBUF_MAX, ((idx != BUF_07) ? " " : "-")) != EOK) {
985 return;
986 }
987 if (idx != BUF_0F) {
988 continue;
989 }
990 DumpShow(hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX);
991 if (!DumpClear(loc + 1, hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
992 return;
993 }
994 }
995 DumpShow(hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX);
996 }
997
DumpClear(size_t loc,std::unique_ptr<char[]> & hexBuf,int hexBufSize,std::unique_ptr<char[]> & txtBuf,int txtBufSize)998 bool MtpPacketTool::DumpClear(size_t loc, std::unique_ptr<char[]> &hexBuf, int hexBufSize,
999 std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1000 {
1001 CHECK_AND_RETURN_RET(!((hexBuf == nullptr) || (txtBuf == nullptr)), false);
1002 CHECK_AND_RETURN_RET(sprintf_s(hexBuf.get(), hexBufSize, "%08X : ", static_cast<uint32_t>(loc)) != -1, false);
1003 CHECK_AND_RETURN_RET(sprintf_s(txtBuf.get(), txtBufSize, "%s", "") != -1, false);
1004 return true;
1005 }
1006
DumpChar(uint8_t u8,std::unique_ptr<char[]> & hexBuf,int hexBufSize,std::unique_ptr<char[]> & txtBuf,int txtBufSize)1007 bool MtpPacketTool::DumpChar(uint8_t u8, std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1008 std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1009 {
1010 bool cond = ((hexBuf == nullptr) || (txtBuf == nullptr));
1011 CHECK_AND_RETURN_RET(!cond, false);
1012
1013 char hexTmp[BIT_4] = {0};
1014 CHECK_AND_RETURN_RET(sprintf_s(hexTmp, sizeof(hexTmp), "%02X", u8) != -1, false);
1015
1016 int intData = static_cast<int>(u8);
1017 char txtTmp[BIT_4] = {0};
1018 if (isprint(intData)) {
1019 CHECK_AND_RETURN_RET(sprintf_s(txtTmp, sizeof(txtTmp), "%d", intData) != -1, false);
1020 } else {
1021 CHECK_AND_RETURN_RET(sprintf_s(txtTmp, sizeof(txtTmp), "%c", '.') != -1, false);
1022 }
1023
1024 CHECK_AND_RETURN_RET(strcat_s(hexBuf.get(), hexBufSize, hexTmp) == EOK, false);
1025 CHECK_AND_RETURN_RET(strcat_s(txtBuf.get(), txtBufSize, txtTmp) == EOK, false);
1026 return true;
1027 }
1028
DumpShow(const std::unique_ptr<char[]> & hexBuf,int hexBufSize,const std::unique_ptr<char[]> & txtBuf,int txtBufSize)1029 void MtpPacketTool::DumpShow(const std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1030 const std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1031 {
1032 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1033 return;
1034 }
1035 if ((hexBuf[OFFSET_0] == '\0') || (txtBuf[OFFSET_0] == '\0')) {
1036 return;
1037 }
1038
1039 MEDIA_DEBUG_LOG("%-60s %s", hexBuf.get(), txtBuf.get());
1040 }
1041 } // namespace Media
1042 } // namespace OHOS