You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

854 lines
20KB

  1. /*
  2. * Buffered I/O for ffmpeg system
  3. * Copyright (c) 2000,2001 Fabrice Bellard
  4. *
  5. * This file is part of FFmpeg.
  6. *
  7. * FFmpeg is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU Lesser General Public
  9. * License as published by the Free Software Foundation; either
  10. * version 2.1 of the License, or (at your option) any later version.
  11. *
  12. * FFmpeg is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15. * Lesser General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU Lesser General Public
  18. * License along with FFmpeg; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20. */
  21. #include "libavutil/crc.h"
  22. #include "libavutil/intreadwrite.h"
  23. #include "avformat.h"
  24. #include "avio.h"
  25. #include <stdarg.h>
  26. #define IO_BUFFER_SIZE 32768
  27. static void fill_buffer(ByteIOContext *s);
  28. #if LIBAVFORMAT_VERSION_MAJOR >= 53
  29. static int url_resetbuf(ByteIOContext *s, int flags);
  30. #endif
  31. int init_put_byte(ByteIOContext *s,
  32. unsigned char *buffer,
  33. int buffer_size,
  34. int write_flag,
  35. void *opaque,
  36. int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
  37. int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
  38. int64_t (*seek)(void *opaque, int64_t offset, int whence))
  39. {
  40. s->buffer = buffer;
  41. s->buffer_size = buffer_size;
  42. s->buf_ptr = buffer;
  43. s->opaque = opaque;
  44. url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY);
  45. s->write_packet = write_packet;
  46. s->read_packet = read_packet;
  47. s->seek = seek;
  48. s->pos = 0;
  49. s->must_flush = 0;
  50. s->eof_reached = 0;
  51. s->error = 0;
  52. s->is_streamed = 0;
  53. s->max_packet_size = 0;
  54. s->update_checksum= NULL;
  55. if(!read_packet && !write_flag){
  56. s->pos = buffer_size;
  57. s->buf_end = s->buffer + buffer_size;
  58. }
  59. s->read_pause = NULL;
  60. s->read_seek = NULL;
  61. return 0;
  62. }
  63. ByteIOContext *av_alloc_put_byte(
  64. unsigned char *buffer,
  65. int buffer_size,
  66. int write_flag,
  67. void *opaque,
  68. int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
  69. int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
  70. int64_t (*seek)(void *opaque, int64_t offset, int whence))
  71. {
  72. ByteIOContext *s = av_mallocz(sizeof(ByteIOContext));
  73. init_put_byte(s, buffer, buffer_size, write_flag, opaque,
  74. read_packet, write_packet, seek);
  75. return s;
  76. }
  77. static void flush_buffer(ByteIOContext *s)
  78. {
  79. if (s->buf_ptr > s->buffer) {
  80. if (s->write_packet && !s->error){
  81. int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
  82. if(ret < 0){
  83. s->error = ret;
  84. }
  85. }
  86. if(s->update_checksum){
  87. s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
  88. s->checksum_ptr= s->buffer;
  89. }
  90. s->pos += s->buf_ptr - s->buffer;
  91. }
  92. s->buf_ptr = s->buffer;
  93. }
  94. void put_byte(ByteIOContext *s, int b)
  95. {
  96. *(s->buf_ptr)++ = b;
  97. if (s->buf_ptr >= s->buf_end)
  98. flush_buffer(s);
  99. }
  100. void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
  101. {
  102. while (size > 0) {
  103. int len = FFMIN(s->buf_end - s->buf_ptr, size);
  104. memcpy(s->buf_ptr, buf, len);
  105. s->buf_ptr += len;
  106. if (s->buf_ptr >= s->buf_end)
  107. flush_buffer(s);
  108. buf += len;
  109. size -= len;
  110. }
  111. }
  112. void put_flush_packet(ByteIOContext *s)
  113. {
  114. flush_buffer(s);
  115. s->must_flush = 0;
  116. }
  117. int64_t url_fseek(ByteIOContext *s, int64_t offset, int whence)
  118. {
  119. int64_t offset1;
  120. int64_t pos;
  121. if(!s)
  122. return AVERROR(EINVAL);
  123. pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
  124. if (whence != SEEK_CUR && whence != SEEK_SET)
  125. return AVERROR(EINVAL);
  126. if (whence == SEEK_CUR) {
  127. offset1 = pos + (s->buf_ptr - s->buffer);
  128. if (offset == 0)
  129. return offset1;
  130. offset += offset1;
  131. }
  132. offset1 = offset - pos;
  133. if (!s->must_flush &&
  134. offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
  135. /* can do the seek inside the buffer */
  136. s->buf_ptr = s->buffer + offset1;
  137. } else if(s->is_streamed && !s->write_flag && offset1 >= 0 &&
  138. ( offset1 < (s->buf_end - s->buffer) + (1<<16)
  139. || (whence & AVSEEK_FORCE))){
  140. while(s->pos < offset && !s->eof_reached)
  141. fill_buffer(s);
  142. if (s->eof_reached)
  143. return AVERROR_EOF;
  144. s->buf_ptr = s->buf_end + offset - s->pos;
  145. } else {
  146. int64_t res = AVERROR(EPIPE);
  147. #if CONFIG_MUXERS || CONFIG_NETWORK
  148. if (s->write_flag) {
  149. flush_buffer(s);
  150. s->must_flush = 1;
  151. }
  152. #endif /* CONFIG_MUXERS || CONFIG_NETWORK */
  153. if (!s->seek || (res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
  154. return res;
  155. if (!s->write_flag)
  156. s->buf_end = s->buffer;
  157. s->buf_ptr = s->buffer;
  158. s->pos = offset;
  159. }
  160. s->eof_reached = 0;
  161. return offset;
  162. }
  163. void url_fskip(ByteIOContext *s, int64_t offset)
  164. {
  165. url_fseek(s, offset, SEEK_CUR);
  166. }
  167. int64_t url_ftell(ByteIOContext *s)
  168. {
  169. return url_fseek(s, 0, SEEK_CUR);
  170. }
  171. int64_t url_fsize(ByteIOContext *s)
  172. {
  173. int64_t size;
  174. if(!s)
  175. return AVERROR(EINVAL);
  176. if (!s->seek)
  177. return AVERROR(EPIPE);
  178. size = s->seek(s->opaque, 0, AVSEEK_SIZE);
  179. if(size<0){
  180. if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
  181. return size;
  182. size++;
  183. s->seek(s->opaque, s->pos, SEEK_SET);
  184. }
  185. return size;
  186. }
  187. int url_feof(ByteIOContext *s)
  188. {
  189. if(!s)
  190. return 0;
  191. return s->eof_reached;
  192. }
  193. int url_ferror(ByteIOContext *s)
  194. {
  195. if(!s)
  196. return 0;
  197. return s->error;
  198. }
  199. void put_le32(ByteIOContext *s, unsigned int val)
  200. {
  201. put_byte(s, val);
  202. put_byte(s, val >> 8);
  203. put_byte(s, val >> 16);
  204. put_byte(s, val >> 24);
  205. }
  206. void put_be32(ByteIOContext *s, unsigned int val)
  207. {
  208. put_byte(s, val >> 24);
  209. put_byte(s, val >> 16);
  210. put_byte(s, val >> 8);
  211. put_byte(s, val);
  212. }
  213. void put_strz(ByteIOContext *s, const char *str)
  214. {
  215. if (str)
  216. put_buffer(s, (const unsigned char *) str, strlen(str) + 1);
  217. else
  218. put_byte(s, 0);
  219. }
  220. void put_le64(ByteIOContext *s, uint64_t val)
  221. {
  222. put_le32(s, (uint32_t)(val & 0xffffffff));
  223. put_le32(s, (uint32_t)(val >> 32));
  224. }
  225. void put_be64(ByteIOContext *s, uint64_t val)
  226. {
  227. put_be32(s, (uint32_t)(val >> 32));
  228. put_be32(s, (uint32_t)(val & 0xffffffff));
  229. }
  230. void put_le16(ByteIOContext *s, unsigned int val)
  231. {
  232. put_byte(s, val);
  233. put_byte(s, val >> 8);
  234. }
  235. void put_be16(ByteIOContext *s, unsigned int val)
  236. {
  237. put_byte(s, val >> 8);
  238. put_byte(s, val);
  239. }
  240. void put_le24(ByteIOContext *s, unsigned int val)
  241. {
  242. put_le16(s, val & 0xffff);
  243. put_byte(s, val >> 16);
  244. }
  245. void put_be24(ByteIOContext *s, unsigned int val)
  246. {
  247. put_be16(s, val >> 8);
  248. put_byte(s, val);
  249. }
  250. void put_tag(ByteIOContext *s, const char *tag)
  251. {
  252. while (*tag) {
  253. put_byte(s, *tag++);
  254. }
  255. }
  256. /* Input stream */
  257. static void fill_buffer(ByteIOContext *s)
  258. {
  259. uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_ptr : s->buffer;
  260. int len= s->buffer_size - (dst - s->buffer);
  261. assert(s->buf_ptr == s->buf_end);
  262. /* no need to do anything if EOF already reached */
  263. if (s->eof_reached)
  264. return;
  265. if(s->update_checksum && dst == s->buffer){
  266. if(s->buf_end > s->checksum_ptr)
  267. s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr);
  268. s->checksum_ptr= s->buffer;
  269. }
  270. if(s->read_packet)
  271. len = s->read_packet(s->opaque, dst, len);
  272. else
  273. len = 0;
  274. if (len <= 0) {
  275. /* do not modify buffer if EOF reached so that a seek back can
  276. be done without rereading data */
  277. s->eof_reached = 1;
  278. if(len<0)
  279. s->error= len;
  280. } else {
  281. s->pos += len;
  282. s->buf_ptr = dst;
  283. s->buf_end = dst + len;
  284. }
  285. }
  286. unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
  287. unsigned int len)
  288. {
  289. return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
  290. }
  291. unsigned long get_checksum(ByteIOContext *s)
  292. {
  293. s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
  294. s->update_checksum= NULL;
  295. return s->checksum;
  296. }
  297. void init_checksum(ByteIOContext *s,
  298. unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
  299. unsigned long checksum)
  300. {
  301. s->update_checksum= update_checksum;
  302. if(s->update_checksum){
  303. s->checksum= checksum;
  304. s->checksum_ptr= s->buf_ptr;
  305. }
  306. }
  307. /* XXX: put an inline version */
  308. int get_byte(ByteIOContext *s)
  309. {
  310. if (s->buf_ptr < s->buf_end) {
  311. return *s->buf_ptr++;
  312. } else {
  313. fill_buffer(s);
  314. if (s->buf_ptr < s->buf_end)
  315. return *s->buf_ptr++;
  316. else
  317. return 0;
  318. }
  319. }
  320. int url_fgetc(ByteIOContext *s)
  321. {
  322. if (s->buf_ptr < s->buf_end) {
  323. return *s->buf_ptr++;
  324. } else {
  325. fill_buffer(s);
  326. if (s->buf_ptr < s->buf_end)
  327. return *s->buf_ptr++;
  328. else
  329. return URL_EOF;
  330. }
  331. }
  332. int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
  333. {
  334. int len, size1;
  335. size1 = size;
  336. while (size > 0) {
  337. len = s->buf_end - s->buf_ptr;
  338. if (len > size)
  339. len = size;
  340. if (len == 0) {
  341. if(size > s->buffer_size && !s->update_checksum){
  342. if(s->read_packet)
  343. len = s->read_packet(s->opaque, buf, size);
  344. if (len <= 0) {
  345. /* do not modify buffer if EOF reached so that a seek back can
  346. be done without rereading data */
  347. s->eof_reached = 1;
  348. if(len<0)
  349. s->error= len;
  350. break;
  351. } else {
  352. s->pos += len;
  353. size -= len;
  354. buf += len;
  355. s->buf_ptr = s->buffer;
  356. s->buf_end = s->buffer/* + len*/;
  357. }
  358. }else{
  359. fill_buffer(s);
  360. len = s->buf_end - s->buf_ptr;
  361. if (len == 0)
  362. break;
  363. }
  364. } else {
  365. memcpy(buf, s->buf_ptr, len);
  366. buf += len;
  367. s->buf_ptr += len;
  368. size -= len;
  369. }
  370. }
  371. if (size1 == size) {
  372. if (url_ferror(s)) return url_ferror(s);
  373. if (url_feof(s)) return AVERROR_EOF;
  374. }
  375. return size1 - size;
  376. }
  377. int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size)
  378. {
  379. int len;
  380. if(size<0)
  381. return -1;
  382. len = s->buf_end - s->buf_ptr;
  383. if (len == 0) {
  384. fill_buffer(s);
  385. len = s->buf_end - s->buf_ptr;
  386. }
  387. if (len > size)
  388. len = size;
  389. memcpy(buf, s->buf_ptr, len);
  390. s->buf_ptr += len;
  391. if (!len) {
  392. if (url_ferror(s)) return url_ferror(s);
  393. if (url_feof(s)) return AVERROR_EOF;
  394. }
  395. return len;
  396. }
  397. unsigned int get_le16(ByteIOContext *s)
  398. {
  399. unsigned int val;
  400. val = get_byte(s);
  401. val |= get_byte(s) << 8;
  402. return val;
  403. }
  404. unsigned int get_le24(ByteIOContext *s)
  405. {
  406. unsigned int val;
  407. val = get_le16(s);
  408. val |= get_byte(s) << 16;
  409. return val;
  410. }
  411. unsigned int get_le32(ByteIOContext *s)
  412. {
  413. unsigned int val;
  414. val = get_le16(s);
  415. val |= get_le16(s) << 16;
  416. return val;
  417. }
  418. uint64_t get_le64(ByteIOContext *s)
  419. {
  420. uint64_t val;
  421. val = (uint64_t)get_le32(s);
  422. val |= (uint64_t)get_le32(s) << 32;
  423. return val;
  424. }
  425. unsigned int get_be16(ByteIOContext *s)
  426. {
  427. unsigned int val;
  428. val = get_byte(s) << 8;
  429. val |= get_byte(s);
  430. return val;
  431. }
  432. unsigned int get_be24(ByteIOContext *s)
  433. {
  434. unsigned int val;
  435. val = get_be16(s) << 8;
  436. val |= get_byte(s);
  437. return val;
  438. }
  439. unsigned int get_be32(ByteIOContext *s)
  440. {
  441. unsigned int val;
  442. val = get_be16(s) << 16;
  443. val |= get_be16(s);
  444. return val;
  445. }
  446. char *get_strz(ByteIOContext *s, char *buf, int maxlen)
  447. {
  448. int i = 0;
  449. char c;
  450. while ((c = get_byte(s))) {
  451. if (i < maxlen-1)
  452. buf[i++] = c;
  453. }
  454. buf[i] = 0; /* Ensure null terminated, but may be truncated */
  455. return buf;
  456. }
  457. uint64_t get_be64(ByteIOContext *s)
  458. {
  459. uint64_t val;
  460. val = (uint64_t)get_be32(s) << 32;
  461. val |= (uint64_t)get_be32(s);
  462. return val;
  463. }
  464. uint64_t ff_get_v(ByteIOContext *bc){
  465. uint64_t val = 0;
  466. int tmp;
  467. do{
  468. tmp = get_byte(bc);
  469. val= (val<<7) + (tmp&127);
  470. }while(tmp&128);
  471. return val;
  472. }
  473. int url_fdopen(ByteIOContext **s, URLContext *h)
  474. {
  475. uint8_t *buffer;
  476. int buffer_size, max_packet_size;
  477. max_packet_size = url_get_max_packet_size(h);
  478. if (max_packet_size) {
  479. buffer_size = max_packet_size; /* no need to bufferize more than one packet */
  480. } else {
  481. buffer_size = IO_BUFFER_SIZE;
  482. }
  483. buffer = av_malloc(buffer_size);
  484. if (!buffer)
  485. return AVERROR(ENOMEM);
  486. *s = av_mallocz(sizeof(ByteIOContext));
  487. if(!*s) {
  488. av_free(buffer);
  489. return AVERROR(ENOMEM);
  490. }
  491. if (init_put_byte(*s, buffer, buffer_size,
  492. (h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
  493. url_read, url_write, url_seek) < 0) {
  494. av_free(buffer);
  495. av_freep(s);
  496. return AVERROR(EIO);
  497. }
  498. (*s)->is_streamed = h->is_streamed;
  499. (*s)->max_packet_size = max_packet_size;
  500. if(h->prot) {
  501. (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
  502. (*s)->read_seek = (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;
  503. }
  504. return 0;
  505. }
  506. int url_setbufsize(ByteIOContext *s, int buf_size)
  507. {
  508. uint8_t *buffer;
  509. buffer = av_malloc(buf_size);
  510. if (!buffer)
  511. return AVERROR(ENOMEM);
  512. av_free(s->buffer);
  513. s->buffer = buffer;
  514. s->buffer_size = buf_size;
  515. s->buf_ptr = buffer;
  516. url_resetbuf(s, s->write_flag ? URL_WRONLY : URL_RDONLY);
  517. return 0;
  518. }
  519. #if LIBAVFORMAT_VERSION_MAJOR < 53
  520. int url_resetbuf(ByteIOContext *s, int flags)
  521. #else
  522. static int url_resetbuf(ByteIOContext *s, int flags)
  523. #endif
  524. {
  525. #if LIBAVFORMAT_VERSION_MAJOR < 53
  526. URLContext *h = s->opaque;
  527. if ((flags & URL_RDWR) || (h && h->flags != flags && !h->flags & URL_RDWR))
  528. return AVERROR(EINVAL);
  529. #else
  530. assert(flags == URL_WRONLY || flags == URL_RDONLY);
  531. #endif
  532. if (flags & URL_WRONLY) {
  533. s->buf_end = s->buffer + s->buffer_size;
  534. s->write_flag = 1;
  535. } else {
  536. s->buf_end = s->buffer;
  537. s->write_flag = 0;
  538. }
  539. return 0;
  540. }
  541. int url_fopen(ByteIOContext **s, const char *filename, int flags)
  542. {
  543. URLContext *h;
  544. int err;
  545. err = url_open(&h, filename, flags);
  546. if (err < 0)
  547. return err;
  548. err = url_fdopen(s, h);
  549. if (err < 0) {
  550. url_close(h);
  551. return err;
  552. }
  553. return 0;
  554. }
  555. int url_fclose(ByteIOContext *s)
  556. {
  557. URLContext *h = s->opaque;
  558. av_free(s->buffer);
  559. av_free(s);
  560. return url_close(h);
  561. }
  562. URLContext *url_fileno(ByteIOContext *s)
  563. {
  564. return s->opaque;
  565. }
  566. #if CONFIG_MUXERS
  567. int url_fprintf(ByteIOContext *s, const char *fmt, ...)
  568. {
  569. va_list ap;
  570. char buf[4096];
  571. int ret;
  572. va_start(ap, fmt);
  573. ret = vsnprintf(buf, sizeof(buf), fmt, ap);
  574. va_end(ap);
  575. put_buffer(s, buf, strlen(buf));
  576. return ret;
  577. }
  578. #endif //CONFIG_MUXERS
  579. char *url_fgets(ByteIOContext *s, char *buf, int buf_size)
  580. {
  581. int c;
  582. char *q;
  583. c = url_fgetc(s);
  584. if (c == EOF)
  585. return NULL;
  586. q = buf;
  587. for(;;) {
  588. if (c == EOF || c == '\n')
  589. break;
  590. if ((q - buf) < buf_size - 1)
  591. *q++ = c;
  592. c = url_fgetc(s);
  593. }
  594. if (buf_size > 0)
  595. *q = '\0';
  596. return buf;
  597. }
  598. int url_fget_max_packet_size(ByteIOContext *s)
  599. {
  600. return s->max_packet_size;
  601. }
  602. int av_url_read_fpause(ByteIOContext *s, int pause)
  603. {
  604. if (!s->read_pause)
  605. return AVERROR(ENOSYS);
  606. return s->read_pause(s->opaque, pause);
  607. }
  608. int64_t av_url_read_fseek(ByteIOContext *s, int stream_index,
  609. int64_t timestamp, int flags)
  610. {
  611. URLContext *h = s->opaque;
  612. int64_t ret;
  613. if (!s->read_seek)
  614. return AVERROR(ENOSYS);
  615. ret = s->read_seek(h, stream_index, timestamp, flags);
  616. if(ret >= 0) {
  617. s->buf_ptr = s->buf_end; // Flush buffer
  618. s->pos = s->seek(h, 0, SEEK_CUR);
  619. }
  620. return ret;
  621. }
  622. /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
  623. * back to the server even if CONFIG_MUXERS is false. */
  624. #if CONFIG_MUXERS || CONFIG_NETWORK
  625. /* buffer handling */
  626. int url_open_buf(ByteIOContext **s, uint8_t *buf, int buf_size, int flags)
  627. {
  628. int ret;
  629. *s = av_mallocz(sizeof(ByteIOContext));
  630. if(!*s)
  631. return AVERROR(ENOMEM);
  632. ret = init_put_byte(*s, buf, buf_size,
  633. (flags & URL_WRONLY || flags & URL_RDWR),
  634. NULL, NULL, NULL, NULL);
  635. if(ret != 0)
  636. av_freep(s);
  637. return ret;
  638. }
  639. int url_close_buf(ByteIOContext *s)
  640. {
  641. put_flush_packet(s);
  642. return s->buf_ptr - s->buffer;
  643. }
  644. /* output in a dynamic buffer */
  645. typedef struct DynBuffer {
  646. int pos, size, allocated_size;
  647. uint8_t *buffer;
  648. int io_buffer_size;
  649. uint8_t io_buffer[1];
  650. } DynBuffer;
  651. static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
  652. {
  653. DynBuffer *d = opaque;
  654. unsigned new_size, new_allocated_size;
  655. /* reallocate buffer if needed */
  656. new_size = d->pos + buf_size;
  657. new_allocated_size = d->allocated_size;
  658. if(new_size < d->pos || new_size > INT_MAX/2)
  659. return -1;
  660. while (new_size > new_allocated_size) {
  661. if (!new_allocated_size)
  662. new_allocated_size = new_size;
  663. else
  664. new_allocated_size += new_allocated_size / 2 + 1;
  665. }
  666. if (new_allocated_size > d->allocated_size) {
  667. d->buffer = av_realloc(d->buffer, new_allocated_size);
  668. if(d->buffer == NULL)
  669. return AVERROR(ENOMEM);
  670. d->allocated_size = new_allocated_size;
  671. }
  672. memcpy(d->buffer + d->pos, buf, buf_size);
  673. d->pos = new_size;
  674. if (d->pos > d->size)
  675. d->size = d->pos;
  676. return buf_size;
  677. }
  678. static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
  679. {
  680. unsigned char buf1[4];
  681. int ret;
  682. /* packetized write: output the header */
  683. AV_WB32(buf1, buf_size);
  684. ret= dyn_buf_write(opaque, buf1, 4);
  685. if(ret < 0)
  686. return ret;
  687. /* then the data */
  688. return dyn_buf_write(opaque, buf, buf_size);
  689. }
  690. static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
  691. {
  692. DynBuffer *d = opaque;
  693. if (whence == SEEK_CUR)
  694. offset += d->pos;
  695. else if (whence == SEEK_END)
  696. offset += d->size;
  697. if (offset < 0 || offset > 0x7fffffffLL)
  698. return -1;
  699. d->pos = offset;
  700. return 0;
  701. }
  702. static int url_open_dyn_buf_internal(ByteIOContext **s, int max_packet_size)
  703. {
  704. DynBuffer *d;
  705. int ret;
  706. unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
  707. if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
  708. return -1;
  709. d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
  710. if (!d)
  711. return AVERROR(ENOMEM);
  712. *s = av_mallocz(sizeof(ByteIOContext));
  713. if(!*s) {
  714. av_free(d);
  715. return AVERROR(ENOMEM);
  716. }
  717. d->io_buffer_size = io_buffer_size;
  718. ret = init_put_byte(*s, d->io_buffer, io_buffer_size,
  719. 1, d, NULL,
  720. max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
  721. max_packet_size ? NULL : dyn_buf_seek);
  722. if (ret == 0) {
  723. (*s)->max_packet_size = max_packet_size;
  724. } else {
  725. av_free(d);
  726. av_freep(s);
  727. }
  728. return ret;
  729. }
  730. int url_open_dyn_buf(ByteIOContext **s)
  731. {
  732. return url_open_dyn_buf_internal(s, 0);
  733. }
  734. int url_open_dyn_packet_buf(ByteIOContext **s, int max_packet_size)
  735. {
  736. if (max_packet_size <= 0)
  737. return -1;
  738. return url_open_dyn_buf_internal(s, max_packet_size);
  739. }
  740. int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
  741. {
  742. DynBuffer *d = s->opaque;
  743. int size;
  744. put_flush_packet(s);
  745. *pbuffer = d->buffer;
  746. size = d->size;
  747. av_free(d);
  748. av_free(s);
  749. return size;
  750. }
  751. #endif /* CONFIG_MUXERS || CONFIG_NETWORK */