FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aviobuf.c
Go to the documentation of this file.
1 /*
2  * buffered I/O
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 
22 #include "libavutil/bprint.h"
23 #include "libavutil/crc.h"
24 #include "libavutil/dict.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/log.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/avassert.h"
29 #include "avformat.h"
30 #include "avio.h"
31 #include "avio_internal.h"
32 #include "internal.h"
33 #include "url.h"
34 #include <stdarg.h>
35 
36 #define IO_BUFFER_SIZE 32768
37 
38 /**
39  * Do seeks within this distance ahead of the current buffer by skipping
40  * data instead of calling the protocol seek function, for seekable
41  * protocols.
42  */
43 #define SHORT_SEEK_THRESHOLD 4096
44 
45 typedef struct AVIOInternal {
47 } AVIOInternal;
48 
49 static void *ff_avio_child_next(void *obj, void *prev)
50 {
51  AVIOContext *s = obj;
52  AVIOInternal *internal = s->opaque;
53  return prev ? NULL : internal->h;
54 }
55 
56 static const AVClass *ff_avio_child_class_next(const AVClass *prev)
57 {
58  return prev ? NULL : &ffurl_context_class;
59 }
60 
61 #define OFFSET(x) offsetof(AVIOContext,x)
62 #define E AV_OPT_FLAG_ENCODING_PARAM
63 #define D AV_OPT_FLAG_DECODING_PARAM
64 static const AVOption ff_avio_options[] = {
65  {"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, CHAR_MIN, CHAR_MAX, D },
66  { NULL },
67 };
68 
70  .class_name = "AVIOContext",
71  .item_name = av_default_item_name,
72  .version = LIBAVUTIL_VERSION_INT,
73  .option = ff_avio_options,
74  .child_next = ff_avio_child_next,
75  .child_class_next = ff_avio_child_class_next,
76 };
77 
78 static void fill_buffer(AVIOContext *s);
79 static int url_resetbuf(AVIOContext *s, int flags);
80 
82  unsigned char *buffer,
83  int buffer_size,
84  int write_flag,
85  void *opaque,
86  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
87  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
88  int64_t (*seek)(void *opaque, int64_t offset, int whence))
89 {
90  s->buffer = buffer;
91  s->orig_buffer_size =
92  s->buffer_size = buffer_size;
93  s->buf_ptr = buffer;
94  s->buf_ptr_max = buffer;
95  s->opaque = opaque;
96  s->direct = 0;
97 
98  url_resetbuf(s, write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
99 
102  s->seek = seek;
103  s->pos = 0;
104  s->eof_reached = 0;
105  s->error = 0;
106  s->seekable = seek ? AVIO_SEEKABLE_NORMAL : 0;
107  s->min_packet_size = 0;
108  s->max_packet_size = 0;
109  s->update_checksum = NULL;
111 
112  if (!read_packet && !write_flag) {
113  s->pos = buffer_size;
114  s->buf_end = s->buffer + buffer_size;
115  }
116  s->read_pause = NULL;
117  s->read_seek = NULL;
118 
119  s->write_data_type = NULL;
120  s->ignore_boundary_point = 0;
123  s->short_seek_get = NULL;
124  s->written = 0;
125 
126  return 0;
127 }
128 
130  unsigned char *buffer,
131  int buffer_size,
132  int write_flag,
133  void *opaque,
134  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
135  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
136  int64_t (*seek)(void *opaque, int64_t offset, int whence))
137 {
138  AVIOContext *s = av_mallocz(sizeof(AVIOContext));
139  if (!s)
140  return NULL;
141  ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
142  read_packet, write_packet, seek);
143  return s;
144 }
145 
146 static void writeout(AVIOContext *s, const uint8_t *data, int len)
147 {
148  if (!s->error) {
149  int ret = 0;
150  if (s->write_data_type)
151  ret = s->write_data_type(s->opaque, (uint8_t *)data,
152  len,
153  s->current_type,
154  s->last_time);
155  else if (s->write_packet)
156  ret = s->write_packet(s->opaque, (uint8_t *)data, len);
157  if (ret < 0) {
158  s->error = ret;
159  } else {
160  if (s->pos + len > s->written)
161  s->written = s->pos + len;
162  }
163  }
167  }
169  s->writeout_count ++;
170  s->pos += len;
171 }
172 
173 static void flush_buffer(AVIOContext *s)
174 {
175  s->buf_ptr_max = FFMAX(s->buf_ptr, s->buf_ptr_max);
176  if (s->write_flag && s->buf_ptr_max > s->buffer) {
177  writeout(s, s->buffer, s->buf_ptr_max - s->buffer);
178  if (s->update_checksum) {
180  s->buf_ptr_max - s->checksum_ptr);
181  s->checksum_ptr = s->buffer;
182  }
183  }
184  s->buf_ptr = s->buf_ptr_max = s->buffer;
185  if (!s->write_flag)
186  s->buf_end = s->buffer;
187 }
188 
189 void avio_w8(AVIOContext *s, int b)
190 {
191  av_assert2(b>=-128 && b<=255);
192  *s->buf_ptr++ = b;
193  if (s->buf_ptr >= s->buf_end)
194  flush_buffer(s);
195 }
196 
197 void ffio_fill(AVIOContext *s, int b, int count)
198 {
199  while (count > 0) {
200  int len = FFMIN(s->buf_end - s->buf_ptr, count);
201  memset(s->buf_ptr, b, len);
202  s->buf_ptr += len;
203 
204  if (s->buf_ptr >= s->buf_end)
205  flush_buffer(s);
206 
207  count -= len;
208  }
209 }
210 
211 void avio_write(AVIOContext *s, const unsigned char *buf, int size)
212 {
213  if (s->direct && !s->update_checksum) {
214  avio_flush(s);
215  writeout(s, buf, size);
216  return;
217  }
218  while (size > 0) {
219  int len = FFMIN(s->buf_end - s->buf_ptr, size);
220  memcpy(s->buf_ptr, buf, len);
221  s->buf_ptr += len;
222 
223  if (s->buf_ptr >= s->buf_end)
224  flush_buffer(s);
225 
226  buf += len;
227  size -= len;
228  }
229 }
230 
232 {
233  int seekback = s->write_flag ? FFMIN(0, s->buf_ptr - s->buf_ptr_max) : 0;
234  flush_buffer(s);
235  if (seekback)
236  avio_seek(s, seekback, SEEK_CUR);
237 }
238 
239 int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
240 {
241  int64_t offset1;
242  int64_t pos;
243  int force = whence & AVSEEK_FORCE;
244  int buffer_size;
245  int short_seek;
246  whence &= ~AVSEEK_FORCE;
247 
248  if(!s)
249  return AVERROR(EINVAL);
250 
251  buffer_size = s->buf_end - s->buffer;
252  // pos is the absolute position that the beginning of s->buffer corresponds to in the file
253  pos = s->pos - (s->write_flag ? 0 : buffer_size);
254 
255  if (whence != SEEK_CUR && whence != SEEK_SET)
256  return AVERROR(EINVAL);
257 
258  if (whence == SEEK_CUR) {
259  offset1 = pos + (s->buf_ptr - s->buffer);
260  if (offset == 0)
261  return offset1;
262  offset += offset1;
263  }
264  if (offset < 0)
265  return AVERROR(EINVAL);
266 
267  if (s->short_seek_get) {
268  short_seek = s->short_seek_get(s->opaque);
269  /* fallback to default short seek */
270  if (short_seek <= 0)
271  short_seek = s->short_seek_threshold;
272  } else
273  short_seek = s->short_seek_threshold;
274 
275  offset1 = offset - pos; // "offset1" is the relative offset from the beginning of s->buffer
276  s->buf_ptr_max = FFMAX(s->buf_ptr_max, s->buf_ptr);
277  if ((!s->direct || !s->seek) &&
278  offset1 >= 0 && offset1 <= (s->write_flag ? s->buf_ptr_max - s->buffer : buffer_size)) {
279  /* can do the seek inside the buffer */
280  s->buf_ptr = s->buffer + offset1;
281  } else if ((!(s->seekable & AVIO_SEEKABLE_NORMAL) ||
282  offset1 <= buffer_size + short_seek) &&
283  !s->write_flag && offset1 >= 0 &&
284  (!s->direct || !s->seek) &&
285  (whence != SEEK_END || force)) {
286  while(s->pos < offset && !s->eof_reached)
287  fill_buffer(s);
288  if (s->eof_reached)
289  return AVERROR_EOF;
290  s->buf_ptr = s->buf_end - (s->pos - offset);
291  } else if(!s->write_flag && offset1 < 0 && -offset1 < buffer_size>>1 && s->seek && offset > 0) {
292  int64_t res;
293 
294  pos -= FFMIN(buffer_size>>1, pos);
295  if ((res = s->seek(s->opaque, pos, SEEK_SET)) < 0)
296  return res;
297  s->buf_end =
298  s->buf_ptr = s->buffer;
299  s->pos = pos;
300  s->eof_reached = 0;
301  fill_buffer(s);
302  return avio_seek(s, offset, SEEK_SET | force);
303  } else {
304  int64_t res;
305  if (s->write_flag) {
306  flush_buffer(s);
307  }
308  if (!s->seek)
309  return AVERROR(EPIPE);
310  if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
311  return res;
312  s->seek_count ++;
313  if (!s->write_flag)
314  s->buf_end = s->buffer;
315  s->buf_ptr = s->buf_ptr_max = s->buffer;
316  s->pos = offset;
317  }
318  s->eof_reached = 0;
319  return offset;
320 }
321 
322 int64_t avio_skip(AVIOContext *s, int64_t offset)
323 {
324  return avio_seek(s, offset, SEEK_CUR);
325 }
326 
328 {
329  int64_t size;
330 
331  if (!s)
332  return AVERROR(EINVAL);
333 
334  if (s->written)
335  return s->written;
336 
337  if (!s->seek)
338  return AVERROR(ENOSYS);
339  size = s->seek(s->opaque, 0, AVSEEK_SIZE);
340  if (size < 0) {
341  if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
342  return size;
343  size++;
344  s->seek(s->opaque, s->pos, SEEK_SET);
345  }
346  return size;
347 }
348 
350 {
351  if(!s)
352  return 0;
353  if(s->eof_reached){
354  s->eof_reached=0;
355  fill_buffer(s);
356  }
357  return s->eof_reached;
358 }
359 
360 #if FF_API_URL_FEOF
361 int url_feof(AVIOContext *s)
362 {
363  return avio_feof(s);
364 }
365 #endif
366 
367 void avio_wl32(AVIOContext *s, unsigned int val)
368 {
369  avio_w8(s, (uint8_t) val );
370  avio_w8(s, (uint8_t)(val >> 8 ));
371  avio_w8(s, (uint8_t)(val >> 16));
372  avio_w8(s, val >> 24 );
373 }
374 
375 void avio_wb32(AVIOContext *s, unsigned int val)
376 {
377  avio_w8(s, val >> 24 );
378  avio_w8(s, (uint8_t)(val >> 16));
379  avio_w8(s, (uint8_t)(val >> 8 ));
380  avio_w8(s, (uint8_t) val );
381 }
382 
383 int avio_put_str(AVIOContext *s, const char *str)
384 {
385  int len = 1;
386  if (str) {
387  len += strlen(str);
388  avio_write(s, (const unsigned char *) str, len);
389  } else
390  avio_w8(s, 0);
391  return len;
392 }
393 
394 static inline int put_str16(AVIOContext *s, const char *str, const int be)
395 {
396  const uint8_t *q = str;
397  int ret = 0;
398  int err = 0;
399 
400  while (*q) {
401  uint32_t ch;
402  uint16_t tmp;
403 
404  GET_UTF8(ch, *q++, goto invalid;)
405  PUT_UTF16(ch, tmp, be ? avio_wb16(s, tmp) : avio_wl16(s, tmp);
406  ret += 2;)
407  continue;
408 invalid:
409  av_log(s, AV_LOG_ERROR, "Invalid UTF8 sequence in avio_put_str16%s\n", be ? "be" : "le");
410  err = AVERROR(EINVAL);
411  if (!*(q-1))
412  break;
413  }
414  if (be)
415  avio_wb16(s, 0);
416  else
417  avio_wl16(s, 0);
418  if (err)
419  return err;
420  ret += 2;
421  return ret;
422 }
423 
424 #define PUT_STR16(type, big_endian) \
425 int avio_put_str16 ## type(AVIOContext *s, const char *str) \
426 { \
427 return put_str16(s, str, big_endian); \
428 }
429 
430 PUT_STR16(le, 0)
431 PUT_STR16(be, 1)
432 
433 #undef PUT_STR16
434 
435 int ff_get_v_length(uint64_t val)
436 {
437  int i = 1;
438 
439  while (val >>= 7)
440  i++;
441 
442  return i;
443 }
444 
445 void ff_put_v(AVIOContext *bc, uint64_t val)
446 {
447  int i = ff_get_v_length(val);
448 
449  while (--i > 0)
450  avio_w8(bc, 128 | (uint8_t)(val >> (7*i)));
451 
452  avio_w8(bc, val & 127);
453 }
454 
455 void avio_wl64(AVIOContext *s, uint64_t val)
456 {
457  avio_wl32(s, (uint32_t)(val & 0xffffffff));
458  avio_wl32(s, (uint32_t)(val >> 32));
459 }
460 
461 void avio_wb64(AVIOContext *s, uint64_t val)
462 {
463  avio_wb32(s, (uint32_t)(val >> 32));
464  avio_wb32(s, (uint32_t)(val & 0xffffffff));
465 }
466 
467 void avio_wl16(AVIOContext *s, unsigned int val)
468 {
469  avio_w8(s, (uint8_t)val);
470  avio_w8(s, (int)val >> 8);
471 }
472 
473 void avio_wb16(AVIOContext *s, unsigned int val)
474 {
475  avio_w8(s, (int)val >> 8);
476  avio_w8(s, (uint8_t)val);
477 }
478 
479 void avio_wl24(AVIOContext *s, unsigned int val)
480 {
481  avio_wl16(s, val & 0xffff);
482  avio_w8(s, (int)val >> 16);
483 }
484 
485 void avio_wb24(AVIOContext *s, unsigned int val)
486 {
487  avio_wb16(s, (int)val >> 8);
488  avio_w8(s, (uint8_t)val);
489 }
490 
492 {
493  if (type == AVIO_DATA_MARKER_FLUSH_POINT) {
494  if (s->buf_ptr - s->buffer >= s->min_packet_size)
495  avio_flush(s);
496  return;
497  }
498  if (!s->write_data_type)
499  return;
500  // If ignoring boundary points, just treat it as unknown
503  // Avoid unnecessary flushes if we are already in non-header/trailer
504  // data and setting the type to unknown
505  if (type == AVIO_DATA_MARKER_UNKNOWN &&
508  return;
509 
510  switch (type) {
513  // For header/trailer, ignore a new marker of the same type;
514  // consecutive header/trailer markers can be merged.
515  if (type == s->current_type)
516  return;
517  break;
518  }
519 
520  // If we've reached here, we have a new, noteworthy marker.
521  // Flush the previous data and mark the start of the new data.
522  avio_flush(s);
523  s->current_type = type;
524  s->last_time = time;
525 }
526 
527 /* Input stream */
528 
529 static void fill_buffer(AVIOContext *s)
530 {
531  int max_buffer_size = s->max_packet_size ?
533  uint8_t *dst = s->buf_end - s->buffer + max_buffer_size < s->buffer_size ?
534  s->buf_end : s->buffer;
535  int len = s->buffer_size - (dst - s->buffer);
536 
537  /* can't fill the buffer without read_packet, just set EOF if appropriate */
538  if (!s->read_packet && s->buf_ptr >= s->buf_end)
539  s->eof_reached = 1;
540 
541  /* no need to do anything if EOF already reached */
542  if (s->eof_reached)
543  return;
544 
545  if (s->update_checksum && dst == s->buffer) {
546  if (s->buf_end > s->checksum_ptr)
548  s->buf_end - s->checksum_ptr);
549  s->checksum_ptr = s->buffer;
550  }
551 
552  /* make buffer smaller in case it ended up large after probing */
553  if (s->read_packet && s->orig_buffer_size && s->buffer_size > s->orig_buffer_size) {
554  if (dst == s->buffer && s->buf_ptr != dst) {
555  int ret = ffio_set_buf_size(s, s->orig_buffer_size);
556  if (ret < 0)
557  av_log(s, AV_LOG_WARNING, "Failed to decrease buffer size\n");
558 
559  s->checksum_ptr = dst = s->buffer;
560  }
561  av_assert0(len >= s->orig_buffer_size);
562  len = s->orig_buffer_size;
563  }
564 
565  if (s->read_packet)
566  len = s->read_packet(s->opaque, dst, len);
567  else
568  len = 0;
569  if (len <= 0) {
570  /* do not modify buffer if EOF reached so that a seek back can
571  be done without rereading data */
572  s->eof_reached = 1;
573  if (len < 0)
574  s->error = len;
575  } else {
576  s->pos += len;
577  s->buf_ptr = dst;
578  s->buf_end = dst + len;
579  s->bytes_read += len;
580  }
581 }
582 
583 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
584  unsigned int len)
585 {
586  return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
587 }
588 
589 unsigned long ff_crcEDB88320_update(unsigned long checksum, const uint8_t *buf,
590  unsigned int len)
591 {
592  return av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), checksum, buf, len);
593 }
594 
595 unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf,
596  unsigned int len)
597 {
598  return av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), checksum, buf, len);
599 }
600 
602 {
604  s->buf_ptr - s->checksum_ptr);
605  s->update_checksum = NULL;
606  return s->checksum;
607 }
608 
610  unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
611  unsigned long checksum)
612 {
613  s->update_checksum = update_checksum;
614  if (s->update_checksum) {
615  s->checksum = checksum;
616  s->checksum_ptr = s->buf_ptr;
617  }
618 }
619 
620 /* XXX: put an inline version */
622 {
623  if (s->buf_ptr >= s->buf_end)
624  fill_buffer(s);
625  if (s->buf_ptr < s->buf_end)
626  return *s->buf_ptr++;
627  return 0;
628 }
629 
630 int avio_read(AVIOContext *s, unsigned char *buf, int size)
631 {
632  int len, size1;
633 
634  size1 = size;
635  while (size > 0) {
636  len = FFMIN(s->buf_end - s->buf_ptr, size);
637  if (len == 0 || s->write_flag) {
638  if((s->direct || size > s->buffer_size) && !s->update_checksum) {
639  // bypass the buffer and read data directly into buf
640  if(s->read_packet)
641  len = s->read_packet(s->opaque, buf, size);
642 
643  if (len <= 0) {
644  /* do not modify buffer if EOF reached so that a seek back can
645  be done without rereading data */
646  s->eof_reached = 1;
647  if(len<0)
648  s->error= len;
649  break;
650  } else {
651  s->pos += len;
652  s->bytes_read += len;
653  size -= len;
654  buf += len;
655  // reset the buffer
656  s->buf_ptr = s->buffer;
657  s->buf_end = s->buffer/* + len*/;
658  }
659  } else {
660  fill_buffer(s);
661  len = s->buf_end - s->buf_ptr;
662  if (len == 0)
663  break;
664  }
665  } else {
666  memcpy(buf, s->buf_ptr, len);
667  buf += len;
668  s->buf_ptr += len;
669  size -= len;
670  }
671  }
672  if (size1 == size) {
673  if (s->error) return s->error;
674  if (avio_feof(s)) return AVERROR_EOF;
675  }
676  return size1 - size;
677 }
678 
679 int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
680 {
681  int ret = avio_read(s, buf, size);
682  if (ret != size)
683  return AVERROR_INVALIDDATA;
684  return ret;
685 }
686 
687 int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsigned char **data)
688 {
689  if (s->buf_end - s->buf_ptr >= size && !s->write_flag) {
690  *data = s->buf_ptr;
691  s->buf_ptr += size;
692  return size;
693  } else {
694  *data = buf;
695  return avio_read(s, buf, size);
696  }
697 }
698 
699 int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size)
700 {
701  int len;
702 
703  if (size < 0)
704  return -1;
705 
706  if (s->read_packet && s->write_flag) {
707  len = s->read_packet(s->opaque, buf, size);
708  if (len > 0)
709  s->pos += len;
710  return len;
711  }
712 
713  len = s->buf_end - s->buf_ptr;
714  if (len == 0) {
715  /* Reset the buf_end pointer to the start of the buffer, to make sure
716  * the fill_buffer call tries to read as much data as fits into the
717  * full buffer, instead of just what space is left after buf_end.
718  * This avoids returning partial packets at the end of the buffer,
719  * for packet based inputs.
720  */
721  s->buf_end = s->buf_ptr = s->buffer;
722  fill_buffer(s);
723  len = s->buf_end - s->buf_ptr;
724  }
725  if (len > size)
726  len = size;
727  memcpy(buf, s->buf_ptr, len);
728  s->buf_ptr += len;
729  if (!len) {
730  if (s->error) return s->error;
731  if (avio_feof(s)) return AVERROR_EOF;
732  }
733  return len;
734 }
735 
736 unsigned int avio_rl16(AVIOContext *s)
737 {
738  unsigned int val;
739  val = avio_r8(s);
740  val |= avio_r8(s) << 8;
741  return val;
742 }
743 
744 unsigned int avio_rl24(AVIOContext *s)
745 {
746  unsigned int val;
747  val = avio_rl16(s);
748  val |= avio_r8(s) << 16;
749  return val;
750 }
751 
752 unsigned int avio_rl32(AVIOContext *s)
753 {
754  unsigned int val;
755  val = avio_rl16(s);
756  val |= avio_rl16(s) << 16;
757  return val;
758 }
759 
760 uint64_t avio_rl64(AVIOContext *s)
761 {
762  uint64_t val;
763  val = (uint64_t)avio_rl32(s);
764  val |= (uint64_t)avio_rl32(s) << 32;
765  return val;
766 }
767 
768 unsigned int avio_rb16(AVIOContext *s)
769 {
770  unsigned int val;
771  val = avio_r8(s) << 8;
772  val |= avio_r8(s);
773  return val;
774 }
775 
776 unsigned int avio_rb24(AVIOContext *s)
777 {
778  unsigned int val;
779  val = avio_rb16(s) << 8;
780  val |= avio_r8(s);
781  return val;
782 }
783 unsigned int avio_rb32(AVIOContext *s)
784 {
785  unsigned int val;
786  val = avio_rb16(s) << 16;
787  val |= avio_rb16(s);
788  return val;
789 }
790 
791 int ff_get_line(AVIOContext *s, char *buf, int maxlen)
792 {
793  int i = 0;
794  char c;
795 
796  do {
797  c = avio_r8(s);
798  if (c && i < maxlen-1)
799  buf[i++] = c;
800  } while (c != '\n' && c != '\r' && c);
801  if (c == '\r' && avio_r8(s) != '\n' && !avio_feof(s))
802  avio_skip(s, -1);
803 
804  buf[i] = 0;
805  return i;
806 }
807 
808 int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
809 {
810  int i;
811 
812  if (buflen <= 0)
813  return AVERROR(EINVAL);
814  // reserve 1 byte for terminating 0
815  buflen = FFMIN(buflen - 1, maxlen);
816  for (i = 0; i < buflen; i++)
817  if (!(buf[i] = avio_r8(s)))
818  return i + 1;
819  buf[i] = 0;
820  for (; i < maxlen; i++)
821  if (!avio_r8(s))
822  return i + 1;
823  return maxlen;
824 }
825 
826 #define GET_STR16(type, read) \
827  int avio_get_str16 ##type(AVIOContext *pb, int maxlen, char *buf, int buflen)\
828 {\
829  char* q = buf;\
830  int ret = 0;\
831  if (buflen <= 0) \
832  return AVERROR(EINVAL); \
833  while (ret + 1 < maxlen) {\
834  uint8_t tmp;\
835  uint32_t ch;\
836  GET_UTF16(ch, (ret += 2) <= maxlen ? read(pb) : 0, break;)\
837  if (!ch)\
838  break;\
839  PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)\
840  }\
841  *q = 0;\
842  return ret;\
843 }\
844 
846 GET_STR16(be, avio_rb16)
847 
848 #undef GET_STR16
849 
850 uint64_t avio_rb64(AVIOContext *s)
851 {
852  uint64_t val;
853  val = (uint64_t)avio_rb32(s) << 32;
854  val |= (uint64_t)avio_rb32(s);
855  return val;
856 }
857 
859  uint64_t val = 0;
860  int tmp;
861 
862  do{
863  tmp = avio_r8(bc);
864  val= (val<<7) + (tmp&127);
865  }while(tmp&128);
866  return val;
867 }
868 
869 static int io_read_packet(void *opaque, uint8_t *buf, int buf_size)
870 {
871  AVIOInternal *internal = opaque;
872  return ffurl_read(internal->h, buf, buf_size);
873 }
874 
875 static int io_write_packet(void *opaque, uint8_t *buf, int buf_size)
876 {
877  AVIOInternal *internal = opaque;
878  return ffurl_write(internal->h, buf, buf_size);
879 }
880 
881 static int64_t io_seek(void *opaque, int64_t offset, int whence)
882 {
883  AVIOInternal *internal = opaque;
884  return ffurl_seek(internal->h, offset, whence);
885 }
886 
887 static int io_short_seek(void *opaque)
888 {
889  AVIOInternal *internal = opaque;
890  return ffurl_get_short_seek(internal->h);
891 }
892 
893 static int io_read_pause(void *opaque, int pause)
894 {
895  AVIOInternal *internal = opaque;
896  if (!internal->h->prot->url_read_pause)
897  return AVERROR(ENOSYS);
898  return internal->h->prot->url_read_pause(internal->h, pause);
899 }
900 
901 static int64_t io_read_seek(void *opaque, int stream_index, int64_t timestamp, int flags)
902 {
903  AVIOInternal *internal = opaque;
904  if (!internal->h->prot->url_read_seek)
905  return AVERROR(ENOSYS);
906  return internal->h->prot->url_read_seek(internal->h, stream_index, timestamp, flags);
907 }
908 
910 {
911  AVIOInternal *internal = NULL;
912  uint8_t *buffer = NULL;
913  int buffer_size, max_packet_size;
914 
915  max_packet_size = h->max_packet_size;
916  if (max_packet_size) {
917  buffer_size = max_packet_size; /* no need to bufferize more than one packet */
918  } else {
919  buffer_size = IO_BUFFER_SIZE;
920  }
921  buffer = av_malloc(buffer_size);
922  if (!buffer)
923  return AVERROR(ENOMEM);
924 
925  internal = av_mallocz(sizeof(*internal));
926  if (!internal)
927  goto fail;
928 
929  internal->h = h;
930 
931  *s = avio_alloc_context(buffer, buffer_size, h->flags & AVIO_FLAG_WRITE,
933  if (!*s)
934  goto fail;
935 
936  (*s)->protocol_whitelist = av_strdup(h->protocol_whitelist);
937  if (!(*s)->protocol_whitelist && h->protocol_whitelist) {
938  avio_closep(s);
939  goto fail;
940  }
941  (*s)->protocol_blacklist = av_strdup(h->protocol_blacklist);
942  if (!(*s)->protocol_blacklist && h->protocol_blacklist) {
943  avio_closep(s);
944  goto fail;
945  }
946  (*s)->direct = h->flags & AVIO_FLAG_DIRECT;
947 
948  (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
949  (*s)->max_packet_size = max_packet_size;
950  (*s)->min_packet_size = h->min_packet_size;
951  if(h->prot) {
952  (*s)->read_pause = io_read_pause;
953  (*s)->read_seek = io_read_seek;
954 
955  if (h->prot->url_read_seek)
956  (*s)->seekable |= AVIO_SEEKABLE_TIME;
957  }
958  (*s)->short_seek_get = io_short_seek;
959  (*s)->av_class = &ff_avio_class;
960  return 0;
961 fail:
962  av_freep(&internal);
963  av_freep(&buffer);
964  return AVERROR(ENOMEM);
965 }
966 
967 int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
968 {
969  uint8_t *buffer;
970  int max_buffer_size = s->max_packet_size ?
972  int filled = s->buf_end - s->buffer;
973  ptrdiff_t checksum_ptr_offset = s->checksum_ptr ? s->checksum_ptr - s->buffer : -1;
974 
975  buf_size += s->buf_ptr - s->buffer + max_buffer_size;
976 
977  if (buf_size < filled || s->seekable || !s->read_packet)
978  return 0;
979  av_assert0(!s->write_flag);
980 
981  buffer = av_malloc(buf_size);
982  if (!buffer)
983  return AVERROR(ENOMEM);
984 
985  memcpy(buffer, s->buffer, filled);
986  av_free(s->buffer);
987  s->buf_ptr = buffer + (s->buf_ptr - s->buffer);
988  s->buf_end = buffer + (s->buf_end - s->buffer);
989  s->buffer = buffer;
990  s->buffer_size = buf_size;
991  if (checksum_ptr_offset >= 0)
992  s->checksum_ptr = s->buffer + checksum_ptr_offset;
993  return 0;
994 }
995 
996 int ffio_set_buf_size(AVIOContext *s, int buf_size)
997 {
998  uint8_t *buffer;
999  buffer = av_malloc(buf_size);
1000  if (!buffer)
1001  return AVERROR(ENOMEM);
1002 
1003  av_free(s->buffer);
1004  s->buffer = buffer;
1005  s->orig_buffer_size =
1006  s->buffer_size = buf_size;
1007  s->buf_ptr = s->buf_ptr_max = buffer;
1009  return 0;
1010 }
1011 
1012 static int url_resetbuf(AVIOContext *s, int flags)
1013 {
1014  av_assert1(flags == AVIO_FLAG_WRITE || flags == AVIO_FLAG_READ);
1015 
1016  if (flags & AVIO_FLAG_WRITE) {
1017  s->buf_end = s->buffer + s->buffer_size;
1018  s->write_flag = 1;
1019  } else {
1020  s->buf_end = s->buffer;
1021  s->write_flag = 0;
1022  }
1023  return 0;
1024 }
1025 
1026 int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_size)
1027 {
1028  int64_t buffer_start;
1029  int buffer_size;
1030  int overlap, new_size, alloc_size;
1031  uint8_t *buf = *bufp;
1032 
1033  if (s->write_flag) {
1034  av_freep(bufp);
1035  return AVERROR(EINVAL);
1036  }
1037 
1038  buffer_size = s->buf_end - s->buffer;
1039 
1040  /* the buffers must touch or overlap */
1041  if ((buffer_start = s->pos - buffer_size) > buf_size) {
1042  av_freep(bufp);
1043  return AVERROR(EINVAL);
1044  }
1045 
1046  overlap = buf_size - buffer_start;
1047  new_size = buf_size + buffer_size - overlap;
1048 
1049  alloc_size = FFMAX(s->buffer_size, new_size);
1050  if (alloc_size > buf_size)
1051  if (!(buf = (*bufp) = av_realloc_f(buf, 1, alloc_size)))
1052  return AVERROR(ENOMEM);
1053 
1054  if (new_size > buf_size) {
1055  memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
1056  buf_size = new_size;
1057  }
1058 
1059  av_free(s->buffer);
1060  s->buf_ptr = s->buffer = buf;
1061  s->buffer_size = alloc_size;
1062  s->pos = buf_size;
1063  s->buf_end = s->buf_ptr + buf_size;
1064  s->eof_reached = 0;
1065 
1066  return 0;
1067 }
1068 
1069 int avio_open(AVIOContext **s, const char *filename, int flags)
1070 {
1071  return avio_open2(s, filename, flags, NULL, NULL);
1072 }
1073 
1074 int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags,
1076  const char *whitelist, const char *blacklist
1077  )
1078 {
1079  URLContext *h;
1080  int err;
1081 
1082  err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist, NULL);
1083  if (err < 0)
1084  return err;
1085  err = ffio_fdopen(s, h);
1086  if (err < 0) {
1087  ffurl_close(h);
1088  return err;
1089  }
1090  return 0;
1091 }
1092 
1093 int avio_open2(AVIOContext **s, const char *filename, int flags,
1095 {
1096  return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL, NULL);
1097 }
1098 
1099 int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
1101 {
1102  return ffio_open_whitelist(pb, url, flags, int_cb, options, s->protocol_whitelist, s->protocol_blacklist);
1103 }
1104 
1106 {
1107  AVIOInternal *internal;
1108  URLContext *h;
1109 
1110  if (!s)
1111  return 0;
1112 
1113  avio_flush(s);
1114  internal = s->opaque;
1115  h = internal->h;
1116 
1117  av_freep(&s->opaque);
1118  av_freep(&s->buffer);
1119  if (s->write_flag)
1120  av_log(s, AV_LOG_DEBUG, "Statistics: %d seeks, %d writeouts\n", s->seek_count, s->writeout_count);
1121  else
1122  av_log(s, AV_LOG_DEBUG, "Statistics: %"PRId64" bytes read, %d seeks\n", s->bytes_read, s->seek_count);
1123  av_opt_free(s);
1124  av_free(s);
1125  return ffurl_close(h);
1126 }
1127 
1129 {
1130  int ret = avio_close(*s);
1131  *s = NULL;
1132  return ret;
1133 }
1134 
1135 int avio_printf(AVIOContext *s, const char *fmt, ...)
1136 {
1137  va_list ap;
1138  char buf[4096]; /* update doc entry in avio.h if changed */
1139  int ret;
1140 
1141  va_start(ap, fmt);
1142  ret = vsnprintf(buf, sizeof(buf), fmt, ap);
1143  va_end(ap);
1144  avio_write(s, buf, strlen(buf));
1145  return ret;
1146 }
1147 
1148 int avio_pause(AVIOContext *s, int pause)
1149 {
1150  if (!s->read_pause)
1151  return AVERROR(ENOSYS);
1152  return s->read_pause(s->opaque, pause);
1153 }
1154 
1155 int64_t avio_seek_time(AVIOContext *s, int stream_index,
1156  int64_t timestamp, int flags)
1157 {
1158  int64_t ret;
1159  if (!s->read_seek)
1160  return AVERROR(ENOSYS);
1161  ret = s->read_seek(s->opaque, stream_index, timestamp, flags);
1162  if (ret >= 0) {
1163  int64_t pos;
1164  s->buf_ptr = s->buf_end; // Flush buffer
1165  pos = s->seek(s->opaque, 0, SEEK_CUR);
1166  if (pos >= 0)
1167  s->pos = pos;
1168  else if (pos != AVERROR(ENOSYS))
1169  ret = pos;
1170  }
1171  return ret;
1172 }
1173 
1174 int avio_read_to_bprint(AVIOContext *h, AVBPrint *pb, size_t max_size)
1175 {
1176  int ret;
1177  char buf[1024];
1178  while (max_size) {
1179  ret = avio_read(h, buf, FFMIN(max_size, sizeof(buf)));
1180  if (ret == AVERROR_EOF)
1181  return 0;
1182  if (ret <= 0)
1183  return ret;
1184  av_bprint_append_data(pb, buf, ret);
1185  if (!av_bprint_is_complete(pb))
1186  return AVERROR(ENOMEM);
1187  max_size -= ret;
1188  }
1189  return 0;
1190 }
1191 
1193 {
1194  int ret;
1195  AVIOInternal *internal = s->opaque;
1196  URLContext *sc = internal->h;
1197  URLContext *cc = NULL;
1198  ret = ffurl_accept(sc, &cc);
1199  if (ret < 0)
1200  return ret;
1201  return ffio_fdopen(c, cc);
1202 }
1203 
1205 {
1206  AVIOInternal *internal = c->opaque;
1207  URLContext *cc = internal->h;
1208  return ffurl_handshake(cc);
1209 }
1210 
1211 /* output in a dynamic buffer */
1212 
1213 typedef struct DynBuffer {
1218 } DynBuffer;
1219 
1220 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
1221 {
1222  DynBuffer *d = opaque;
1223  unsigned new_size, new_allocated_size;
1224 
1225  /* reallocate buffer if needed */
1226  new_size = d->pos + buf_size;
1227  new_allocated_size = d->allocated_size;
1228  if (new_size < d->pos || new_size > INT_MAX/2)
1229  return -1;
1230  while (new_size > new_allocated_size) {
1231  if (!new_allocated_size)
1232  new_allocated_size = new_size;
1233  else
1234  new_allocated_size += new_allocated_size / 2 + 1;
1235  }
1236 
1237  if (new_allocated_size > d->allocated_size) {
1238  int err;
1239  if ((err = av_reallocp(&d->buffer, new_allocated_size)) < 0) {
1240  d->allocated_size = 0;
1241  d->size = 0;
1242  return err;
1243  }
1244  d->allocated_size = new_allocated_size;
1245  }
1246  memcpy(d->buffer + d->pos, buf, buf_size);
1247  d->pos = new_size;
1248  if (d->pos > d->size)
1249  d->size = d->pos;
1250  return buf_size;
1251 }
1252 
1253 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
1254 {
1255  unsigned char buf1[4];
1256  int ret;
1257 
1258  /* packetized write: output the header */
1259  AV_WB32(buf1, buf_size);
1260  ret = dyn_buf_write(opaque, buf1, 4);
1261  if (ret < 0)
1262  return ret;
1263 
1264  /* then the data */
1265  return dyn_buf_write(opaque, buf, buf_size);
1266 }
1267 
1268 static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
1269 {
1270  DynBuffer *d = opaque;
1271 
1272  if (whence == SEEK_CUR)
1273  offset += d->pos;
1274  else if (whence == SEEK_END)
1275  offset += d->size;
1276  if (offset < 0 || offset > 0x7fffffffLL)
1277  return -1;
1278  d->pos = offset;
1279  return 0;
1280 }
1281 
1282 static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
1283 {
1284  DynBuffer *d;
1285  unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
1286 
1287  if (sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
1288  return -1;
1289  d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
1290  if (!d)
1291  return AVERROR(ENOMEM);
1292  d->io_buffer_size = io_buffer_size;
1293  *s = avio_alloc_context(d->io_buffer, d->io_buffer_size, 1, d, NULL,
1294  max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
1295  max_packet_size ? NULL : dyn_buf_seek);
1296  if(!*s) {
1297  av_free(d);
1298  return AVERROR(ENOMEM);
1299  }
1300  (*s)->max_packet_size = max_packet_size;
1301  return 0;
1302 }
1303 
1305 {
1306  return url_open_dyn_buf_internal(s, 0);
1307 }
1308 
1309 int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
1310 {
1311  if (max_packet_size <= 0)
1312  return -1;
1313  return url_open_dyn_buf_internal(s, max_packet_size);
1314 }
1315 
1317 {
1318  DynBuffer *d;
1319 
1320  if (!s) {
1321  *pbuffer = NULL;
1322  return 0;
1323  }
1324 
1325  avio_flush(s);
1326 
1327  d = s->opaque;
1328  *pbuffer = d->buffer;
1329 
1330  return d->size;
1331 }
1332 
1334 {
1335  DynBuffer *d;
1336  int size;
1337  static const char padbuf[AV_INPUT_BUFFER_PADDING_SIZE] = {0};
1338  int padding = 0;
1339 
1340  if (!s) {
1341  *pbuffer = NULL;
1342  return 0;
1343  }
1344 
1345  /* don't attempt to pad fixed-size packet buffers */
1346  if (!s->max_packet_size) {
1347  avio_write(s, padbuf, sizeof(padbuf));
1348  padding = AV_INPUT_BUFFER_PADDING_SIZE;
1349  }
1350 
1351  avio_flush(s);
1352 
1353  d = s->opaque;
1354  *pbuffer = d->buffer;
1355  size = d->size;
1356  av_free(d);
1357  av_free(s);
1358  return size - padding;
1359 }
1360 
1362 {
1363  uint8_t *tmp;
1364  if (!*s)
1365  return;
1366  avio_close_dyn_buf(*s, &tmp);
1367  av_free(tmp);
1368  *s = NULL;
1369 }
1370 
1371 static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
1372 {
1373  DynBuffer *d = opaque;
1374 
1375  d->pos += buf_size;
1376  if (d->pos > d->size)
1377  d->size = d->pos;
1378  return buf_size;
1379 }
1380 
1382 {
1383  int ret = url_open_dyn_buf_internal(s, 0);
1384  if (ret >= 0) {
1385  AVIOContext *pb = *s;
1387  }
1388  return ret;
1389 }
1390 
1392 {
1393  DynBuffer *d = s->opaque;
1394  int size;
1395 
1396  avio_flush(s);
1397 
1398  size = d->size;
1399  av_free(d);
1400  av_free(s);
1401  return size;
1402 }
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:671
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:455
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:129
static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
Definition: aviobuf.c:1268
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
Buffered I/O operations.
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:850
int64_t(* read_seek)(void *opaque, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp in stream with the specified stream_index.
Definition: avio.h:256
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1304
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:361
int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist, URLContext *parent)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
Definition: avio.c:307
#define av_realloc_f(p, o, n)
uint8_t io_buffer[1]
Definition: aviobuf.c:1217
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:473
AVOption.
Definition: opt.h:246
static int64_t io_read_seek(void *opaque, int stream_index, int64_t timestamp, int flags)
Definition: aviobuf.c:901
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int(* short_seek_get)(void *opaque)
A callback that is used instead of short_seek_threshold.
Definition: avio.h:339
const char * fmt
Definition: avisynth_c.h:769
int64_t last_time
Definition: avio.h:333
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
Definition: aviobuf.c:349
#define LIBAVUTIL_VERSION_INT
Definition: version.h:86
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
int writeout_count
writeout statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:292
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
Definition: avio.h:229
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:419
#define D
Definition: aviobuf.c:63
int write_flag
true if open for writing
Definition: avio.h:241
int is_streamed
true if streamed (no seek possible), default = false
Definition: url.h:45
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1316
#define AVIO_SEEKABLE_TIME
Seeking by timestamp with avio_seek_time() is possible.
Definition: avio.h:45
#define vsnprintf
Definition: snprintf.h:36
int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:699
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:197
const char * b
Definition: vf_curves.c:113
#define AVIO_FLAG_READ
read-only
Definition: avio.h:643
unsigned int avio_rl24(AVIOContext *s)
Definition: aviobuf.c:744
int min_packet_size
Try to buffer at least this amount of data before flushing it.
Definition: avio.h:352
int avio_read_to_bprint(AVIOContext *h, AVBPrint *pb, size_t max_size)
Read contents of h into print buffer, up to max_size bytes, or up to EOF.
Definition: aviobuf.c:1174
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:644
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
#define OFFSET(x)
Definition: aviobuf.c:61
void avio_wl24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:479
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:189
int flags
Definition: url.h:43
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: aviobuf.c:1128
int64_t(* seek)(void *opaque, int64_t offset, int whence)
Definition: avio.h:237
void * opaque
A private pointer, passed to the read/write/seek/...
Definition: avio.h:233
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
#define IO_BUFFER_SIZE
Definition: aviobuf.c:36
static const AVClass * ff_avio_child_class_next(const AVClass *prev)
Definition: aviobuf.c:56
static int io_read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:869
Trailer data, which doesn't contain actual content, but only for finalizing the output file...
Definition: avio.h:140
Format I/O context.
Definition: avformat.h:1349
int avio_accept(AVIOContext *s, AVIOContext **c)
Accept and allocate a client context on a server context.
Definition: aviobuf.c:1192
URLContext * h
Definition: aviobuf.c:46
int avio_put_str(AVIOContext *s, const char *str)
Write a NULL-terminated string.
Definition: aviobuf.c:383
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:367
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
uint8_t
#define av_malloc(s)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVOptions.
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
static void fill_buffer(AVIOContext *s)
Definition: aviobuf.c:529
static int io_read_pause(void *opaque, int pause)
Definition: aviobuf.c:893
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:601
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:491
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:231
int ffio_open_null_buf(AVIOContext **s)
Open a write-only fake memory stream.
Definition: aviobuf.c:1381
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:81
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:158
Public header for CRC hash function implementation.
int64_t bytes_read
Bytes read statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:280
char * protocol_whitelist
',' separated list of allowed protocols.
Definition: avformat.h:1887
static int flags
Definition: log.c:57
#define AVERROR_EOF
End of file.
Definition: error.h:55
int ffio_set_buf_size(AVIOContext *s, int buf_size)
Definition: aviobuf.c:996
int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsigned char **data)
Read size bytes from AVIOContext, returning a pointer.
Definition: aviobuf.c:687
ptrdiff_t size
Definition: opengl_enc.c:101
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:485
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:467
int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist)
Definition: aviobuf.c:1074
unsigned long ff_crcEDB88320_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:589
const OptionDef options[]
Definition: ffserver.c:3952
#define av_log(a,...)
static void flush_buffer(AVIOContext *s)
Definition: aviobuf.c:173
int max_packet_size
Definition: avio.h:242
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
int64_t written
Definition: avio.h:341
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int io_buffer_size
Definition: aviobuf.c:1216
int(* write_packet)(void *opaque, uint8_t *buf, int buf_size)
Definition: avio.h:236
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:776
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:464
static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1253
const char * protocol_whitelist
Definition: url.h:49
int(* read_packet)(void *opaque, uint8_t *buf, int buf_size)
Definition: avio.h:235
av_default_item_name
static const AVOption ff_avio_options[]
Definition: aviobuf.c:64
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
simple assert() macros that are a bit more flexible than ISO C assert().
unsigned long checksum
Definition: avio.h:243
static void * ff_avio_child_next(void *obj, void *prev)
Definition: aviobuf.c:49
#define SHORT_SEEK_THRESHOLD
Do seeks within this distance ahead of the current buffer by skipping data instead of calling the pro...
Definition: aviobuf.c:43
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:94
int direct
avio_read and avio_write should if possible be satisfied directly instead of going through a buffer...
Definition: avio.h:274
#define fail()
Definition: checkasm.h:98
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:736
int seek_count
seek statistic This field is internal to libavformat and access from outside is not allowed...
Definition: avio.h:286
int avio_pause(AVIOContext *s, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e.g.
Definition: aviobuf.c:1148
int(* write_data_type)(void *opaque, uint8_t *buf, int buf_size, enum AVIODataMarkerType type, int64_t time)
A callback that is used instead of write_packet.
Definition: avio.h:320
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:752
This is any, unlabelled data.
Definition: avio.h:135
int size
Definition: aviobuf.c:1214
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:679
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:239
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int ffurl_get_short_seek(URLContext *h)
Return the current short seek threshold value for this URL.
Definition: avio.c:646
#define FFMIN(a, b)
Definition: common.h:96
const AVClass ff_avio_class
Definition: aviobuf.c:69
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1333
unsigned char * checksum_ptr
Definition: avio.h:244
int avio_printf(AVIOContext *s, const char *fmt,...)
Definition: aviobuf.c:1135
AVIODataMarkerType
Different data types that can be returned via the AVIO write_data_type callback.
Definition: avio.h:111
int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Definition: aviobuf.c:1099
int allocated_size
Definition: aviobuf.c:1214
int ffurl_handshake(URLContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: avio.c:234
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:357
static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1220
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:791
#define GET_STR16(type, read)
Definition: aviobuf.c:826
static volatile int checksum
Definition: adler32.c:28
unsigned long(* update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size)
Definition: avio.h:245
int ffurl_accept(URLContext *s, URLContext **c)
Accept an URLContext c on an URLContext s.
Definition: avio.c:226
int buffer_size
Maximum buffer size.
Definition: avio.h:227
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:461
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:630
uint8_t le
Definition: crc.c:295
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
Open a write only packetized memory stream with a maximum packet size of 'max_packet_size'.
Definition: aviobuf.c:1309
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:237
const char * protocol_blacklist
Definition: url.h:50
#define PUT_STR16(type, big_endian)
Definition: aviobuf.c:424
int avio_open(AVIOContext **s, const char *filename, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1069
static int io_short_seek(void *opaque)
Definition: aviobuf.c:887
int64_t(* url_read_seek)(URLContext *h, int stream_index, int64_t timestamp, int flags)
Definition: url.h:83
int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_size)
Rewind the AVIOContext using the specified buffer containing the first buf_size bytes of the file...
Definition: aviobuf.c:1026
static int url_resetbuf(AVIOContext *s, int flags)
Definition: aviobuf.c:1012
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:760
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1105
void * buf
Definition: avisynth_c.h:690
Definition: url.h:38
GLint GLenum type
Definition: opengl_enc.c:105
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:424
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:211
#define AVSEEK_FORCE
Passing this flag as the "whence" parameter to a seek function causes it to seek by any means (like r...
Definition: avio.h:530
#define AVIO_FLAG_DIRECT
Use direct mode.
Definition: avio.h:670
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:768
int pos
Definition: aviobuf.c:1214
int short_seek_threshold
Threshold to favor readahead over seek.
Definition: avio.h:305
#define PUT_UTF16(val, tmp, PUT_16BIT)
Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
Definition: common.h:448
int ignore_boundary_point
If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT, but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly small chunks of data returned from the callback).
Definition: avio.h:327
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1361
int error
contains the error code or 0 if no error happened
Definition: avio.h:246
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:967
int(* read_pause)(void *opaque, int pause)
Pause or resume playback for network streaming protocols - e.g.
Definition: avio.h:250
int ff_get_v_length(uint64_t val)
Get the length in bytes which is needed to store val as v.
Definition: aviobuf.c:435
int ffurl_close(URLContext *h)
Definition: avio.c:465
const AVClass ffurl_context_class
Definition: avio.c:63
int orig_buffer_size
Original buffer size used internally after probing and ensure seekback to reset the buffer size This ...
Definition: avio.h:299
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:343
enum AVIODataMarkerType current_type
Internal, not meant to be used from outside of AVIOContext.
Definition: avio.h:332
int avio_handshake(AVIOContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: aviobuf.c:1204
int avio_open2(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1093
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:327
Main libavformat public API header.
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1544
int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:808
int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)
Change the position that will be used by the next read/write operation on the resource accessed by h...
Definition: avio.c:432
const struct URLProtocol * prot
Definition: url.h:40
int ffio_fdopen(AVIOContext **s, URLContext *h)
Create and initialize a AVIOContext for accessing the resource referenced by the URLContext h...
Definition: aviobuf.c:909
void ffio_init_checksum(AVIOContext *s, unsigned long(*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum)
Definition: aviobuf.c:609
static double c[64]
int64_t pos
position in the file of the current buffer
Definition: avio.h:238
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:522
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:776
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:858
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:783
unsigned char * buf_ptr_max
Maximum reached position before a backward seek in the write buffer, used keeping track of already wr...
Definition: avio.h:347
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
#define av_free(p)
uint8_t * buffer
Definition: aviobuf.c:1215
static int put_str16(AVIOContext *s, const char *str, const int be)
Definition: aviobuf.c:394
int eof_reached
true if eof reached
Definition: avio.h:240
static int io_write_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:875
void ff_put_v(AVIOContext *bc, uint64_t val)
Put val using a variable number of bytes.
Definition: aviobuf.c:445
int len
int ffio_close_null_buf(AVIOContext *s)
Close a null buffer.
Definition: aviobuf.c:1391
static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1371
static void writeout(AVIOContext *s, const uint8_t *data, int len)
Definition: aviobuf.c:146
static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
Definition: aviobuf.c:1282
char * protocol_blacklist
',' separated list of disallowed protocols.
Definition: avformat.h:1922
int max_packet_size
if non zero, the stream is packetized with this max packet size
Definition: url.h:44
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:322
#define av_freep(p)
unbuffered private I/O API
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:583
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:621
int min_packet_size
if non zero, the stream is packetized with this min packet size
Definition: url.h:51
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf...
Definition: avio.c:405
static int64_t io_seek(void *opaque, int64_t offset, int whence)
Definition: aviobuf.c:881
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:115
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int64_t avio_seek_time(AVIOContext *s, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp relative to some component stream.
Definition: aviobuf.c:1155
unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:595
GLuint buffer
Definition: opengl_enc.c:102
static uint8_t tmp[11]
Definition: aes_ctr.c:26