stream_peer.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722
  1. /**************************************************************************/
  2. /* stream_peer.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #include "stream_peer.h"
  31. #include "core/io/marshalls.h"
  32. Error StreamPeer::_put_data(const Vector<uint8_t> &p_data) {
  33. int len = p_data.size();
  34. if (len == 0) {
  35. return OK;
  36. }
  37. const uint8_t *r = p_data.ptr();
  38. return put_data(&r[0], len);
  39. }
  40. Array StreamPeer::_put_partial_data(const Vector<uint8_t> &p_data) {
  41. Array ret;
  42. int len = p_data.size();
  43. if (len == 0) {
  44. ret.push_back(OK);
  45. ret.push_back(0);
  46. return ret;
  47. }
  48. const uint8_t *r = p_data.ptr();
  49. int sent;
  50. Error err = put_partial_data(&r[0], len, sent);
  51. if (err != OK) {
  52. sent = 0;
  53. }
  54. ret.push_back(err);
  55. ret.push_back(sent);
  56. return ret;
  57. }
  58. Array StreamPeer::_get_data(int p_bytes) {
  59. Array ret;
  60. Vector<uint8_t> data;
  61. data.resize(p_bytes);
  62. if (data.size() != p_bytes) {
  63. ret.push_back(ERR_OUT_OF_MEMORY);
  64. ret.push_back(Vector<uint8_t>());
  65. return ret;
  66. }
  67. uint8_t *w = data.ptrw();
  68. Error err = get_data(&w[0], p_bytes);
  69. ret.push_back(err);
  70. ret.push_back(data);
  71. return ret;
  72. }
  73. Array StreamPeer::_get_partial_data(int p_bytes) {
  74. Array ret;
  75. Vector<uint8_t> data;
  76. data.resize(p_bytes);
  77. if (data.size() != p_bytes) {
  78. ret.push_back(ERR_OUT_OF_MEMORY);
  79. ret.push_back(Vector<uint8_t>());
  80. return ret;
  81. }
  82. uint8_t *w = data.ptrw();
  83. int received;
  84. Error err = get_partial_data(&w[0], p_bytes, received);
  85. if (err != OK) {
  86. data.clear();
  87. } else if (received != data.size()) {
  88. data.resize(received);
  89. }
  90. ret.push_back(err);
  91. ret.push_back(data);
  92. return ret;
  93. }
  94. void StreamPeer::set_big_endian(bool p_big_endian) {
  95. big_endian = p_big_endian;
  96. }
  97. bool StreamPeer::is_big_endian_enabled() const {
  98. return big_endian;
  99. }
  100. void StreamPeer::put_u8(uint8_t p_val) {
  101. put_data((const uint8_t *)&p_val, 1);
  102. }
  103. void StreamPeer::put_8(int8_t p_val) {
  104. put_data((const uint8_t *)&p_val, 1);
  105. }
  106. void StreamPeer::put_u16(uint16_t p_val) {
  107. #ifdef BIG_ENDIAN_ENABLED
  108. if (!big_endian) {
  109. p_val = BSWAP16(p_val);
  110. }
  111. #else
  112. if (big_endian) {
  113. p_val = BSWAP16(p_val);
  114. }
  115. #endif
  116. uint8_t buf[2];
  117. encode_uint16(p_val, buf);
  118. put_data(buf, 2);
  119. }
  120. void StreamPeer::put_16(int16_t p_val) {
  121. #ifdef BIG_ENDIAN_ENABLED
  122. if (!big_endian) {
  123. p_val = BSWAP16(p_val);
  124. }
  125. #else
  126. if (big_endian) {
  127. p_val = BSWAP16(p_val);
  128. }
  129. #endif
  130. uint8_t buf[2];
  131. encode_uint16(p_val, buf);
  132. put_data(buf, 2);
  133. }
  134. void StreamPeer::put_u32(uint32_t p_val) {
  135. #ifdef BIG_ENDIAN_ENABLED
  136. if (!big_endian) {
  137. p_val = BSWAP32(p_val);
  138. }
  139. #else
  140. if (big_endian) {
  141. p_val = BSWAP32(p_val);
  142. }
  143. #endif
  144. uint8_t buf[4];
  145. encode_uint32(p_val, buf);
  146. put_data(buf, 4);
  147. }
  148. void StreamPeer::put_32(int32_t p_val) {
  149. #ifdef BIG_ENDIAN_ENABLED
  150. if (!big_endian) {
  151. p_val = BSWAP32(p_val);
  152. }
  153. #else
  154. if (big_endian) {
  155. p_val = BSWAP32(p_val);
  156. }
  157. #endif
  158. uint8_t buf[4];
  159. encode_uint32(p_val, buf);
  160. put_data(buf, 4);
  161. }
  162. void StreamPeer::put_u64(uint64_t p_val) {
  163. #ifdef BIG_ENDIAN_ENABLED
  164. if (!big_endian) {
  165. p_val = BSWAP64(p_val);
  166. }
  167. #else
  168. if (big_endian) {
  169. p_val = BSWAP64(p_val);
  170. }
  171. #endif
  172. uint8_t buf[8];
  173. encode_uint64(p_val, buf);
  174. put_data(buf, 8);
  175. }
  176. void StreamPeer::put_64(int64_t p_val) {
  177. #ifdef BIG_ENDIAN_ENABLED
  178. if (!big_endian) {
  179. p_val = BSWAP64(p_val);
  180. }
  181. #else
  182. if (big_endian) {
  183. p_val = BSWAP64(p_val);
  184. }
  185. #endif
  186. uint8_t buf[8];
  187. encode_uint64(p_val, buf);
  188. put_data(buf, 8);
  189. }
  190. void StreamPeer::put_half(float p_val) {
  191. uint8_t buf[2];
  192. encode_half(p_val, buf);
  193. uint16_t *p16 = (uint16_t *)buf;
  194. #ifdef BIG_ENDIAN_ENABLED
  195. if (!big_endian) {
  196. *p16 = BSWAP16(*p16);
  197. }
  198. #else
  199. if (big_endian) {
  200. *p16 = BSWAP16(*p16);
  201. }
  202. #endif
  203. put_data(buf, 2);
  204. }
  205. void StreamPeer::put_float(float p_val) {
  206. uint8_t buf[4];
  207. encode_float(p_val, buf);
  208. #ifdef BIG_ENDIAN_ENABLED
  209. if (!big_endian) {
  210. uint32_t *p32 = (uint32_t *)buf;
  211. *p32 = BSWAP32(*p32);
  212. }
  213. #else
  214. if (big_endian) {
  215. uint32_t *p32 = (uint32_t *)buf;
  216. *p32 = BSWAP32(*p32);
  217. }
  218. #endif
  219. put_data(buf, 4);
  220. }
  221. void StreamPeer::put_double(double p_val) {
  222. uint8_t buf[8];
  223. encode_double(p_val, buf);
  224. #ifdef BIG_ENDIAN_ENABLED
  225. if (!big_endian) {
  226. uint64_t *p64 = (uint64_t *)buf;
  227. *p64 = BSWAP64(*p64);
  228. }
  229. #else
  230. if (big_endian) {
  231. uint64_t *p64 = (uint64_t *)buf;
  232. *p64 = BSWAP64(*p64);
  233. }
  234. #endif
  235. put_data(buf, 8);
  236. }
  237. void StreamPeer::put_string(const String &p_string) {
  238. CharString cs = p_string.ascii();
  239. put_u32(cs.length());
  240. put_data((const uint8_t *)cs.get_data(), cs.length());
  241. }
  242. void StreamPeer::put_utf8_string(const String &p_string) {
  243. CharString cs = p_string.utf8();
  244. put_u32(cs.length());
  245. put_data((const uint8_t *)cs.get_data(), cs.length());
  246. }
  247. void StreamPeer::put_var(const Variant &p_variant, bool p_full_objects) {
  248. int len = 0;
  249. Vector<uint8_t> buf;
  250. encode_variant(p_variant, nullptr, len, p_full_objects);
  251. buf.resize(len);
  252. put_32(len);
  253. encode_variant(p_variant, buf.ptrw(), len, p_full_objects);
  254. put_data(buf.ptr(), buf.size());
  255. }
  256. uint8_t StreamPeer::get_u8() {
  257. uint8_t buf[1] = {};
  258. get_data(buf, 1);
  259. return buf[0];
  260. }
  261. int8_t StreamPeer::get_8() {
  262. uint8_t buf[1] = {};
  263. get_data(buf, 1);
  264. return int8_t(buf[0]);
  265. }
  266. uint16_t StreamPeer::get_u16() {
  267. uint8_t buf[2];
  268. get_data(buf, 2);
  269. uint16_t r = decode_uint16(buf);
  270. #ifdef BIG_ENDIAN_ENABLED
  271. if (!big_endian) {
  272. r = BSWAP16(r);
  273. }
  274. #else
  275. if (big_endian) {
  276. r = BSWAP16(r);
  277. }
  278. #endif
  279. return r;
  280. }
  281. int16_t StreamPeer::get_16() {
  282. uint8_t buf[2];
  283. get_data(buf, 2);
  284. uint16_t r = decode_uint16(buf);
  285. #ifdef BIG_ENDIAN_ENABLED
  286. if (!big_endian) {
  287. r = BSWAP16(r);
  288. }
  289. #else
  290. if (big_endian) {
  291. r = BSWAP16(r);
  292. }
  293. #endif
  294. return int16_t(r);
  295. }
  296. uint32_t StreamPeer::get_u32() {
  297. uint8_t buf[4];
  298. get_data(buf, 4);
  299. uint32_t r = decode_uint32(buf);
  300. #ifdef BIG_ENDIAN_ENABLED
  301. if (!big_endian) {
  302. r = BSWAP32(r);
  303. }
  304. #else
  305. if (big_endian) {
  306. r = BSWAP32(r);
  307. }
  308. #endif
  309. return r;
  310. }
  311. int32_t StreamPeer::get_32() {
  312. uint8_t buf[4];
  313. get_data(buf, 4);
  314. uint32_t r = decode_uint32(buf);
  315. #ifdef BIG_ENDIAN_ENABLED
  316. if (!big_endian) {
  317. r = BSWAP32(r);
  318. }
  319. #else
  320. if (big_endian) {
  321. r = BSWAP32(r);
  322. }
  323. #endif
  324. return int32_t(r);
  325. }
  326. uint64_t StreamPeer::get_u64() {
  327. uint8_t buf[8];
  328. get_data(buf, 8);
  329. uint64_t r = decode_uint64(buf);
  330. #ifdef BIG_ENDIAN_ENABLED
  331. if (!big_endian) {
  332. r = BSWAP64(r);
  333. }
  334. #else
  335. if (big_endian) {
  336. r = BSWAP64(r);
  337. }
  338. #endif
  339. return r;
  340. }
  341. int64_t StreamPeer::get_64() {
  342. uint8_t buf[8];
  343. get_data(buf, 8);
  344. uint64_t r = decode_uint64(buf);
  345. #ifdef BIG_ENDIAN_ENABLED
  346. if (!big_endian) {
  347. r = BSWAP64(r);
  348. }
  349. #else
  350. if (big_endian) {
  351. r = BSWAP64(r);
  352. }
  353. #endif
  354. return int64_t(r);
  355. }
  356. float StreamPeer::get_half() {
  357. uint8_t buf[2];
  358. get_data(buf, 2);
  359. #ifdef BIG_ENDIAN_ENABLED
  360. if (!big_endian) {
  361. uint16_t *p16 = (uint16_t *)buf;
  362. *p16 = BSWAP16(*p16);
  363. }
  364. #else
  365. if (big_endian) {
  366. uint16_t *p16 = (uint16_t *)buf;
  367. *p16 = BSWAP16(*p16);
  368. }
  369. #endif
  370. return decode_half(buf);
  371. }
  372. float StreamPeer::get_float() {
  373. uint8_t buf[4];
  374. get_data(buf, 4);
  375. #ifdef BIG_ENDIAN_ENABLED
  376. if (!big_endian) {
  377. uint32_t *p32 = (uint32_t *)buf;
  378. *p32 = BSWAP32(*p32);
  379. }
  380. #else
  381. if (big_endian) {
  382. uint32_t *p32 = (uint32_t *)buf;
  383. *p32 = BSWAP32(*p32);
  384. }
  385. #endif
  386. return decode_float(buf);
  387. }
  388. double StreamPeer::get_double() {
  389. uint8_t buf[8];
  390. get_data(buf, 8);
  391. #ifdef BIG_ENDIAN_ENABLED
  392. if (!big_endian) {
  393. uint64_t *p64 = (uint64_t *)buf;
  394. *p64 = BSWAP64(*p64);
  395. }
  396. #else
  397. if (big_endian) {
  398. uint64_t *p64 = (uint64_t *)buf;
  399. *p64 = BSWAP64(*p64);
  400. }
  401. #endif
  402. return decode_double(buf);
  403. }
  404. String StreamPeer::get_string(int p_bytes) {
  405. if (p_bytes < 0) {
  406. p_bytes = get_32();
  407. }
  408. ERR_FAIL_COND_V(p_bytes < 0, String());
  409. Vector<char> buf;
  410. Error err = buf.resize(p_bytes + 1);
  411. ERR_FAIL_COND_V(err != OK, String());
  412. err = get_data((uint8_t *)&buf[0], p_bytes);
  413. ERR_FAIL_COND_V(err != OK, String());
  414. buf.write[p_bytes] = 0;
  415. return buf.ptr();
  416. }
  417. String StreamPeer::get_utf8_string(int p_bytes) {
  418. if (p_bytes < 0) {
  419. p_bytes = get_32();
  420. }
  421. ERR_FAIL_COND_V(p_bytes < 0, String());
  422. Vector<uint8_t> buf;
  423. Error err = buf.resize(p_bytes);
  424. ERR_FAIL_COND_V(err != OK, String());
  425. err = get_data(buf.ptrw(), p_bytes);
  426. ERR_FAIL_COND_V(err != OK, String());
  427. return String::utf8((const char *)buf.ptr(), buf.size());
  428. }
  429. Variant StreamPeer::get_var(bool p_allow_objects) {
  430. int len = get_32();
  431. Vector<uint8_t> var;
  432. Error err = var.resize(len);
  433. ERR_FAIL_COND_V(err != OK, Variant());
  434. err = get_data(var.ptrw(), len);
  435. ERR_FAIL_COND_V(err != OK, Variant());
  436. Variant ret;
  437. err = decode_variant(ret, var.ptr(), len, nullptr, p_allow_objects);
  438. ERR_FAIL_COND_V_MSG(err != OK, Variant(), "Error when trying to decode Variant.");
  439. return ret;
  440. }
  441. void StreamPeer::_bind_methods() {
  442. ClassDB::bind_method(D_METHOD("put_data", "data"), &StreamPeer::_put_data);
  443. ClassDB::bind_method(D_METHOD("put_partial_data", "data"), &StreamPeer::_put_partial_data);
  444. ClassDB::bind_method(D_METHOD("get_data", "bytes"), &StreamPeer::_get_data);
  445. ClassDB::bind_method(D_METHOD("get_partial_data", "bytes"), &StreamPeer::_get_partial_data);
  446. ClassDB::bind_method(D_METHOD("get_available_bytes"), &StreamPeer::get_available_bytes);
  447. ClassDB::bind_method(D_METHOD("set_big_endian", "enable"), &StreamPeer::set_big_endian);
  448. ClassDB::bind_method(D_METHOD("is_big_endian_enabled"), &StreamPeer::is_big_endian_enabled);
  449. ClassDB::bind_method(D_METHOD("put_8", "value"), &StreamPeer::put_8);
  450. ClassDB::bind_method(D_METHOD("put_u8", "value"), &StreamPeer::put_u8);
  451. ClassDB::bind_method(D_METHOD("put_16", "value"), &StreamPeer::put_16);
  452. ClassDB::bind_method(D_METHOD("put_u16", "value"), &StreamPeer::put_u16);
  453. ClassDB::bind_method(D_METHOD("put_32", "value"), &StreamPeer::put_32);
  454. ClassDB::bind_method(D_METHOD("put_u32", "value"), &StreamPeer::put_u32);
  455. ClassDB::bind_method(D_METHOD("put_64", "value"), &StreamPeer::put_64);
  456. ClassDB::bind_method(D_METHOD("put_u64", "value"), &StreamPeer::put_u64);
  457. ClassDB::bind_method(D_METHOD("put_half", "value"), &StreamPeer::put_half);
  458. ClassDB::bind_method(D_METHOD("put_float", "value"), &StreamPeer::put_float);
  459. ClassDB::bind_method(D_METHOD("put_double", "value"), &StreamPeer::put_double);
  460. ClassDB::bind_method(D_METHOD("put_string", "value"), &StreamPeer::put_string);
  461. ClassDB::bind_method(D_METHOD("put_utf8_string", "value"), &StreamPeer::put_utf8_string);
  462. ClassDB::bind_method(D_METHOD("put_var", "value", "full_objects"), &StreamPeer::put_var, DEFVAL(false));
  463. ClassDB::bind_method(D_METHOD("get_8"), &StreamPeer::get_8);
  464. ClassDB::bind_method(D_METHOD("get_u8"), &StreamPeer::get_u8);
  465. ClassDB::bind_method(D_METHOD("get_16"), &StreamPeer::get_16);
  466. ClassDB::bind_method(D_METHOD("get_u16"), &StreamPeer::get_u16);
  467. ClassDB::bind_method(D_METHOD("get_32"), &StreamPeer::get_32);
  468. ClassDB::bind_method(D_METHOD("get_u32"), &StreamPeer::get_u32);
  469. ClassDB::bind_method(D_METHOD("get_64"), &StreamPeer::get_64);
  470. ClassDB::bind_method(D_METHOD("get_u64"), &StreamPeer::get_u64);
  471. ClassDB::bind_method(D_METHOD("get_half"), &StreamPeer::get_half);
  472. ClassDB::bind_method(D_METHOD("get_float"), &StreamPeer::get_float);
  473. ClassDB::bind_method(D_METHOD("get_double"), &StreamPeer::get_double);
  474. ClassDB::bind_method(D_METHOD("get_string", "bytes"), &StreamPeer::get_string, DEFVAL(-1));
  475. ClassDB::bind_method(D_METHOD("get_utf8_string", "bytes"), &StreamPeer::get_utf8_string, DEFVAL(-1));
  476. ClassDB::bind_method(D_METHOD("get_var", "allow_objects"), &StreamPeer::get_var, DEFVAL(false));
  477. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "big_endian"), "set_big_endian", "is_big_endian_enabled");
  478. }
  479. ////////////////////////////////
  480. Error StreamPeerExtension::get_data(uint8_t *r_buffer, int p_bytes) {
  481. Error err;
  482. int received = 0;
  483. if (GDVIRTUAL_CALL(_get_data, r_buffer, p_bytes, &received, err)) {
  484. return err;
  485. }
  486. WARN_PRINT_ONCE("StreamPeerExtension::_get_data is unimplemented!");
  487. return FAILED;
  488. }
  489. Error StreamPeerExtension::get_partial_data(uint8_t *r_buffer, int p_bytes, int &r_received) {
  490. Error err;
  491. if (GDVIRTUAL_CALL(_get_partial_data, r_buffer, p_bytes, &r_received, err)) {
  492. return err;
  493. }
  494. WARN_PRINT_ONCE("StreamPeerExtension::_get_partial_data is unimplemented!");
  495. return FAILED;
  496. }
  497. Error StreamPeerExtension::put_data(const uint8_t *p_data, int p_bytes) {
  498. Error err;
  499. int sent = 0;
  500. if (GDVIRTUAL_CALL(_put_data, p_data, p_bytes, &sent, err)) {
  501. return err;
  502. }
  503. WARN_PRINT_ONCE("StreamPeerExtension::_put_data is unimplemented!");
  504. return FAILED;
  505. }
  506. Error StreamPeerExtension::put_partial_data(const uint8_t *p_data, int p_bytes, int &r_sent) {
  507. Error err;
  508. if (GDVIRTUAL_CALL(_put_partial_data, p_data, p_bytes, &r_sent, err)) {
  509. return err;
  510. }
  511. WARN_PRINT_ONCE("StreamPeerExtension::_put_partial_data is unimplemented!");
  512. return FAILED;
  513. }
  514. void StreamPeerExtension::_bind_methods() {
  515. GDVIRTUAL_BIND(_get_data, "r_buffer", "r_bytes", "r_received");
  516. GDVIRTUAL_BIND(_get_partial_data, "r_buffer", "r_bytes", "r_received");
  517. GDVIRTUAL_BIND(_put_data, "p_data", "p_bytes", "r_sent");
  518. GDVIRTUAL_BIND(_put_partial_data, "p_data", "p_bytes", "r_sent");
  519. GDVIRTUAL_BIND(_get_available_bytes);
  520. }
  521. ////////////////////////////////
  522. void StreamPeerBuffer::_bind_methods() {
  523. ClassDB::bind_method(D_METHOD("seek", "position"), &StreamPeerBuffer::seek);
  524. ClassDB::bind_method(D_METHOD("get_size"), &StreamPeerBuffer::get_size);
  525. ClassDB::bind_method(D_METHOD("get_position"), &StreamPeerBuffer::get_position);
  526. ClassDB::bind_method(D_METHOD("resize", "size"), &StreamPeerBuffer::resize);
  527. ClassDB::bind_method(D_METHOD("set_data_array", "data"), &StreamPeerBuffer::set_data_array);
  528. ClassDB::bind_method(D_METHOD("get_data_array"), &StreamPeerBuffer::get_data_array);
  529. ClassDB::bind_method(D_METHOD("clear"), &StreamPeerBuffer::clear);
  530. ClassDB::bind_method(D_METHOD("duplicate"), &StreamPeerBuffer::duplicate);
  531. ADD_PROPERTY(PropertyInfo(Variant::PACKED_BYTE_ARRAY, "data_array"), "set_data_array", "get_data_array");
  532. }
  533. Error StreamPeerBuffer::put_data(const uint8_t *p_data, int p_bytes) {
  534. if (p_bytes <= 0 || !p_data) {
  535. return OK;
  536. }
  537. if (pointer + p_bytes > data.size()) {
  538. data.resize(pointer + p_bytes);
  539. }
  540. uint8_t *w = data.ptrw();
  541. memcpy(&w[pointer], p_data, p_bytes);
  542. pointer += p_bytes;
  543. return OK;
  544. }
  545. Error StreamPeerBuffer::put_partial_data(const uint8_t *p_data, int p_bytes, int &r_sent) {
  546. r_sent = p_bytes;
  547. return put_data(p_data, p_bytes);
  548. }
  549. Error StreamPeerBuffer::get_data(uint8_t *p_buffer, int p_bytes) {
  550. int recv;
  551. get_partial_data(p_buffer, p_bytes, recv);
  552. if (recv != p_bytes) {
  553. return ERR_INVALID_PARAMETER;
  554. }
  555. return OK;
  556. }
  557. Error StreamPeerBuffer::get_partial_data(uint8_t *p_buffer, int p_bytes, int &r_received) {
  558. if (!p_bytes) {
  559. r_received = 0;
  560. return OK;
  561. }
  562. if (pointer + p_bytes > data.size()) {
  563. r_received = data.size() - pointer;
  564. if (r_received <= 0) {
  565. r_received = 0;
  566. return OK; //you got 0
  567. }
  568. } else {
  569. r_received = p_bytes;
  570. }
  571. const uint8_t *r = data.ptr();
  572. memcpy(p_buffer, r + pointer, r_received);
  573. pointer += r_received;
  574. // FIXME: return what? OK or ERR_*
  575. // return OK for now so we don't maybe return garbage
  576. return OK;
  577. }
  578. int StreamPeerBuffer::get_available_bytes() const {
  579. return data.size() - pointer;
  580. }
  581. void StreamPeerBuffer::seek(int p_pos) {
  582. ERR_FAIL_COND(p_pos < 0);
  583. ERR_FAIL_COND(p_pos > data.size());
  584. pointer = p_pos;
  585. }
  586. int StreamPeerBuffer::get_size() const {
  587. return data.size();
  588. }
  589. int StreamPeerBuffer::get_position() const {
  590. return pointer;
  591. }
  592. void StreamPeerBuffer::resize(int p_size) {
  593. data.resize(p_size);
  594. }
  595. void StreamPeerBuffer::set_data_array(const Vector<uint8_t> &p_data) {
  596. data = p_data;
  597. pointer = 0;
  598. }
  599. Vector<uint8_t> StreamPeerBuffer::get_data_array() const {
  600. return data;
  601. }
  602. void StreamPeerBuffer::clear() {
  603. data.clear();
  604. pointer = 0;
  605. }
  606. Ref<StreamPeerBuffer> StreamPeerBuffer::duplicate() const {
  607. Ref<StreamPeerBuffer> spb;
  608. spb.instantiate();
  609. spb->data = data;
  610. return spb;
  611. }