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.

766 lines
18KB

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