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.

680 lines
16KB

  1. /*
  2. * Buffered I/O for ffmpeg system
  3. * Copyright (c) 2000,2001 Fabrice Bellard
  4. *
  5. * This library is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU Lesser General Public
  7. * License as published by the Free Software Foundation; either
  8. * version 2 of the License, or (at your option) any later version.
  9. *
  10. * This library is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. * Lesser General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU Lesser General Public
  16. * License along with this library; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18. */
  19. #include "avformat.h"
  20. #include <stdarg.h>
  21. #define IO_BUFFER_SIZE 32768
  22. int init_put_byte(ByteIOContext *s,
  23. unsigned char *buffer,
  24. int buffer_size,
  25. int write_flag,
  26. void *opaque,
  27. int (*read_packet)(void *opaque, UINT8 *buf, int buf_size),
  28. void (*write_packet)(void *opaque, UINT8 *buf, int buf_size),
  29. int (*seek)(void *opaque, offset_t offset, int whence))
  30. {
  31. s->buffer = buffer;
  32. s->buffer_size = buffer_size;
  33. s->buf_ptr = buffer;
  34. s->write_flag = write_flag;
  35. if (!s->write_flag)
  36. s->buf_end = buffer;
  37. else
  38. s->buf_end = buffer + buffer_size;
  39. s->opaque = opaque;
  40. s->write_packet = write_packet;
  41. s->read_packet = read_packet;
  42. s->seek = seek;
  43. s->pos = 0;
  44. s->must_flush = 0;
  45. s->eof_reached = 0;
  46. s->is_streamed = 0;
  47. s->max_packet_size = 0;
  48. return 0;
  49. }
  50. static void flush_buffer(ByteIOContext *s)
  51. {
  52. if (s->buf_ptr > s->buffer) {
  53. if (s->write_packet)
  54. s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
  55. s->pos += s->buf_ptr - s->buffer;
  56. }
  57. s->buf_ptr = s->buffer;
  58. }
  59. void put_byte(ByteIOContext *s, int b)
  60. {
  61. *(s->buf_ptr)++ = b;
  62. if (s->buf_ptr >= s->buf_end)
  63. flush_buffer(s);
  64. }
  65. void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
  66. {
  67. int len;
  68. while (size > 0) {
  69. len = (s->buf_end - s->buf_ptr);
  70. if (len > size)
  71. len = size;
  72. memcpy(s->buf_ptr, buf, len);
  73. s->buf_ptr += len;
  74. if (s->buf_ptr >= s->buf_end)
  75. flush_buffer(s);
  76. buf += len;
  77. size -= len;
  78. }
  79. }
  80. void put_flush_packet(ByteIOContext *s)
  81. {
  82. flush_buffer(s);
  83. s->must_flush = 0;
  84. }
  85. offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence)
  86. {
  87. offset_t offset1;
  88. if (whence != SEEK_CUR && whence != SEEK_SET)
  89. return -EINVAL;
  90. if (s->write_flag) {
  91. if (whence == SEEK_CUR) {
  92. offset1 = s->pos + (s->buf_ptr - s->buffer);
  93. if (offset == 0)
  94. return offset1;
  95. offset += offset1;
  96. }
  97. offset1 = offset - s->pos;
  98. if (!s->must_flush &&
  99. offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
  100. /* can do the seek inside the buffer */
  101. s->buf_ptr = s->buffer + offset1;
  102. } else {
  103. if (!s->seek)
  104. return -EPIPE;
  105. flush_buffer(s);
  106. s->must_flush = 1;
  107. s->buf_ptr = s->buffer;
  108. s->seek(s->opaque, offset, SEEK_SET);
  109. s->pos = offset;
  110. }
  111. } else {
  112. if (whence == SEEK_CUR) {
  113. offset1 = s->pos - (s->buf_end - s->buffer) + (s->buf_ptr - s->buffer);
  114. if (offset == 0)
  115. return offset1;
  116. offset += offset1;
  117. }
  118. offset1 = offset - (s->pos - (s->buf_end - s->buffer));
  119. if (offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
  120. /* can do the seek inside the buffer */
  121. s->buf_ptr = s->buffer + offset1;
  122. } else {
  123. if (!s->seek)
  124. return -EPIPE;
  125. s->buf_ptr = s->buffer;
  126. s->buf_end = s->buffer;
  127. s->seek(s->opaque, offset, SEEK_SET);
  128. s->pos = offset;
  129. }
  130. s->eof_reached = 0;
  131. }
  132. return offset;
  133. }
  134. void url_fskip(ByteIOContext *s, offset_t offset)
  135. {
  136. url_fseek(s, offset, SEEK_CUR);
  137. }
  138. offset_t url_ftell(ByteIOContext *s)
  139. {
  140. return url_fseek(s, 0, SEEK_CUR);
  141. }
  142. int url_feof(ByteIOContext *s)
  143. {
  144. return s->eof_reached;
  145. }
  146. void put_le32(ByteIOContext *s, unsigned int val)
  147. {
  148. put_byte(s, val);
  149. put_byte(s, val >> 8);
  150. put_byte(s, val >> 16);
  151. put_byte(s, val >> 24);
  152. }
  153. void put_be32(ByteIOContext *s, unsigned int val)
  154. {
  155. put_byte(s, val >> 24);
  156. put_byte(s, val >> 16);
  157. put_byte(s, val >> 8);
  158. put_byte(s, val);
  159. }
  160. void put_native_double(ByteIOContext *s, double val)
  161. {
  162. put_buffer(s, (const unsigned char *) &val, sizeof(val));
  163. }
  164. void put_native_string(ByteIOContext *s, const char *str)
  165. {
  166. if (str)
  167. put_buffer(s, (const unsigned char *) str, strlen(str) + 1);
  168. else
  169. put_byte(s, 0);
  170. }
  171. void put_le64(ByteIOContext *s, UINT64 val)
  172. {
  173. put_le32(s, (UINT32)(val & 0xffffffff));
  174. put_le32(s, (UINT32)(val >> 32));
  175. }
  176. void put_be64(ByteIOContext *s, UINT64 val)
  177. {
  178. put_be32(s, (UINT32)(val >> 32));
  179. put_be32(s, (UINT32)(val & 0xffffffff));
  180. }
  181. void put_le16(ByteIOContext *s, unsigned int val)
  182. {
  183. put_byte(s, val);
  184. put_byte(s, val >> 8);
  185. }
  186. void put_be16(ByteIOContext *s, unsigned int val)
  187. {
  188. put_byte(s, val >> 8);
  189. put_byte(s, val);
  190. }
  191. void put_tag(ByteIOContext *s, char *tag)
  192. {
  193. while (*tag) {
  194. put_byte(s, *tag++);
  195. }
  196. }
  197. /* Input stream */
  198. static void fill_buffer(ByteIOContext *s)
  199. {
  200. int len;
  201. /* no need to do anything if EOF already reached */
  202. if (s->eof_reached)
  203. return;
  204. len = s->read_packet(s->opaque, s->buffer, s->buffer_size);
  205. if (len <= 0) {
  206. /* do not modify buffer if EOF reached so that a seek back can
  207. be done without rereading data */
  208. s->eof_reached = 1;
  209. } else {
  210. s->pos += len;
  211. s->buf_ptr = s->buffer;
  212. s->buf_end = s->buffer + len;
  213. }
  214. }
  215. /* NOTE: return 0 if EOF, so you cannot use it if EOF handling is
  216. necessary */
  217. /* XXX: put an inline version */
  218. int get_byte(ByteIOContext *s)
  219. {
  220. if (s->buf_ptr < s->buf_end) {
  221. return *s->buf_ptr++;
  222. } else {
  223. fill_buffer(s);
  224. if (s->buf_ptr < s->buf_end)
  225. return *s->buf_ptr++;
  226. else
  227. return 0;
  228. }
  229. }
  230. /* NOTE: return URL_EOF (-1) if EOF */
  231. int url_fgetc(ByteIOContext *s)
  232. {
  233. if (s->buf_ptr < s->buf_end) {
  234. return *s->buf_ptr++;
  235. } else {
  236. fill_buffer(s);
  237. if (s->buf_ptr < s->buf_end)
  238. return *s->buf_ptr++;
  239. else
  240. return URL_EOF;
  241. }
  242. }
  243. int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
  244. {
  245. int len, size1;
  246. size1 = size;
  247. while (size > 0) {
  248. len = s->buf_end - s->buf_ptr;
  249. if (len > size)
  250. len = size;
  251. if (len == 0) {
  252. fill_buffer(s);
  253. len = s->buf_end - s->buf_ptr;
  254. if (len == 0)
  255. break;
  256. } else {
  257. memcpy(buf, s->buf_ptr, len);
  258. buf += len;
  259. s->buf_ptr += len;
  260. size -= len;
  261. }
  262. }
  263. return size1 - size;
  264. }
  265. unsigned int get_le16(ByteIOContext *s)
  266. {
  267. unsigned int val;
  268. val = get_byte(s);
  269. val |= get_byte(s) << 8;
  270. return val;
  271. }
  272. unsigned int get_le32(ByteIOContext *s)
  273. {
  274. unsigned int val;
  275. val = get_byte(s);
  276. val |= get_byte(s) << 8;
  277. val |= get_byte(s) << 16;
  278. val |= get_byte(s) << 24;
  279. return val;
  280. }
  281. UINT64 get_le64(ByteIOContext *s)
  282. {
  283. UINT64 val;
  284. val = (UINT64)get_le32(s);
  285. val |= (UINT64)get_le32(s) << 32;
  286. return val;
  287. }
  288. unsigned int get_be16(ByteIOContext *s)
  289. {
  290. unsigned int val;
  291. val = get_byte(s) << 8;
  292. val |= get_byte(s);
  293. return val;
  294. }
  295. unsigned int get_be32(ByteIOContext *s)
  296. {
  297. unsigned int val;
  298. val = get_byte(s) << 24;
  299. val |= get_byte(s) << 16;
  300. val |= get_byte(s) << 8;
  301. val |= get_byte(s);
  302. return val;
  303. }
  304. double get_native_double(ByteIOContext *s)
  305. {
  306. double val;
  307. get_buffer(s, (unsigned char *) &val, sizeof(val));
  308. return val;
  309. }
  310. char *get_native_string(ByteIOContext *s, char *buf, int maxlen)
  311. {
  312. int i = 0;
  313. char c;
  314. while ((c = get_byte(s))) {
  315. if (i < maxlen-1)
  316. buf[i++] = c;
  317. }
  318. buf[i] = 0; /* Ensure null terminated, but may be truncated */
  319. return buf;
  320. }
  321. UINT64 get_be64(ByteIOContext *s)
  322. {
  323. UINT64 val;
  324. val = (UINT64)get_be32(s) << 32;
  325. val |= (UINT64)get_be32(s);
  326. return val;
  327. }
  328. /* link with avio functions */
  329. void url_write_packet(void *opaque, UINT8 *buf, int buf_size)
  330. {
  331. URLContext *h = opaque;
  332. url_write(h, buf, buf_size);
  333. }
  334. int url_read_packet(void *opaque, UINT8 *buf, int buf_size)
  335. {
  336. URLContext *h = opaque;
  337. return url_read(h, buf, buf_size);
  338. }
  339. int url_seek_packet(void *opaque, INT64 offset, int whence)
  340. {
  341. URLContext *h = opaque;
  342. url_seek(h, offset, whence);
  343. return 0;
  344. }
  345. int url_fdopen(ByteIOContext *s, URLContext *h)
  346. {
  347. UINT8 *buffer;
  348. int buffer_size, max_packet_size;
  349. max_packet_size = url_get_max_packet_size(h);
  350. if (max_packet_size) {
  351. buffer_size = max_packet_size; /* no need to bufferize more than one packet */
  352. } else {
  353. buffer_size = IO_BUFFER_SIZE;
  354. }
  355. buffer = av_malloc(buffer_size);
  356. if (!buffer)
  357. return -ENOMEM;
  358. if (init_put_byte(s, buffer, buffer_size,
  359. (h->flags & URL_WRONLY) != 0, h,
  360. url_read_packet, url_write_packet, url_seek_packet) < 0) {
  361. av_free(buffer);
  362. return -EIO;
  363. }
  364. s->is_streamed = h->is_streamed;
  365. s->max_packet_size = max_packet_size;
  366. return 0;
  367. }
  368. /* XXX: must be called before any I/O */
  369. int url_setbufsize(ByteIOContext *s, int buf_size)
  370. {
  371. UINT8 *buffer;
  372. buffer = av_malloc(buf_size);
  373. if (!buffer)
  374. return -ENOMEM;
  375. av_free(s->buffer);
  376. s->buffer = buffer;
  377. s->buffer_size = buf_size;
  378. s->buf_ptr = buffer;
  379. if (!s->write_flag)
  380. s->buf_end = buffer;
  381. else
  382. s->buf_end = buffer + buf_size;
  383. return 0;
  384. }
  385. /* NOTE: when opened as read/write, the buffers are only used for
  386. reading */
  387. int url_fopen(ByteIOContext *s, const char *filename, int flags)
  388. {
  389. URLContext *h;
  390. int err;
  391. err = url_open(&h, filename, flags);
  392. if (err < 0)
  393. return err;
  394. err = url_fdopen(s, h);
  395. if (err < 0) {
  396. url_close(h);
  397. return err;
  398. }
  399. return 0;
  400. }
  401. int url_fclose(ByteIOContext *s)
  402. {
  403. URLContext *h = s->opaque;
  404. av_free(s->buffer);
  405. memset(s, 0, sizeof(ByteIOContext));
  406. return url_close(h);
  407. }
  408. URLContext *url_fileno(ByteIOContext *s)
  409. {
  410. return s->opaque;
  411. }
  412. /* XXX: currently size is limited */
  413. int url_fprintf(ByteIOContext *s, const char *fmt, ...)
  414. {
  415. va_list ap;
  416. char buf[4096];
  417. int ret;
  418. va_start(ap, fmt);
  419. ret = vsnprintf(buf, sizeof(buf), fmt, ap);
  420. va_end(ap);
  421. put_buffer(s, buf, strlen(buf));
  422. return ret;
  423. }
  424. /* note: unlike fgets, the EOL character is not returned and a whole
  425. line is parsed. return NULL if first char read was EOF */
  426. char *url_fgets(ByteIOContext *s, char *buf, int buf_size)
  427. {
  428. int c;
  429. char *q;
  430. c = url_fgetc(s);
  431. if (c == EOF)
  432. return NULL;
  433. q = buf;
  434. for(;;) {
  435. if (c == EOF || c == '\n')
  436. break;
  437. if ((q - buf) < buf_size - 1)
  438. *q++ = c;
  439. c = url_fgetc(s);
  440. }
  441. if (buf_size > 0)
  442. *q = '\0';
  443. return buf;
  444. }
  445. /*
  446. * Return the maximum packet size associated to packetized buffered file
  447. * handle. If the file is not packetized (stream like http or file on
  448. * disk), then 0 is returned.
  449. *
  450. * @param h buffered file handle
  451. * @return maximum packet size in bytes
  452. */
  453. int url_fget_max_packet_size(ByteIOContext *s)
  454. {
  455. return s->max_packet_size;
  456. }
  457. /* buffer handling */
  458. int url_open_buf(ByteIOContext *s, UINT8 *buf, int buf_size, int flags)
  459. {
  460. return init_put_byte(s, buf, buf_size,
  461. (flags & URL_WRONLY) != 0, NULL, NULL, NULL, NULL);
  462. }
  463. /* return the written or read size */
  464. int url_close_buf(ByteIOContext *s)
  465. {
  466. put_flush_packet(s);
  467. return s->buf_ptr - s->buffer;
  468. }
  469. /* output in a dynamic buffer */
  470. typedef struct DynBuffer {
  471. int pos, size, allocated_size;
  472. UINT8 *buffer;
  473. int io_buffer_size;
  474. UINT8 io_buffer[1];
  475. } DynBuffer;
  476. static void dyn_buf_write(void *opaque, UINT8 *buf, int buf_size)
  477. {
  478. DynBuffer *d = opaque;
  479. int new_size, new_allocated_size;
  480. UINT8 *new_buffer;
  481. /* reallocate buffer if needed */
  482. new_size = d->pos + buf_size;
  483. new_allocated_size = d->allocated_size;
  484. while (new_size > new_allocated_size) {
  485. if (!new_allocated_size)
  486. new_allocated_size = new_size;
  487. else
  488. new_allocated_size = (new_allocated_size * 3) / 2 + 1;
  489. }
  490. if (new_allocated_size > d->allocated_size) {
  491. new_buffer = av_malloc(new_allocated_size);
  492. if (!new_buffer)
  493. return;
  494. memcpy(new_buffer, d->buffer, d->size);
  495. av_free(d->buffer);
  496. d->buffer = new_buffer;
  497. d->allocated_size = new_allocated_size;
  498. }
  499. memcpy(d->buffer + d->pos, buf, buf_size);
  500. d->pos = new_size;
  501. if (d->pos > d->size)
  502. d->size = d->pos;
  503. }
  504. static void dyn_packet_buf_write(void *opaque, UINT8 *buf, int buf_size)
  505. {
  506. unsigned char buf1[4];
  507. /* packetized write: output the header */
  508. buf1[0] = (buf_size >> 24);
  509. buf1[1] = (buf_size >> 16);
  510. buf1[2] = (buf_size >> 8);
  511. buf1[3] = (buf_size);
  512. dyn_buf_write(opaque, buf1, 4);
  513. /* then the data */
  514. dyn_buf_write(opaque, buf, buf_size);
  515. }
  516. static int dyn_buf_seek(void *opaque, offset_t offset, int whence)
  517. {
  518. DynBuffer *d = opaque;
  519. if (whence == SEEK_CUR)
  520. offset += d->pos;
  521. else if (whence == SEEK_END)
  522. offset += d->size;
  523. if (offset < 0 || offset > 0x7fffffffLL)
  524. return -1;
  525. d->pos = offset;
  526. return 0;
  527. }
  528. static int url_open_dyn_buf_internal(ByteIOContext *s, int max_packet_size)
  529. {
  530. DynBuffer *d;
  531. int io_buffer_size, ret;
  532. if (max_packet_size)
  533. io_buffer_size = max_packet_size;
  534. else
  535. io_buffer_size = 1024;
  536. d = av_malloc(sizeof(DynBuffer) + io_buffer_size);
  537. if (!d)
  538. return -1;
  539. d->io_buffer_size = io_buffer_size;
  540. d->buffer = NULL;
  541. d->pos = 0;
  542. d->size = 0;
  543. d->allocated_size = 0;
  544. ret = init_put_byte(s, d->io_buffer, io_buffer_size,
  545. 1, d, NULL,
  546. max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
  547. max_packet_size ? NULL : dyn_buf_seek);
  548. if (ret == 0) {
  549. s->max_packet_size = max_packet_size;
  550. }
  551. return ret;
  552. }
  553. /*
  554. * Open a write only memory stream.
  555. *
  556. * @param s new IO context
  557. * @return zero if no error.
  558. */
  559. int url_open_dyn_buf(ByteIOContext *s)
  560. {
  561. return url_open_dyn_buf_internal(s, 0);
  562. }
  563. /*
  564. * Open a write only packetized memory stream with a maximum packet
  565. * size of 'max_packet_size'. The stream is stored in a memory buffer
  566. * with a big endian 4 byte header giving the packet size in bytes.
  567. *
  568. * @param s new IO context
  569. * @param max_packet_size maximum packet size (must be > 0)
  570. * @return zero if no error.
  571. */
  572. int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size)
  573. {
  574. if (max_packet_size <= 0)
  575. return -1;
  576. return url_open_dyn_buf_internal(s, max_packet_size);
  577. }
  578. /*
  579. * Return the written size and a pointer to the buffer. The buffer
  580. * must be freed with av_free().
  581. * @param s IO context
  582. * @param pointer to a byte buffer
  583. * @return the length of the byte buffer
  584. */
  585. int url_close_dyn_buf(ByteIOContext *s, UINT8 **pbuffer)
  586. {
  587. DynBuffer *d = s->opaque;
  588. int size;
  589. put_flush_packet(s);
  590. *pbuffer = d->buffer;
  591. size = d->size;
  592. av_free(d);
  593. return size;
  594. }