FFmpeg
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/internal.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/log.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/avassert.h"
30 #include "libavcodec/defs.h"
31 #include "avio.h"
32 #include "avio_internal.h"
33 #include "internal.h"
34 #include "url.h"
35 #include <stdarg.h>
36 
37 #define IO_BUFFER_SIZE 32768
38 
39 /**
40  * Do seeks within this distance ahead of the current buffer by skipping
41  * data instead of calling the protocol seek function, for seekable
42  * protocols.
43  */
44 #define SHORT_SEEK_THRESHOLD 32768
45 
46 static void *ff_avio_child_next(void *obj, void *prev)
47 {
48  AVIOContext *s = obj;
49  return prev ? NULL : s->opaque;
50 }
51 
52 static const AVClass *child_class_iterate(void **iter)
53 {
54  const AVClass *c = *iter ? NULL : &ffurl_context_class;
55  *iter = (void*)(uintptr_t)c;
56  return c;
57 }
58 
59 #define OFFSET(x) offsetof(AVIOContext,x)
60 #define E AV_OPT_FLAG_ENCODING_PARAM
61 #define D AV_OPT_FLAG_DECODING_PARAM
62 static const AVOption ff_avio_options[] = {
63  {"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D },
64  { NULL },
65 };
66 
68  .class_name = "AVIOContext",
69  .item_name = av_default_item_name,
70  .version = LIBAVUTIL_VERSION_INT,
71  .option = ff_avio_options,
72  .child_next = ff_avio_child_next,
73  .child_class_iterate = child_class_iterate,
74 };
75 
76 static void fill_buffer(AVIOContext *s);
77 static int url_resetbuf(AVIOContext *s, int flags);
78 /** @warning must be called before any I/O */
79 static int set_buf_size(AVIOContext *s, int buf_size);
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  AVIOContext *const s = &ctx->pub;
91 
92  memset(ctx, 0, sizeof(*ctx));
93 
94  s->buffer = buffer;
95  ctx->orig_buffer_size =
96  s->buffer_size = buffer_size;
97  s->buf_ptr = buffer;
98  s->buf_ptr_max = buffer;
99  s->opaque = opaque;
100  s->direct = 0;
101 
102  url_resetbuf(s, write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
103 
104  s->write_packet = write_packet;
105  s->read_packet = read_packet;
106  s->seek = seek;
107  s->pos = 0;
108  s->eof_reached = 0;
109  s->error = 0;
110  s->seekable = seek ? AVIO_SEEKABLE_NORMAL : 0;
111  s->min_packet_size = 0;
112  s->max_packet_size = 0;
113  s->update_checksum = NULL;
114  ctx->short_seek_threshold = SHORT_SEEK_THRESHOLD;
115 
116  if (!read_packet && !write_flag) {
117  s->pos = buffer_size;
118  s->buf_end = s->buffer + buffer_size;
119  }
120  s->read_pause = NULL;
121  s->read_seek = NULL;
122 
123  s->write_data_type = NULL;
124  s->ignore_boundary_point = 0;
125  ctx->current_type = AVIO_DATA_MARKER_UNKNOWN;
126  ctx->last_time = AV_NOPTS_VALUE;
127  ctx->short_seek_get = NULL;
128 #if FF_API_AVIOCONTEXT_WRITTEN
130  s->written = 0;
132 #endif
133 }
134 
136  unsigned char *buffer,
137  int buffer_size,
138  int write_flag,
139  void *opaque,
140  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
141  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
142  int64_t (*seek)(void *opaque, int64_t offset, int whence))
143 {
144  FFIOContext *s = av_malloc(sizeof(*s));
145  if (!s)
146  return NULL;
147  ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
148  read_packet, write_packet, seek);
149  return &s->pub;
150 }
151 
153 {
154  av_freep(ps);
155 }
156 
157 static void writeout(AVIOContext *s, const uint8_t *data, int len)
158 {
159  FFIOContext *const ctx = ffiocontext(s);
160  if (!s->error) {
161  int ret = 0;
162  if (s->write_data_type)
163  ret = s->write_data_type(s->opaque, (uint8_t *)data,
164  len,
165  ctx->current_type,
166  ctx->last_time);
167  else if (s->write_packet)
168  ret = s->write_packet(s->opaque, (uint8_t *)data, len);
169  if (ret < 0) {
170  s->error = ret;
171  } else {
172  ctx->bytes_written += len;
173  s->bytes_written = ctx->bytes_written;
174 
175  if (s->pos + len > ctx->written_output_size) {
176  ctx->written_output_size = s->pos + len;
177 #if FF_API_AVIOCONTEXT_WRITTEN
179  s->written = ctx->written_output_size;
181 #endif
182  }
183  }
184  }
185  if (ctx->current_type == AVIO_DATA_MARKER_SYNC_POINT ||
186  ctx->current_type == AVIO_DATA_MARKER_BOUNDARY_POINT) {
187  ctx->current_type = AVIO_DATA_MARKER_UNKNOWN;
188  }
189  ctx->last_time = AV_NOPTS_VALUE;
190  ctx->writeout_count++;
191  s->pos += len;
192 }
193 
195 {
196  s->buf_ptr_max = FFMAX(s->buf_ptr, s->buf_ptr_max);
197  if (s->write_flag && s->buf_ptr_max > s->buffer) {
198  writeout(s, s->buffer, s->buf_ptr_max - s->buffer);
199  if (s->update_checksum) {
200  s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
201  s->buf_ptr_max - s->checksum_ptr);
202  s->checksum_ptr = s->buffer;
203  }
204  }
205  s->buf_ptr = s->buf_ptr_max = s->buffer;
206  if (!s->write_flag)
207  s->buf_end = s->buffer;
208 }
209 
210 void avio_w8(AVIOContext *s, int b)
211 {
212  av_assert2(b>=-128 && b<=255);
213  *s->buf_ptr++ = b;
214  if (s->buf_ptr >= s->buf_end)
215  flush_buffer(s);
216 }
217 
218 void ffio_fill(AVIOContext *s, int b, int64_t count)
219 {
220  while (count > 0) {
221  int len = FFMIN(s->buf_end - s->buf_ptr, count);
222  memset(s->buf_ptr, b, len);
223  s->buf_ptr += len;
224 
225  if (s->buf_ptr >= s->buf_end)
226  flush_buffer(s);
227 
228  count -= len;
229  }
230 }
231 
232 void avio_write(AVIOContext *s, const unsigned char *buf, int size)
233 {
234  if (s->direct && !s->update_checksum) {
235  avio_flush(s);
236  writeout(s, buf, size);
237  return;
238  }
239  while (size > 0) {
240  int len = FFMIN(s->buf_end - s->buf_ptr, size);
241  memcpy(s->buf_ptr, buf, len);
242  s->buf_ptr += len;
243 
244  if (s->buf_ptr >= s->buf_end)
245  flush_buffer(s);
246 
247  buf += len;
248  size -= len;
249  }
250 }
251 
253 {
254  int seekback = s->write_flag ? FFMIN(0, s->buf_ptr - s->buf_ptr_max) : 0;
255  flush_buffer(s);
256  if (seekback)
257  avio_seek(s, seekback, SEEK_CUR);
258 }
259 
260 int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
261 {
262  FFIOContext *const ctx = ffiocontext(s);
263  int64_t offset1;
264  int64_t pos;
265  int force = whence & AVSEEK_FORCE;
266  int buffer_size;
267  int short_seek;
268  whence &= ~AVSEEK_FORCE;
269 
270  if(!s)
271  return AVERROR(EINVAL);
272 
273  if ((whence & AVSEEK_SIZE))
274  return s->seek ? s->seek(s->opaque, offset, AVSEEK_SIZE) : AVERROR(ENOSYS);
275 
276  buffer_size = s->buf_end - s->buffer;
277  // pos is the absolute position that the beginning of s->buffer corresponds to in the file
278  pos = s->pos - (s->write_flag ? 0 : buffer_size);
279 
280  if (whence != SEEK_CUR && whence != SEEK_SET)
281  return AVERROR(EINVAL);
282 
283  if (whence == SEEK_CUR) {
284  offset1 = pos + (s->buf_ptr - s->buffer);
285  if (offset == 0)
286  return offset1;
287  if (offset > INT64_MAX - offset1)
288  return AVERROR(EINVAL);
289  offset += offset1;
290  }
291  if (offset < 0)
292  return AVERROR(EINVAL);
293 
294  short_seek = ctx->short_seek_threshold;
295  if (ctx->short_seek_get) {
296  int tmp = ctx->short_seek_get(s->opaque);
297  short_seek = FFMAX(tmp, short_seek);
298  }
299 
300  offset1 = offset - pos; // "offset1" is the relative offset from the beginning of s->buffer
301  s->buf_ptr_max = FFMAX(s->buf_ptr_max, s->buf_ptr);
302  if ((!s->direct || !s->seek) &&
303  offset1 >= 0 && offset1 <= (s->write_flag ? s->buf_ptr_max - s->buffer : buffer_size)) {
304  /* can do the seek inside the buffer */
305  s->buf_ptr = s->buffer + offset1;
306  } else if ((!(s->seekable & AVIO_SEEKABLE_NORMAL) ||
307  offset1 <= buffer_size + short_seek) &&
308  !s->write_flag && offset1 >= 0 &&
309  (!s->direct || !s->seek) &&
310  (whence != SEEK_END || force)) {
311  while(s->pos < offset && !s->eof_reached)
312  fill_buffer(s);
313  if (s->eof_reached)
314  return AVERROR_EOF;
315  s->buf_ptr = s->buf_end - (s->pos - offset);
316  } else if(!s->write_flag && offset1 < 0 && -offset1 < buffer_size>>1 && s->seek && offset > 0) {
317  int64_t res;
318 
319  pos -= FFMIN(buffer_size>>1, pos);
320  if ((res = s->seek(s->opaque, pos, SEEK_SET)) < 0)
321  return res;
322  s->buf_end =
323  s->buf_ptr = s->buffer;
324  s->pos = pos;
325  s->eof_reached = 0;
326  fill_buffer(s);
327  return avio_seek(s, offset, SEEK_SET | force);
328  } else {
329  int64_t res;
330  if (s->write_flag) {
331  flush_buffer(s);
332  }
333  if (!s->seek)
334  return AVERROR(EPIPE);
335  if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
336  return res;
337  ctx->seek_count++;
338  if (!s->write_flag)
339  s->buf_end = s->buffer;
340  s->buf_ptr = s->buf_ptr_max = s->buffer;
341  s->pos = offset;
342  }
343  s->eof_reached = 0;
344  return offset;
345 }
346 
347 int64_t avio_skip(AVIOContext *s, int64_t offset)
348 {
349  return avio_seek(s, offset, SEEK_CUR);
350 }
351 
353 {
354  FFIOContext *const ctx = ffiocontext(s);
355  int64_t size;
356 
357  if (!s)
358  return AVERROR(EINVAL);
359 
360  if (ctx->written_output_size)
361  return ctx->written_output_size;
362 
363  if (!s->seek)
364  return AVERROR(ENOSYS);
365  size = s->seek(s->opaque, 0, AVSEEK_SIZE);
366  if (size < 0) {
367  if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
368  return size;
369  size++;
370  s->seek(s->opaque, s->pos, SEEK_SET);
371  }
372  return size;
373 }
374 
376 {
377  if(!s)
378  return 0;
379  if(s->eof_reached){
380  s->eof_reached=0;
381  fill_buffer(s);
382  }
383  return s->eof_reached;
384 }
385 
386 void avio_wl32(AVIOContext *s, unsigned int val)
387 {
388  avio_w8(s, (uint8_t) val );
389  avio_w8(s, (uint8_t)(val >> 8 ));
390  avio_w8(s, (uint8_t)(val >> 16));
391  avio_w8(s, val >> 24 );
392 }
393 
394 void avio_wb32(AVIOContext *s, unsigned int val)
395 {
396  avio_w8(s, val >> 24 );
397  avio_w8(s, (uint8_t)(val >> 16));
398  avio_w8(s, (uint8_t)(val >> 8 ));
399  avio_w8(s, (uint8_t) val );
400 }
401 
402 int avio_put_str(AVIOContext *s, const char *str)
403 {
404  int len = 1;
405  if (str) {
406  len += strlen(str);
407  avio_write(s, (const unsigned char *) str, len);
408  } else
409  avio_w8(s, 0);
410  return len;
411 }
412 
413 static inline int put_str16(AVIOContext *s, const char *str, const int be)
414 {
415  const uint8_t *q = str;
416  int ret = 0;
417  int err = 0;
418 
419  while (*q) {
420  uint32_t ch;
421  uint16_t tmp;
422 
423  GET_UTF8(ch, *q++, goto invalid;)
424  PUT_UTF16(ch, tmp, be ? avio_wb16(s, tmp) : avio_wl16(s, tmp);
425  ret += 2;)
426  continue;
427 invalid:
428  av_log(s, AV_LOG_ERROR, "Invalid UTF8 sequence in avio_put_str16%s\n", be ? "be" : "le");
429  err = AVERROR(EINVAL);
430  if (!*(q-1))
431  break;
432  }
433  if (be)
434  avio_wb16(s, 0);
435  else
436  avio_wl16(s, 0);
437  if (err)
438  return err;
439  ret += 2;
440  return ret;
441 }
442 
443 #define PUT_STR16(type, big_endian) \
444 int avio_put_str16 ## type(AVIOContext *s, const char *str) \
445 { \
446 return put_str16(s, str, big_endian); \
447 }
448 
449 PUT_STR16(le, 0)
450 PUT_STR16(be, 1)
451 
452 #undef PUT_STR16
453 
454 void avio_wl64(AVIOContext *s, uint64_t val)
455 {
456  avio_wl32(s, (uint32_t)(val & 0xffffffff));
457  avio_wl32(s, (uint32_t)(val >> 32));
458 }
459 
460 void avio_wb64(AVIOContext *s, uint64_t val)
461 {
462  avio_wb32(s, (uint32_t)(val >> 32));
463  avio_wb32(s, (uint32_t)(val & 0xffffffff));
464 }
465 
466 void avio_wl16(AVIOContext *s, unsigned int val)
467 {
468  avio_w8(s, (uint8_t)val);
469  avio_w8(s, (int)val >> 8);
470 }
471 
472 void avio_wb16(AVIOContext *s, unsigned int val)
473 {
474  avio_w8(s, (int)val >> 8);
475  avio_w8(s, (uint8_t)val);
476 }
477 
478 void avio_wl24(AVIOContext *s, unsigned int val)
479 {
480  avio_wl16(s, val & 0xffff);
481  avio_w8(s, (int)val >> 16);
482 }
483 
484 void avio_wb24(AVIOContext *s, unsigned int val)
485 {
486  avio_wb16(s, (int)val >> 8);
487  avio_w8(s, (uint8_t)val);
488 }
489 
491 {
492  FFIOContext *const ctx = ffiocontext(s);
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
501  if (type == AVIO_DATA_MARKER_BOUNDARY_POINT && s->ignore_boundary_point)
503  // Avoid unnecessary flushes if we are already in non-header/trailer
504  // data and setting the type to unknown
506  (ctx->current_type != AVIO_DATA_MARKER_HEADER &&
507  ctx->current_type != AVIO_DATA_MARKER_TRAILER))
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 == ctx->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  ctx->current_type = type;
524  ctx->last_time = time;
525 }
526 
527 static int read_packet_wrapper(AVIOContext *s, uint8_t *buf, int size)
528 {
529  int ret;
530 
531  if (!s->read_packet)
532  return AVERROR(EINVAL);
533  ret = s->read_packet(s->opaque, buf, size);
534  av_assert2(ret || s->max_packet_size);
535  return ret;
536 }
537 
538 /* Input stream */
539 
540 static void fill_buffer(AVIOContext *s)
541 {
542  FFIOContext *const ctx = (FFIOContext *)s;
543  int max_buffer_size = s->max_packet_size ?
544  s->max_packet_size : IO_BUFFER_SIZE;
545  uint8_t *dst = s->buf_end - s->buffer + max_buffer_size <= s->buffer_size ?
546  s->buf_end : s->buffer;
547  int len = s->buffer_size - (dst - s->buffer);
548 
549  /* can't fill the buffer without read_packet, just set EOF if appropriate */
550  if (!s->read_packet && s->buf_ptr >= s->buf_end)
551  s->eof_reached = 1;
552 
553  /* no need to do anything if EOF already reached */
554  if (s->eof_reached)
555  return;
556 
557  if (s->update_checksum && dst == s->buffer) {
558  if (s->buf_end > s->checksum_ptr)
559  s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
560  s->buf_end - s->checksum_ptr);
561  s->checksum_ptr = s->buffer;
562  }
563 
564  /* make buffer smaller in case it ended up large after probing */
565  if (s->read_packet && ctx->orig_buffer_size &&
566  s->buffer_size > ctx->orig_buffer_size && len >= ctx->orig_buffer_size) {
567  if (dst == s->buffer && s->buf_ptr != dst) {
568  int ret = set_buf_size(s, ctx->orig_buffer_size);
569  if (ret < 0)
570  av_log(s, AV_LOG_WARNING, "Failed to decrease buffer size\n");
571 
572  s->checksum_ptr = dst = s->buffer;
573  }
574  len = ctx->orig_buffer_size;
575  }
576 
577  len = read_packet_wrapper(s, dst, len);
578  if (len == AVERROR_EOF) {
579  /* do not modify buffer if EOF reached so that a seek back can
580  be done without rereading data */
581  s->eof_reached = 1;
582  } else if (len < 0) {
583  s->eof_reached = 1;
584  s->error= len;
585  } else {
586  s->pos += len;
587  s->buf_ptr = dst;
588  s->buf_end = dst + len;
590  s->bytes_read = ffiocontext(s)->bytes_read;
591  }
592 }
593 
594 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
595  unsigned int len)
596 {
597  return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
598 }
599 
600 unsigned long ff_crcEDB88320_update(unsigned long checksum, const uint8_t *buf,
601  unsigned int len)
602 {
603  return av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), checksum, buf, len);
604 }
605 
606 unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf,
607  unsigned int len)
608 {
609  return av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), checksum, buf, len);
610 }
611 
613 {
614  s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
615  s->buf_ptr - s->checksum_ptr);
616  s->update_checksum = NULL;
617  return s->checksum;
618 }
619 
621  unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
622  unsigned long checksum)
623 {
624  s->update_checksum = update_checksum;
625  if (s->update_checksum) {
626  s->checksum = checksum;
627  s->checksum_ptr = s->buf_ptr;
628  }
629 }
630 
631 /* XXX: put an inline version */
633 {
634  if (s->buf_ptr >= s->buf_end)
635  fill_buffer(s);
636  if (s->buf_ptr < s->buf_end)
637  return *s->buf_ptr++;
638  return 0;
639 }
640 
641 int avio_read(AVIOContext *s, unsigned char *buf, int size)
642 {
643  int len, size1;
644 
645  size1 = size;
646  while (size > 0) {
647  len = FFMIN(s->buf_end - s->buf_ptr, size);
648  if (len == 0 || s->write_flag) {
649  if((s->direct || size > s->buffer_size) && !s->update_checksum && s->read_packet) {
650  // bypass the buffer and read data directly into buf
651  len = read_packet_wrapper(s, buf, size);
652  if (len == AVERROR_EOF) {
653  /* do not modify buffer if EOF reached so that a seek back can
654  be done without rereading data */
655  s->eof_reached = 1;
656  break;
657  } else if (len < 0) {
658  s->eof_reached = 1;
659  s->error= len;
660  break;
661  } else {
662  s->pos += len;
664  s->bytes_read = ffiocontext(s)->bytes_read;
665  size -= len;
666  buf += len;
667  // reset the buffer
668  s->buf_ptr = s->buffer;
669  s->buf_end = s->buffer/* + len*/;
670  }
671  } else {
672  fill_buffer(s);
673  len = s->buf_end - s->buf_ptr;
674  if (len == 0)
675  break;
676  }
677  } else {
678  memcpy(buf, s->buf_ptr, len);
679  buf += len;
680  s->buf_ptr += len;
681  size -= len;
682  }
683  }
684  if (size1 == size) {
685  if (s->error) return s->error;
686  if (avio_feof(s)) return AVERROR_EOF;
687  }
688  return size1 - size;
689 }
690 
691 int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
692 {
693  int ret = avio_read(s, buf, size);
694  if (ret == size)
695  return ret;
696  if (ret < 0 && ret != AVERROR_EOF)
697  return ret;
698  return AVERROR_INVALIDDATA;
699 }
700 
701 int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsigned char **data)
702 {
703  if (s->buf_end - s->buf_ptr >= size && !s->write_flag) {
704  *data = s->buf_ptr;
705  s->buf_ptr += size;
706  return size;
707  } else {
708  *data = buf;
709  return avio_read(s, buf, size);
710  }
711 }
712 
713 int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
714 {
715  int len;
716 
717  if (size < 0)
718  return AVERROR(EINVAL);
719 
720  if (s->read_packet && s->write_flag) {
721  len = read_packet_wrapper(s, buf, size);
722  if (len > 0)
723  s->pos += len;
724  return len;
725  }
726 
727  len = s->buf_end - s->buf_ptr;
728  if (len == 0) {
729  fill_buffer(s);
730  len = s->buf_end - s->buf_ptr;
731  }
732  if (len > size)
733  len = size;
734  memcpy(buf, s->buf_ptr, len);
735  s->buf_ptr += len;
736  if (!len) {
737  if (s->error) return s->error;
738  if (avio_feof(s)) return AVERROR_EOF;
739  }
740  return len;
741 }
742 
743 unsigned int avio_rl16(AVIOContext *s)
744 {
745  unsigned int val;
746  val = avio_r8(s);
747  val |= avio_r8(s) << 8;
748  return val;
749 }
750 
751 unsigned int avio_rl24(AVIOContext *s)
752 {
753  unsigned int val;
754  val = avio_rl16(s);
755  val |= avio_r8(s) << 16;
756  return val;
757 }
758 
759 unsigned int avio_rl32(AVIOContext *s)
760 {
761  unsigned int val;
762  val = avio_rl16(s);
763  val |= avio_rl16(s) << 16;
764  return val;
765 }
766 
768 {
769  uint64_t val;
770  val = (uint64_t)avio_rl32(s);
771  val |= (uint64_t)avio_rl32(s) << 32;
772  return val;
773 }
774 
775 unsigned int avio_rb16(AVIOContext *s)
776 {
777  unsigned int val;
778  val = avio_r8(s) << 8;
779  val |= avio_r8(s);
780  return val;
781 }
782 
783 unsigned int avio_rb24(AVIOContext *s)
784 {
785  unsigned int val;
786  val = avio_rb16(s) << 8;
787  val |= avio_r8(s);
788  return val;
789 }
790 unsigned int avio_rb32(AVIOContext *s)
791 {
792  unsigned int val;
793  val = avio_rb16(s) << 16;
794  val |= avio_rb16(s);
795  return val;
796 }
797 
798 int ff_get_line(AVIOContext *s, char *buf, int maxlen)
799 {
800  int i = 0;
801  char c;
802 
803  do {
804  c = avio_r8(s);
805  if (c && i < maxlen-1)
806  buf[i++] = c;
807  } while (c != '\n' && c != '\r' && c);
808  if (c == '\r' && avio_r8(s) != '\n' && !avio_feof(s))
809  avio_skip(s, -1);
810 
811  buf[i] = 0;
812  return i;
813 }
814 
815 int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen)
816 {
817  int len = ff_get_line(s, buf, maxlen);
818  while (len > 0 && av_isspace(buf[len - 1]))
819  buf[--len] = '\0';
820  return len;
821 }
822 
827 
828 static int64_t read_string_to_bprint(AVIOContext *s, AVBPrint *bp,
830  int64_t max_len)
831 {
832  int len, end;
833  int64_t read = 0;
834  char tmp[1024];
835  char c;
836 
837  if (!max_len)
838  return 0;
839 
840  do {
841  len = 0;
842  do {
843  c = avio_r8(s);
844  end = ((mode == FFBPrintReadLine && (c == '\r' || c == '\n')) ||
845  c == '\0');
846  if (!end)
847  tmp[len++] = c;
848  } while (!end && len < sizeof(tmp) &&
849  ((max_len < 0) || (read + len < max_len)));
851  read += len;
852  } while (!end && ((max_len < 0) || (read < max_len)));
853 
854  if (mode == FFBPrintReadLine &&
855  c == '\r' && avio_r8(s) != '\n' && !avio_feof(s))
856  avio_skip(s, -1);
857 
858  if (!c && s->error)
859  return s->error;
860 
861  if (!c && !read && avio_feof(s))
862  return AVERROR_EOF;
863 
864  return read;
865 }
866 
867 static int64_t read_string_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp,
869  int64_t max_len)
870 {
871  int64_t ret;
872 
873  av_bprint_clear(bp);
874  ret = read_string_to_bprint(s, bp, mode, max_len);
875  if (ret < 0)
876  return ret;
877 
878  if (!av_bprint_is_complete(bp))
879  return AVERROR(ENOMEM);
880 
881  return bp->len;
882 }
883 
885 {
887 }
888 
890  int64_t max_len)
891 {
893 }
894 
895 int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
896 {
897  int i;
898 
899  if (buflen <= 0)
900  return AVERROR(EINVAL);
901  // reserve 1 byte for terminating 0
902  buflen = FFMIN(buflen - 1, maxlen);
903  for (i = 0; i < buflen; i++)
904  if (!(buf[i] = avio_r8(s)))
905  return i + 1;
906  buf[i] = 0;
907  for (; i < maxlen; i++)
908  if (!avio_r8(s))
909  return i + 1;
910  return maxlen;
911 }
912 
913 #define GET_STR16(type, read) \
914  int avio_get_str16 ##type(AVIOContext *pb, int maxlen, char *buf, int buflen)\
915 {\
916  char* q = buf;\
917  int ret = 0;\
918  if (buflen <= 0) \
919  return AVERROR(EINVAL); \
920  while (ret + 1 < maxlen) {\
921  uint8_t tmp;\
922  uint32_t ch;\
923  GET_UTF16(ch, (ret += 2) <= maxlen ? read(pb) : 0, break;)\
924  if (!ch)\
925  break;\
926  PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)\
927  }\
928  *q = 0;\
929  return ret;\
930 }\
931 
932 GET_STR16(le, avio_rl16)
934 
935 #undef GET_STR16
936 
938 {
939  uint64_t val;
940  val = (uint64_t)avio_rb32(s) << 32;
941  val |= (uint64_t)avio_rb32(s);
942  return val;
943 }
944 
946  uint64_t val = 0;
947  int tmp;
948 
949  do{
950  tmp = avio_r8(bc);
951  val= (val<<7) + (tmp&127);
952  }while(tmp&128);
953  return val;
954 }
955 
957 {
958  uint8_t *buffer = NULL;
959  int buffer_size, max_packet_size;
960 
961  max_packet_size = h->max_packet_size;
962  if (max_packet_size) {
963  buffer_size = max_packet_size; /* no need to bufferize more than one packet */
964  } else {
965  buffer_size = IO_BUFFER_SIZE;
966  }
967  if (!(h->flags & AVIO_FLAG_WRITE) && h->is_streamed) {
968  if (buffer_size > INT_MAX/2)
969  return AVERROR(EINVAL);
970  buffer_size *= 2;
971  }
972  buffer = av_malloc(buffer_size);
973  if (!buffer)
974  return AVERROR(ENOMEM);
975 
976  *s = avio_alloc_context(buffer, buffer_size, h->flags & AVIO_FLAG_WRITE, h,
977  (int (*)(void *, uint8_t *, int)) ffurl_read,
978  (int (*)(void *, uint8_t *, int)) ffurl_write,
979  (int64_t (*)(void *, int64_t, int))ffurl_seek);
980  if (!*s) {
981  av_freep(&buffer);
982  return AVERROR(ENOMEM);
983  }
984  (*s)->protocol_whitelist = av_strdup(h->protocol_whitelist);
985  if (!(*s)->protocol_whitelist && h->protocol_whitelist) {
986  avio_closep(s);
987  return AVERROR(ENOMEM);
988  }
989  (*s)->protocol_blacklist = av_strdup(h->protocol_blacklist);
990  if (!(*s)->protocol_blacklist && h->protocol_blacklist) {
991  avio_closep(s);
992  return AVERROR(ENOMEM);
993  }
994  (*s)->direct = h->flags & AVIO_FLAG_DIRECT;
995 
996  (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
997  (*s)->max_packet_size = max_packet_size;
998  (*s)->min_packet_size = h->min_packet_size;
999  if(h->prot) {
1000  (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
1001  (*s)->read_seek =
1002  (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;
1003 
1004  if (h->prot->url_read_seek)
1005  (*s)->seekable |= AVIO_SEEKABLE_TIME;
1006  }
1007  ((FFIOContext*)(*s))->short_seek_get = (int (*)(void *))ffurl_get_short_seek;
1008  (*s)->av_class = &ff_avio_class;
1009  return 0;
1010 }
1011 
1013 {
1014  if (!s)
1015  return NULL;
1016 
1017  if (s->opaque && s->read_packet == (int (*)(void *, uint8_t *, int))ffurl_read)
1018  return s->opaque;
1019  else
1020  return NULL;
1021 }
1022 
1024 {
1025  const char *opts[] = {
1026  "headers", "user_agent", "cookies", "http_proxy", "referer", "rw_timeout", "icy", NULL };
1027  const char **opt = opts;
1028  uint8_t *buf = NULL;
1029  int ret = 0;
1030 
1031  while (*opt) {
1032  if (av_opt_get(pb, *opt, AV_OPT_SEARCH_CHILDREN, &buf) >= 0) {
1033  if (buf[0] != '\0') {
1034  ret = av_dict_set(avio_opts, *opt, buf, AV_DICT_DONT_STRDUP_VAL);
1035  if (ret < 0)
1036  return ret;
1037  } else {
1038  av_freep(&buf);
1039  }
1040  }
1041  opt++;
1042  }
1043 
1044  return ret;
1045 }
1046 
1048 {
1049  if (s->update_checksum && s->buf_ptr > s->checksum_ptr) {
1050  s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
1051  s->buf_ptr - s->checksum_ptr);
1052  }
1053 }
1054 
1055 int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
1056 {
1057  uint8_t *buffer;
1058  int max_buffer_size = s->max_packet_size ?
1059  s->max_packet_size : IO_BUFFER_SIZE;
1060  ptrdiff_t filled = s->buf_end - s->buf_ptr;
1061 
1062  if (buf_size <= s->buf_end - s->buf_ptr)
1063  return 0;
1064 
1065  buf_size += max_buffer_size - 1;
1066 
1067  if (buf_size + s->buf_ptr - s->buffer <= s->buffer_size || s->seekable || !s->read_packet)
1068  return 0;
1069  av_assert0(!s->write_flag);
1070 
1071  if (buf_size <= s->buffer_size) {
1072  update_checksum(s);
1073  memmove(s->buffer, s->buf_ptr, filled);
1074  } else {
1075  buffer = av_malloc(buf_size);
1076  if (!buffer)
1077  return AVERROR(ENOMEM);
1078  update_checksum(s);
1079  memcpy(buffer, s->buf_ptr, filled);
1080  av_free(s->buffer);
1081  s->buffer = buffer;
1082  s->buffer_size = buf_size;
1083  }
1084  s->buf_ptr = s->buffer;
1085  s->buf_end = s->buffer + filled;
1086  s->checksum_ptr = s->buffer;
1087  return 0;
1088 }
1089 
1091 {
1092  FFIOContext *const ctx = ffiocontext(s);
1093  if (ctx->maxsize >= 0) {
1094  int64_t pos = avio_tell(s);
1095  int64_t remaining = ctx->maxsize - pos;
1096  if (remaining < size) {
1097  int64_t newsize = avio_size(s);
1098  if (!ctx->maxsize || ctx->maxsize < newsize)
1099  ctx->maxsize = newsize - !newsize;
1100  if (pos > ctx->maxsize && ctx->maxsize >= 0)
1101  ctx->maxsize = AVERROR(EIO);
1102  if (ctx->maxsize >= 0)
1103  remaining = ctx->maxsize - pos;
1104  }
1105 
1106  if (ctx->maxsize >= 0 && remaining < size && size > 1) {
1107  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG,
1108  "Truncating packet of size %d to %"PRId64"\n",
1109  size, remaining + !remaining);
1110  size = remaining + !remaining;
1111  }
1112  }
1113  return size;
1114 }
1115 
1116 static int set_buf_size(AVIOContext *s, int buf_size)
1117 {
1118  uint8_t *buffer;
1119  buffer = av_malloc(buf_size);
1120  if (!buffer)
1121  return AVERROR(ENOMEM);
1122 
1123  av_free(s->buffer);
1124  s->buffer = buffer;
1126  s->buffer_size = buf_size;
1127  s->buf_ptr = s->buf_ptr_max = buffer;
1128  url_resetbuf(s, s->write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
1129  return 0;
1130 }
1131 
1132 int ffio_realloc_buf(AVIOContext *s, int buf_size)
1133 {
1134  uint8_t *buffer;
1135  int data_size;
1136 
1137  if (!s->buffer_size)
1138  return set_buf_size(s, buf_size);
1139 
1140  if (buf_size <= s->buffer_size)
1141  return 0;
1142 
1143  buffer = av_malloc(buf_size);
1144  if (!buffer)
1145  return AVERROR(ENOMEM);
1146 
1147  data_size = s->write_flag ? (s->buf_ptr - s->buffer) : (s->buf_end - s->buf_ptr);
1148  if (data_size > 0)
1149  memcpy(buffer, s->write_flag ? s->buffer : s->buf_ptr, data_size);
1150  av_free(s->buffer);
1151  s->buffer = buffer;
1152  ffiocontext(s)->orig_buffer_size = buf_size;
1153  s->buffer_size = buf_size;
1154  s->buf_ptr = s->write_flag ? (s->buffer + data_size) : s->buffer;
1155  if (s->write_flag)
1156  s->buf_ptr_max = s->buffer + data_size;
1157 
1158  s->buf_end = s->write_flag ? (s->buffer + s->buffer_size) : (s->buf_ptr + data_size);
1159 
1160  return 0;
1161 }
1162 
1163 static int url_resetbuf(AVIOContext *s, int flags)
1164 {
1166 
1167  if (flags & AVIO_FLAG_WRITE) {
1168  s->buf_end = s->buffer + s->buffer_size;
1169  s->write_flag = 1;
1170  } else {
1171  s->buf_end = s->buffer;
1172  s->write_flag = 0;
1173  }
1174  return 0;
1175 }
1176 
1177 int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_size)
1178 {
1179  int64_t buffer_start;
1180  int buffer_size;
1181  int overlap, new_size, alloc_size;
1182  uint8_t *buf = *bufp;
1183 
1184  if (s->write_flag) {
1185  av_freep(bufp);
1186  return AVERROR(EINVAL);
1187  }
1188 
1189  buffer_size = s->buf_end - s->buffer;
1190 
1191  /* the buffers must touch or overlap */
1192  if ((buffer_start = s->pos - buffer_size) > buf_size) {
1193  av_freep(bufp);
1194  return AVERROR(EINVAL);
1195  }
1196 
1197  overlap = buf_size - buffer_start;
1198  new_size = buf_size + buffer_size - overlap;
1199 
1200  alloc_size = FFMAX(s->buffer_size, new_size);
1201  if (alloc_size > buf_size)
1202  if (!(buf = (*bufp) = av_realloc_f(buf, 1, alloc_size)))
1203  return AVERROR(ENOMEM);
1204 
1205  if (new_size > buf_size) {
1206  memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
1207  buf_size = new_size;
1208  }
1209 
1210  av_free(s->buffer);
1211  s->buf_ptr = s->buffer = buf;
1212  s->buffer_size = alloc_size;
1213  s->pos = buf_size;
1214  s->buf_end = s->buf_ptr + buf_size;
1215  s->eof_reached = 0;
1216 
1217  return 0;
1218 }
1219 
1220 int avio_open(AVIOContext **s, const char *filename, int flags)
1221 {
1222  return avio_open2(s, filename, flags, NULL, NULL);
1223 }
1224 
1225 int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags,
1227  const char *whitelist, const char *blacklist
1228  )
1229 {
1230  URLContext *h;
1231  int err;
1232 
1233  *s = NULL;
1234 
1235  err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist, NULL);
1236  if (err < 0)
1237  return err;
1238  err = ffio_fdopen(s, h);
1239  if (err < 0) {
1240  ffurl_close(h);
1241  return err;
1242  }
1243  return 0;
1244 }
1245 
1246 int avio_open2(AVIOContext **s, const char *filename, int flags,
1248 {
1249  return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL, NULL);
1250 }
1251 
1253 {
1254  FFIOContext *const ctx = ffiocontext(s);
1255  URLContext *h;
1256  int ret, error;
1257 
1258  if (!s)
1259  return 0;
1260 
1261  avio_flush(s);
1262  h = s->opaque;
1263  s->opaque = NULL;
1264 
1265  av_freep(&s->buffer);
1266  if (s->write_flag)
1268  "Statistics: %"PRId64" bytes written, %d seeks, %d writeouts\n",
1269  ctx->bytes_written, ctx->seek_count, ctx->writeout_count);
1270  else
1271  av_log(s, AV_LOG_VERBOSE, "Statistics: %"PRId64" bytes read, %d seeks\n",
1272  ctx->bytes_read, ctx->seek_count);
1273  av_opt_free(s);
1274 
1275  error = s->error;
1276  avio_context_free(&s);
1277 
1278  ret = ffurl_close(h);
1279  if (ret < 0)
1280  return ret;
1281 
1282  return error;
1283 }
1284 
1286 {
1287  int ret = avio_close(*s);
1288  *s = NULL;
1289  return ret;
1290 }
1291 
1292 int avio_printf(AVIOContext *s, const char *fmt, ...)
1293 {
1294  va_list ap;
1295  AVBPrint bp;
1296 
1297  av_bprint_init(&bp, 0, INT_MAX);
1298  va_start(ap, fmt);
1299  av_vbprintf(&bp, fmt, ap);
1300  va_end(ap);
1301  if (!av_bprint_is_complete(&bp)) {
1302  av_bprint_finalize(&bp, NULL);
1303  s->error = AVERROR(ENOMEM);
1304  return AVERROR(ENOMEM);
1305  }
1306  avio_write(s, bp.str, bp.len);
1307  av_bprint_finalize(&bp, NULL);
1308  return bp.len;
1309 }
1310 
1311 void avio_print_string_array(AVIOContext *s, const char *strings[])
1312 {
1313  for(; *strings; strings++)
1314  avio_write(s, (const unsigned char *)*strings, strlen(*strings));
1315 }
1316 
1317 int avio_pause(AVIOContext *s, int pause)
1318 {
1319  if (!s->read_pause)
1320  return AVERROR(ENOSYS);
1321  return s->read_pause(s->opaque, pause);
1322 }
1323 
1324 int64_t avio_seek_time(AVIOContext *s, int stream_index,
1325  int64_t timestamp, int flags)
1326 {
1327  int64_t ret;
1328  if (!s->read_seek)
1329  return AVERROR(ENOSYS);
1330  ret = s->read_seek(s->opaque, stream_index, timestamp, flags);
1331  if (ret >= 0) {
1332  int64_t pos;
1333  s->buf_ptr = s->buf_end; // Flush buffer
1334  pos = s->seek(s->opaque, 0, SEEK_CUR);
1335  if (pos >= 0)
1336  s->pos = pos;
1337  else if (pos != AVERROR(ENOSYS))
1338  ret = pos;
1339  }
1340  return ret;
1341 }
1342 
1343 int avio_read_to_bprint(AVIOContext *h, AVBPrint *pb, size_t max_size)
1344 {
1345  int ret;
1346  char buf[1024];
1347  while (max_size) {
1348  ret = avio_read(h, buf, FFMIN(max_size, sizeof(buf)));
1349  if (ret == AVERROR_EOF)
1350  return 0;
1351  if (ret <= 0)
1352  return ret;
1353  av_bprint_append_data(pb, buf, ret);
1354  if (!av_bprint_is_complete(pb))
1355  return AVERROR(ENOMEM);
1356  max_size -= ret;
1357  }
1358  return 0;
1359 }
1360 
1362 {
1363  int ret;
1364  URLContext *sc = s->opaque;
1365  URLContext *cc = NULL;
1366  ret = ffurl_accept(sc, &cc);
1367  if (ret < 0)
1368  return ret;
1369  return ffio_fdopen(c, cc);
1370 }
1371 
1373 {
1374  URLContext *cc = c->opaque;
1375  return ffurl_handshake(cc);
1376 }
1377 
1378 /* output in a dynamic buffer */
1379 
1380 typedef struct DynBuffer {
1382  uint8_t *buffer;
1384  uint8_t io_buffer[1];
1385 } DynBuffer;
1386 
1387 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
1388 {
1389  DynBuffer *d = opaque;
1390  unsigned new_size;
1391 
1392  /* reallocate buffer if needed */
1393  new_size = (unsigned)d->pos + buf_size;
1394  if (new_size < d->pos || new_size > INT_MAX)
1395  return AVERROR(ERANGE);
1396  if (new_size > d->allocated_size) {
1397  unsigned new_allocated_size = d->allocated_size ? d->allocated_size
1398  : new_size;
1399  int err;
1400  while (new_size > new_allocated_size)
1401  new_allocated_size += new_allocated_size / 2 + 1;
1402 
1403  new_allocated_size = FFMIN(new_allocated_size, INT_MAX);
1404 
1405  if ((err = av_reallocp(&d->buffer, new_allocated_size)) < 0) {
1406  d->allocated_size = 0;
1407  d->size = 0;
1408  return err;
1409  }
1410  d->allocated_size = new_allocated_size;
1411  }
1412  memcpy(d->buffer + d->pos, buf, buf_size);
1413  d->pos = new_size;
1414  if (d->pos > d->size)
1415  d->size = d->pos;
1416  return buf_size;
1417 }
1418 
1419 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
1420 {
1421  unsigned char buf1[4];
1422  int ret;
1423 
1424  /* packetized write: output the header */
1425  AV_WB32(buf1, buf_size);
1426  ret = dyn_buf_write(opaque, buf1, 4);
1427  if (ret < 0)
1428  return ret;
1429 
1430  /* then the data */
1431  return dyn_buf_write(opaque, buf, buf_size);
1432 }
1433 
1434 static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
1435 {
1436  DynBuffer *d = opaque;
1437 
1438  if (whence == SEEK_CUR)
1439  offset += d->pos;
1440  else if (whence == SEEK_END)
1441  offset += d->size;
1442  if (offset < 0)
1443  return AVERROR(EINVAL);
1444  if (offset > INT_MAX)
1445  return AVERROR(ERANGE);
1446  d->pos = offset;
1447  return 0;
1448 }
1449 
1450 static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
1451 {
1452  struct { FFIOContext pb; DynBuffer d; } *ret;
1453  DynBuffer *d;
1454  unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
1455 
1456  if (sizeof(*ret) + io_buffer_size < io_buffer_size)
1457  return AVERROR(ERANGE);
1458  ret = av_mallocz(sizeof(*ret) + io_buffer_size);
1459  if (!ret)
1460  return AVERROR(ENOMEM);
1461  d = &ret->d;
1462  d->io_buffer_size = io_buffer_size;
1463  ffio_init_context(&ret->pb, d->io_buffer, d->io_buffer_size, 1, d, NULL,
1464  max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
1465  max_packet_size ? NULL : dyn_buf_seek);
1466  *s = &ret->pb.pub;
1467  (*s)->max_packet_size = max_packet_size;
1468  return 0;
1469 }
1470 
1472 {
1473  return url_open_dyn_buf_internal(s, 0);
1474 }
1475 
1476 int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
1477 {
1478  if (max_packet_size <= 0)
1479  return AVERROR(EINVAL);
1480  return url_open_dyn_buf_internal(s, max_packet_size);
1481 }
1482 
1483 int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1484 {
1485  DynBuffer *d;
1486 
1487  if (!s) {
1488  *pbuffer = NULL;
1489  return 0;
1490  }
1491  d = s->opaque;
1492 
1493  if (!s->error && !d->size) {
1494  *pbuffer = d->io_buffer;
1495  return FFMAX(s->buf_ptr, s->buf_ptr_max) - s->buffer;
1496  }
1497 
1498  avio_flush(s);
1499 
1500  *pbuffer = d->buffer;
1501 
1502  return d->size;
1503 }
1504 
1506 {
1507  DynBuffer *d = s->opaque;
1508  int max_packet_size = s->max_packet_size;
1509 
1510  ffio_init_context(ffiocontext(s), d->io_buffer, d->io_buffer_size,
1511  1, d, NULL, s->write_packet, s->seek);
1512  s->max_packet_size = max_packet_size;
1513  d->pos = d->size = 0;
1514 }
1515 
1516 int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1517 {
1518  DynBuffer *d;
1519  int size;
1520  int padding = 0;
1521 
1522  if (!s) {
1523  *pbuffer = NULL;
1524  return 0;
1525  }
1526 
1527  /* don't attempt to pad fixed-size packet buffers */
1528  if (!s->max_packet_size) {
1530  padding = AV_INPUT_BUFFER_PADDING_SIZE;
1531  }
1532 
1533  avio_flush(s);
1534 
1535  d = s->opaque;
1536  *pbuffer = d->buffer;
1537  size = d->size;
1538 
1539  avio_context_free(&s);
1540 
1541  return size - padding;
1542 }
1543 
1545 {
1546  DynBuffer *d;
1547 
1548  if (!*s)
1549  return;
1550 
1551  d = (*s)->opaque;
1552  av_free(d->buffer);
1554 }
1555 
1556 static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
1557 {
1558  DynBuffer *d = opaque;
1559 
1560  d->pos += buf_size;
1561  if (d->pos > d->size)
1562  d->size = d->pos;
1563  return buf_size;
1564 }
1565 
1567 {
1568  int ret = url_open_dyn_buf_internal(s, 0);
1569  if (ret >= 0) {
1570  AVIOContext *pb = *s;
1572  }
1573  return ret;
1574 }
1575 
1577 {
1578  DynBuffer *d = s->opaque;
1579  int size;
1580 
1581  avio_flush(s);
1582 
1583  size = d->size;
1584 
1585  avio_context_free(&s);
1586 
1587  return size;
1588 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
ff_get_chomp_line
int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen)
Same as ff_get_line but strip the white-space characters in the text tail.
Definition: aviobuf.c:815
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
put_str16
static int put_str16(AVIOContext *s, const char *str, const int be)
Definition: aviobuf.c:413
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375
AVIO_DATA_MARKER_BOUNDARY_POINT
@ AVIO_DATA_MARKER_BOUNDARY_POINT
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:129
null_buf_write
static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1556
ffurl_context_class
const AVClass ffurl_context_class
Definition: avio.c:64
D
#define D
Definition: aviobuf.c:61
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
avio_get_dyn_buf
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1483
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
url_open_dyn_buf_internal
static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
Definition: aviobuf.c:1450
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
ffiocontext
static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)
Definition: avio_internal.h:82
ffurl_seek
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:428
avio_rl24
unsigned int avio_rl24(AVIOContext *s)
Definition: aviobuf.c:751
dyn_buf_seek
static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
Definition: aviobuf.c:1434
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
avio_wl24
void avio_wl24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:478
av_isspace
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:227
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
ffio_get_checksum
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:612
DynBuffer::buffer
uint8_t * buffer
Definition: aviobuf.c:1382
ffio_open_null_buf
int ffio_open_null_buf(AVIOContext **s)
Open a write-only fake memory stream.
Definition: aviobuf.c:1566
ffio_geturlcontext
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
Definition: aviobuf.c:1012
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:34
AVSEEK_SIZE
#define AVSEEK_SIZE
ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...
Definition: avio.h:479
IO_BUFFER_SIZE
#define IO_BUFFER_SIZE
Definition: aviobuf.c:37
data
const char data[16]
Definition: mxf.c:143
avio_seek_time
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:1324
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
avio_accept
int avio_accept(AVIOContext *s, AVIOContext **c)
Accept and allocate a client context on a server context.
Definition: aviobuf.c:1361
ffurl_close
int ffurl_close(URLContext *h)
Definition: avio.c:461
DynBuffer::io_buffer
uint8_t io_buffer[1]
Definition: aviobuf.c:1384
avio_put_str
int avio_put_str(AVIOContext *s, const char *str)
Write a NULL-terminated string.
Definition: aviobuf.c:402
AVDictionary
Definition: dict.c:30
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:386
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:158
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
avio_read_to_bprint
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:1343
ff_crcEDB88320_update
unsigned long ff_crcEDB88320_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:600
FFBPrintReadString
@ FFBPrintReadString
Definition: aviobuf.c:824
AVIODataMarkerType
AVIODataMarkerType
Different data types that can be returned via the AVIO write_data_type callback.
Definition: avio.h:112
FFIOContext
Definition: avio_internal.h:29
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
update_checksum
static void update_checksum(AVIOContext *s)
Definition: aviobuf.c:1047
fill_buffer
static void fill_buffer(AVIOContext *s)
Definition: aviobuf.c:540
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:59
crc.h
ffio_reset_dyn_buf
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1505
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
AV_CRC_16_ANSI_LE
@ AV_CRC_16_ANSI_LE
Definition: crc.h:54
val
static double val(void *priv, double ch)
Definition: aeval.c:77
avio_wb24
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:484
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:466
ffio_open_whitelist
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:1225
OFFSET
#define OFFSET(x)
Definition: aviobuf.c:59
ff_avio_child_next
static void * ff_avio_child_next(void *obj, void *prev)
Definition: aviobuf.c:46
avio_print_string_array
void avio_print_string_array(AVIOContext *s, const char *strings[])
Write a NULL terminated array of strings to the context.
Definition: aviobuf.c:1311
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:72
GET_UTF8
#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:469
flush_buffer
static void flush_buffer(AVIOContext *s)
Definition: aviobuf.c:194
avassert.h
ffio_copy_url_options
int ffio_copy_url_options(AVIOContext *pb, AVDictionary **avio_opts)
Read url related dictionary options from the AVIOContext and write to the given dictionary.
Definition: aviobuf.c:1023
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:490
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:252
ff_read_string_to_bprint_overwrite
int64_t ff_read_string_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp, int64_t max_len)
Read a whole null-terminated string of text from AVIOContext to an AVBPrint buffer overwriting its co...
Definition: aviobuf.c:889
ffurl_open_whitelist
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:306
FFIOContext::bytes_read
int64_t bytes_read
Bytes read statistic.
Definition: avio_internal.h:52
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:394
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
ffio_read_size
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:691
ff_avio_class
const AVClass ff_avio_class
Definition: aviobuf.c:67
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1516
ffio_init_context
void ffio_init_context(FFIOContext *ctx, 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
DynBuffer::pos
int pos
Definition: aviobuf.c:1381
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:218
ffio_read_indirect
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:701
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:623
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
avio_context_free
void avio_context_free(AVIOContext **ps)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:152
if
if(ret)
Definition: filter_design.txt:179
ffurl_accept
int ffurl_accept(URLContext *s, URLContext **c)
Accept an URLContext c on an URLContext s.
Definition: avio.c:226
av_vbprintf
void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg)
Append a formatted string to a print buffer.
Definition: bprint.c:117
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:32
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
ffio_limit
int ffio_limit(AVIOContext *s, int size)
Definition: aviobuf.c:1090
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:641
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_avio_options
static const AVOption ff_avio_options[]
Definition: aviobuf.c:62
NULL
#define NULL
Definition: coverity.c:32
DynBuffer
Definition: aviobuf.c:1380
AVIO_DATA_MARKER_TRAILER
@ AVIO_DATA_MARKER_TRAILER
Trailer data, which doesn't contain actual content, but only for finalizing the output file.
Definition: avio.h:141
PUT_UTF16
#define PUT_UTF16(val, tmp, PUT_16BIT)
Definition: common.h:556
FFIOContext::orig_buffer_size
int orig_buffer_size
Original buffer size used after probing to ensure seekback and to reset the buffer size.
Definition: avio_internal.h:73
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...)
Definition: aviobuf.c:1292
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
read_string_to_bprint
static int64_t read_string_to_bprint(AVIOContext *s, AVBPrint *bp, FFBPrintReadStringMode mode, int64_t max_len)
Definition: aviobuf.c:828
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1718
SHORT_SEEK_THRESHOLD
#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:44
read_packet_wrapper
static int read_packet_wrapper(AVIOContext *s, uint8_t *buf, int size)
Definition: aviobuf.c:527
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
avio_pause
int avio_pause(AVIOContext *s, int pause)
Pause and resume playing - only meaningful if using a network streaming protocol (e....
Definition: aviobuf.c:1317
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:783
dyn_packet_buf_write
static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1419
options
const OptionDef options[]
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:775
ffio_realloc_buf
int ffio_realloc_buf(AVIOContext *s, int buf_size)
Reallocate a given buffer for AVIOContext.
Definition: aviobuf.c:1132
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
ff_read_line_to_bprint_overwrite
int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp)
Read a whole line of text from AVIOContext to an AVBPrint buffer overwriting its contents.
Definition: aviobuf.c:884
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1544
size
int size
Definition: twinvq_data.h:10344
avio.h
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1055
av_reallocp
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:186
avio_open
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:1220
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVIO_SEEKABLE_TIME
#define AVIO_SEEKABLE_TIME
Seeking by timestamp with avio_seek_time() is possible.
Definition: avio.h:46
dyn_buf_write
static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1387
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
avio_rl64
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:767
ffio_rewind_with_probe_data
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:1177
AVIO_DATA_MARKER_SYNC_POINT
@ AVIO_DATA_MARKER_SYNC_POINT
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:123
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1252
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:563
AVIOContext::write_packet
int(* write_packet)(void *opaque, uint8_t *buf, int buf_size)
Definition: avio.h:237
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
avio_open2
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:1246
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
ffurl_get_short_seek
int ffurl_get_short_seek(URLContext *h)
Return the current short seek threshold value for this URL.
Definition: avio.c:644
ffio_init_checksum
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:620
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
ffio_open_dyn_packet_buf
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:1476
bprint.h
URLContext
Definition: url.h:37
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
avio_internal.h
PUT_STR16
#define PUT_STR16(type, big_endian)
Definition: aviobuf.c:443
FFBPrintReadLine
@ FFBPrintReadLine
Definition: aviobuf.c:825
internal.h
ffio_read_varlen
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:945
read_string_to_bprint_overwrite
static int64_t read_string_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp, FFBPrintReadStringMode mode, int64_t max_len)
Definition: aviobuf.c:867
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
url.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:798
GET_STR16
#define GET_STR16(type, read)
Definition: aviobuf.c:913
len
int len
Definition: vorbis_enc_data.h:426
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:513
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
DynBuffer::io_buffer_size
int io_buffer_size
Definition: aviobuf.c:1383
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:460
AVIO_DATA_MARKER_UNKNOWN
@ AVIO_DATA_MARKER_UNKNOWN
This is any, unlabelled data.
Definition: avio.h:136
avio_get_str
int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:895
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVClass::class_name
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:71
pos
unsigned int pos
Definition: spdifenc.c:412
dict.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
ff_crc04C11DB7_update
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:594
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
ffurl_read
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:401
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
av_crc
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:392
url_resetbuf
static int url_resetbuf(AVIOContext *s, int flags)
Definition: aviobuf.c:1163
mode
mode
Definition: ebur128.h:83
defs.h
AVIO_DATA_MARKER_HEADER
@ AVIO_DATA_MARKER_HEADER
Header data; this needs to be present for the stream to be decodeable.
Definition: avio.h:116
ffurl_write
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:415
ff_crcA001_update
unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:606
DynBuffer::size
int size
Definition: aviobuf.c:1381
AVSEEK_FORCE
#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:487
AVIO_FLAG_DIRECT
#define AVIO_FLAG_DIRECT
Use direct mode.
Definition: avio.h:649
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AV_CRC_32_IEEE_LE
@ AV_CRC_32_IEEE_LE
Definition: crc.h:53
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:622
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
avio_alloc_context
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:135
ffio_fdopen
int ffio_fdopen(AVIOContext **s, URLContext *h)
Create and initialize a AVIOContext for accessing the resource referenced by the URLContext h.
Definition: aviobuf.c:956
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1471
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
ffurl_handshake
int ffurl_handshake(URLContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: avio.c:234
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
DynBuffer::allocated_size
int allocated_size
Definition: aviobuf.c:1381
set_buf_size
static int set_buf_size(AVIOContext *s, int buf_size)
Definition: aviobuf.c:1116
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
d
d
Definition: ffmpeg_filter.c:153
convert_header.str
string str
Definition: convert_header.py:20
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:837
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ffio_close_null_buf
int ffio_close_null_buf(AVIOContext *s)
Close a null buffer.
Definition: aviobuf.c:1576
h
h
Definition: vp9dsp_template.c:2038
write_packet
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:92
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
avio_handshake
int avio_handshake(AVIOContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: aviobuf.c:1372
writeout
static void writeout(AVIOContext *s, const uint8_t *data, int len)
Definition: aviobuf.c:157
child_class_iterate
static const AVClass * child_class_iterate(void **iter)
Definition: aviobuf.c:52
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:352
avio_read_partial
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:713
int
int
Definition: ffmpeg_filter.c:153
avio_wl64
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:454
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:937
FFBPrintReadStringMode
FFBPrintReadStringMode
Definition: aviobuf.c:823
avio_closep
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:1285
AVIO_DATA_MARKER_FLUSH_POINT
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:147