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 {
598 }
599 
600 unsigned long ff_crcEDB88320_update(unsigned long checksum, const uint8_t *buf,
601  unsigned int len)
602 {
604 }
605 
606 unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf,
607  unsigned int len)
608 {
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) {
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  goto fail;
982 
983  (*s)->protocol_whitelist = av_strdup(h->protocol_whitelist);
984  if (!(*s)->protocol_whitelist && h->protocol_whitelist) {
985  avio_closep(s);
986  goto fail;
987  }
988  (*s)->protocol_blacklist = av_strdup(h->protocol_blacklist);
989  if (!(*s)->protocol_blacklist && h->protocol_blacklist) {
990  avio_closep(s);
991  goto fail;
992  }
993  (*s)->direct = h->flags & AVIO_FLAG_DIRECT;
994 
995  (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
996  (*s)->max_packet_size = max_packet_size;
997  (*s)->min_packet_size = h->min_packet_size;
998  if(h->prot) {
999  (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
1000  (*s)->read_seek =
1001  (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;
1002 
1003  if (h->prot->url_read_seek)
1004  (*s)->seekable |= AVIO_SEEKABLE_TIME;
1005  }
1006  ((FFIOContext*)(*s))->short_seek_get = (int (*)(void *))ffurl_get_short_seek;
1007  (*s)->av_class = &ff_avio_class;
1008  return 0;
1009 fail:
1010  av_freep(&buffer);
1011  return AVERROR(ENOMEM);
1012 }
1013 
1015 {
1016  if (!s)
1017  return NULL;
1018 
1019  if (s->opaque && s->read_packet == (int (*)(void *, uint8_t *, int))ffurl_read)
1020  return s->opaque;
1021  else
1022  return NULL;
1023 }
1024 
1026 {
1027  if (s->update_checksum && s->buf_ptr > s->checksum_ptr) {
1028  s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
1029  s->buf_ptr - s->checksum_ptr);
1030  }
1031 }
1032 
1033 int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
1034 {
1035  uint8_t *buffer;
1036  int max_buffer_size = s->max_packet_size ?
1037  s->max_packet_size : IO_BUFFER_SIZE;
1038  ptrdiff_t filled = s->buf_end - s->buf_ptr;
1039 
1040  if (buf_size <= s->buf_end - s->buf_ptr)
1041  return 0;
1042 
1043  buf_size += max_buffer_size - 1;
1044 
1045  if (buf_size + s->buf_ptr - s->buffer <= s->buffer_size || s->seekable || !s->read_packet)
1046  return 0;
1047  av_assert0(!s->write_flag);
1048 
1049  if (buf_size <= s->buffer_size) {
1050  update_checksum(s);
1051  memmove(s->buffer, s->buf_ptr, filled);
1052  } else {
1053  buffer = av_malloc(buf_size);
1054  if (!buffer)
1055  return AVERROR(ENOMEM);
1056  update_checksum(s);
1057  memcpy(buffer, s->buf_ptr, filled);
1058  av_free(s->buffer);
1059  s->buffer = buffer;
1060  s->buffer_size = buf_size;
1061  }
1062  s->buf_ptr = s->buffer;
1063  s->buf_end = s->buffer + filled;
1064  s->checksum_ptr = s->buffer;
1065  return 0;
1066 }
1067 
1069 {
1070  FFIOContext *const ctx = ffiocontext(s);
1071  if (ctx->maxsize >= 0) {
1072  int64_t pos = avio_tell(s);
1073  int64_t remaining = ctx->maxsize - pos;
1074  if (remaining < size) {
1075  int64_t newsize = avio_size(s);
1076  if (!ctx->maxsize || ctx->maxsize < newsize)
1077  ctx->maxsize = newsize - !newsize;
1078  if (pos > ctx->maxsize && ctx->maxsize >= 0)
1079  ctx->maxsize = AVERROR(EIO);
1080  if (ctx->maxsize >= 0)
1081  remaining = ctx->maxsize - pos;
1082  }
1083 
1084  if (ctx->maxsize >= 0 && remaining < size && size > 1) {
1085  av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG,
1086  "Truncating packet of size %d to %"PRId64"\n",
1087  size, remaining + !remaining);
1088  size = remaining + !remaining;
1089  }
1090  }
1091  return size;
1092 }
1093 
1094 static int set_buf_size(AVIOContext *s, int buf_size)
1095 {
1096  uint8_t *buffer;
1097  buffer = av_malloc(buf_size);
1098  if (!buffer)
1099  return AVERROR(ENOMEM);
1100 
1101  av_free(s->buffer);
1102  s->buffer = buffer;
1104  s->buffer_size = buf_size;
1105  s->buf_ptr = s->buf_ptr_max = buffer;
1106  url_resetbuf(s, s->write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
1107  return 0;
1108 }
1109 
1110 int ffio_realloc_buf(AVIOContext *s, int buf_size)
1111 {
1112  uint8_t *buffer;
1113  int data_size;
1114 
1115  if (!s->buffer_size)
1116  return set_buf_size(s, buf_size);
1117 
1118  if (buf_size <= s->buffer_size)
1119  return 0;
1120 
1121  buffer = av_malloc(buf_size);
1122  if (!buffer)
1123  return AVERROR(ENOMEM);
1124 
1125  data_size = s->write_flag ? (s->buf_ptr - s->buffer) : (s->buf_end - s->buf_ptr);
1126  if (data_size > 0)
1127  memcpy(buffer, s->write_flag ? s->buffer : s->buf_ptr, data_size);
1128  av_free(s->buffer);
1129  s->buffer = buffer;
1130  ffiocontext(s)->orig_buffer_size = buf_size;
1131  s->buffer_size = buf_size;
1132  s->buf_ptr = s->write_flag ? (s->buffer + data_size) : s->buffer;
1133  if (s->write_flag)
1134  s->buf_ptr_max = s->buffer + data_size;
1135 
1136  s->buf_end = s->write_flag ? (s->buffer + s->buffer_size) : (s->buf_ptr + data_size);
1137 
1138  return 0;
1139 }
1140 
1141 static int url_resetbuf(AVIOContext *s, int flags)
1142 {
1144 
1145  if (flags & AVIO_FLAG_WRITE) {
1146  s->buf_end = s->buffer + s->buffer_size;
1147  s->write_flag = 1;
1148  } else {
1149  s->buf_end = s->buffer;
1150  s->write_flag = 0;
1151  }
1152  return 0;
1153 }
1154 
1155 int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_size)
1156 {
1157  int64_t buffer_start;
1158  int buffer_size;
1159  int overlap, new_size, alloc_size;
1160  uint8_t *buf = *bufp;
1161 
1162  if (s->write_flag) {
1163  av_freep(bufp);
1164  return AVERROR(EINVAL);
1165  }
1166 
1167  buffer_size = s->buf_end - s->buffer;
1168 
1169  /* the buffers must touch or overlap */
1170  if ((buffer_start = s->pos - buffer_size) > buf_size) {
1171  av_freep(bufp);
1172  return AVERROR(EINVAL);
1173  }
1174 
1175  overlap = buf_size - buffer_start;
1176  new_size = buf_size + buffer_size - overlap;
1177 
1178  alloc_size = FFMAX(s->buffer_size, new_size);
1179  if (alloc_size > buf_size)
1180  if (!(buf = (*bufp) = av_realloc_f(buf, 1, alloc_size)))
1181  return AVERROR(ENOMEM);
1182 
1183  if (new_size > buf_size) {
1184  memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
1185  buf_size = new_size;
1186  }
1187 
1188  av_free(s->buffer);
1189  s->buf_ptr = s->buffer = buf;
1190  s->buffer_size = alloc_size;
1191  s->pos = buf_size;
1192  s->buf_end = s->buf_ptr + buf_size;
1193  s->eof_reached = 0;
1194 
1195  return 0;
1196 }
1197 
1198 int avio_open(AVIOContext **s, const char *filename, int flags)
1199 {
1200  return avio_open2(s, filename, flags, NULL, NULL);
1201 }
1202 
1203 int ffio_open_whitelist(AVIOContext **s, const char *filename, int flags,
1205  const char *whitelist, const char *blacklist
1206  )
1207 {
1208  URLContext *h;
1209  int err;
1210 
1211  *s = NULL;
1212 
1213  err = ffurl_open_whitelist(&h, filename, flags, int_cb, options, whitelist, blacklist, NULL);
1214  if (err < 0)
1215  return err;
1216  err = ffio_fdopen(s, h);
1217  if (err < 0) {
1218  ffurl_close(h);
1219  return err;
1220  }
1221  return 0;
1222 }
1223 
1224 int avio_open2(AVIOContext **s, const char *filename, int flags,
1226 {
1227  return ffio_open_whitelist(s, filename, flags, int_cb, options, NULL, NULL);
1228 }
1229 
1231 {
1232  FFIOContext *const ctx = ffiocontext(s);
1233  URLContext *h;
1234 
1235  if (!s)
1236  return 0;
1237 
1238  avio_flush(s);
1239  h = s->opaque;
1240  s->opaque = NULL;
1241 
1242  av_freep(&s->buffer);
1243  if (s->write_flag)
1245  "Statistics: %"PRId64" bytes written, %d seeks, %d writeouts\n",
1246  ctx->bytes_written, ctx->seek_count, ctx->writeout_count);
1247  else
1248  av_log(s, AV_LOG_VERBOSE, "Statistics: %"PRId64" bytes read, %d seeks\n",
1249  ctx->bytes_read, ctx->seek_count);
1250  av_opt_free(s);
1251 
1252  avio_context_free(&s);
1253 
1254  return ffurl_close(h);
1255 }
1256 
1258 {
1259  int ret = avio_close(*s);
1260  *s = NULL;
1261  return ret;
1262 }
1263 
1264 int avio_printf(AVIOContext *s, const char *fmt, ...)
1265 {
1266  va_list ap;
1267  AVBPrint bp;
1268 
1269  av_bprint_init(&bp, 0, INT_MAX);
1270  va_start(ap, fmt);
1271  av_vbprintf(&bp, fmt, ap);
1272  va_end(ap);
1273  if (!av_bprint_is_complete(&bp)) {
1274  av_bprint_finalize(&bp, NULL);
1275  s->error = AVERROR(ENOMEM);
1276  return AVERROR(ENOMEM);
1277  }
1278  avio_write(s, bp.str, bp.len);
1279  av_bprint_finalize(&bp, NULL);
1280  return bp.len;
1281 }
1282 
1283 void avio_print_string_array(AVIOContext *s, const char *strings[])
1284 {
1285  for(; *strings; strings++)
1286  avio_write(s, (const unsigned char *)*strings, strlen(*strings));
1287 }
1288 
1289 int avio_pause(AVIOContext *s, int pause)
1290 {
1291  if (!s->read_pause)
1292  return AVERROR(ENOSYS);
1293  return s->read_pause(s->opaque, pause);
1294 }
1295 
1296 int64_t avio_seek_time(AVIOContext *s, int stream_index,
1297  int64_t timestamp, int flags)
1298 {
1299  int64_t ret;
1300  if (!s->read_seek)
1301  return AVERROR(ENOSYS);
1302  ret = s->read_seek(s->opaque, stream_index, timestamp, flags);
1303  if (ret >= 0) {
1304  int64_t pos;
1305  s->buf_ptr = s->buf_end; // Flush buffer
1306  pos = s->seek(s->opaque, 0, SEEK_CUR);
1307  if (pos >= 0)
1308  s->pos = pos;
1309  else if (pos != AVERROR(ENOSYS))
1310  ret = pos;
1311  }
1312  return ret;
1313 }
1314 
1315 int avio_read_to_bprint(AVIOContext *h, AVBPrint *pb, size_t max_size)
1316 {
1317  int ret;
1318  char buf[1024];
1319  while (max_size) {
1320  ret = avio_read(h, buf, FFMIN(max_size, sizeof(buf)));
1321  if (ret == AVERROR_EOF)
1322  return 0;
1323  if (ret <= 0)
1324  return ret;
1325  av_bprint_append_data(pb, buf, ret);
1326  if (!av_bprint_is_complete(pb))
1327  return AVERROR(ENOMEM);
1328  max_size -= ret;
1329  }
1330  return 0;
1331 }
1332 
1334 {
1335  int ret;
1336  URLContext *sc = s->opaque;
1337  URLContext *cc = NULL;
1338  ret = ffurl_accept(sc, &cc);
1339  if (ret < 0)
1340  return ret;
1341  return ffio_fdopen(c, cc);
1342 }
1343 
1345 {
1346  URLContext *cc = c->opaque;
1347  return ffurl_handshake(cc);
1348 }
1349 
1350 /* output in a dynamic buffer */
1351 
1352 typedef struct DynBuffer {
1354  uint8_t *buffer;
1356  uint8_t io_buffer[1];
1357 } DynBuffer;
1358 
1359 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
1360 {
1361  DynBuffer *d = opaque;
1362  unsigned new_size;
1363 
1364  /* reallocate buffer if needed */
1365  new_size = (unsigned)d->pos + buf_size;
1366  if (new_size < d->pos || new_size > INT_MAX)
1367  return AVERROR(ERANGE);
1368  if (new_size > d->allocated_size) {
1369  unsigned new_allocated_size = d->allocated_size ? d->allocated_size
1370  : new_size;
1371  int err;
1372  while (new_size > new_allocated_size)
1373  new_allocated_size += new_allocated_size / 2 + 1;
1374 
1375  new_allocated_size = FFMIN(new_allocated_size, INT_MAX);
1376 
1377  if ((err = av_reallocp(&d->buffer, new_allocated_size)) < 0) {
1378  d->allocated_size = 0;
1379  d->size = 0;
1380  return err;
1381  }
1382  d->allocated_size = new_allocated_size;
1383  }
1384  memcpy(d->buffer + d->pos, buf, buf_size);
1385  d->pos = new_size;
1386  if (d->pos > d->size)
1387  d->size = d->pos;
1388  return buf_size;
1389 }
1390 
1391 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
1392 {
1393  unsigned char buf1[4];
1394  int ret;
1395 
1396  /* packetized write: output the header */
1397  AV_WB32(buf1, buf_size);
1398  ret = dyn_buf_write(opaque, buf1, 4);
1399  if (ret < 0)
1400  return ret;
1401 
1402  /* then the data */
1403  return dyn_buf_write(opaque, buf, buf_size);
1404 }
1405 
1406 static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
1407 {
1408  DynBuffer *d = opaque;
1409 
1410  if (whence == SEEK_CUR)
1411  offset += d->pos;
1412  else if (whence == SEEK_END)
1413  offset += d->size;
1414  if (offset < 0)
1415  return AVERROR(EINVAL);
1416  if (offset > INT_MAX)
1417  return AVERROR(ERANGE);
1418  d->pos = offset;
1419  return 0;
1420 }
1421 
1422 static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
1423 {
1424  struct { FFIOContext pb; DynBuffer d; } *ret;
1425  DynBuffer *d;
1426  unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
1427 
1428  if (sizeof(*ret) + io_buffer_size < io_buffer_size)
1429  return AVERROR(ERANGE);
1430  ret = av_mallocz(sizeof(*ret) + io_buffer_size);
1431  if (!ret)
1432  return AVERROR(ENOMEM);
1433  d = &ret->d;
1434  d->io_buffer_size = io_buffer_size;
1435  ffio_init_context(&ret->pb, d->io_buffer, d->io_buffer_size, 1, d, NULL,
1436  max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
1437  max_packet_size ? NULL : dyn_buf_seek);
1438  *s = &ret->pb.pub;
1439  (*s)->max_packet_size = max_packet_size;
1440  return 0;
1441 }
1442 
1444 {
1445  return url_open_dyn_buf_internal(s, 0);
1446 }
1447 
1448 int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
1449 {
1450  if (max_packet_size <= 0)
1451  return AVERROR(EINVAL);
1452  return url_open_dyn_buf_internal(s, max_packet_size);
1453 }
1454 
1455 int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1456 {
1457  DynBuffer *d;
1458 
1459  if (!s) {
1460  *pbuffer = NULL;
1461  return 0;
1462  }
1463  d = s->opaque;
1464 
1465  if (!s->error && !d->size) {
1466  *pbuffer = d->io_buffer;
1467  return FFMAX(s->buf_ptr, s->buf_ptr_max) - s->buffer;
1468  }
1469 
1470  avio_flush(s);
1471 
1472  *pbuffer = d->buffer;
1473 
1474  return d->size;
1475 }
1476 
1478 {
1479  DynBuffer *d = s->opaque;
1480  int max_packet_size = s->max_packet_size;
1481 
1482  ffio_init_context(ffiocontext(s), d->io_buffer, d->io_buffer_size,
1483  1, d, NULL, s->write_packet, s->seek);
1484  s->max_packet_size = max_packet_size;
1485  d->pos = d->size = 0;
1486 }
1487 
1488 int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1489 {
1490  DynBuffer *d;
1491  int size;
1492  int padding = 0;
1493 
1494  if (!s) {
1495  *pbuffer = NULL;
1496  return 0;
1497  }
1498 
1499  /* don't attempt to pad fixed-size packet buffers */
1500  if (!s->max_packet_size) {
1502  padding = AV_INPUT_BUFFER_PADDING_SIZE;
1503  }
1504 
1505  avio_flush(s);
1506 
1507  d = s->opaque;
1508  *pbuffer = d->buffer;
1509  size = d->size;
1510 
1511  avio_context_free(&s);
1512 
1513  return size - padding;
1514 }
1515 
1517 {
1518  DynBuffer *d;
1519 
1520  if (!*s)
1521  return;
1522 
1523  d = (*s)->opaque;
1524  av_free(d->buffer);
1526 }
1527 
1528 static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
1529 {
1530  DynBuffer *d = opaque;
1531 
1532  d->pos += buf_size;
1533  if (d->pos > d->size)
1534  d->size = d->pos;
1535  return buf_size;
1536 }
1537 
1539 {
1540  int ret = url_open_dyn_buf_internal(s, 0);
1541  if (ret >= 0) {
1542  AVIOContext *pb = *s;
1544  }
1545  return ret;
1546 }
1547 
1549 {
1550  DynBuffer *d = s->opaque;
1551  int size;
1552 
1553  avio_flush(s);
1554 
1555  size = d->size;
1556 
1557  avio_context_free(&s);
1558 
1559  return size;
1560 }
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:128
null_buf_write
static int null_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1528
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:1455
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:234
url_open_dyn_buf_internal
static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
Definition: aviobuf.c:1422
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:68
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:1406
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:26
ffio_get_checksum
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:612
DynBuffer::buffer
uint8_t * buffer
Definition: aviobuf.c:1354
ffio_open_null_buf
int ffio_open_null_buf(AVIOContext **s)
Open a write-only fake memory stream.
Definition: aviobuf.c:1538
ffio_geturlcontext
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
Definition: aviobuf.c:1014
AVOption
AVOption.
Definition: opt.h:247
b
#define b
Definition: input.c:40
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:478
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:1296
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:1333
ffurl_close
int ffurl_close(URLContext *h)
Definition: avio.c:461
DynBuffer::io_buffer
uint8_t io_buffer[1]
Definition: aviobuf.c:1356
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:157
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:1315
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:111
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:1025
fill_buffer
static void fill_buffer(AVIOContext *s)
Definition: aviobuf.c:540
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
crc.h
ffio_reset_dyn_buf
void ffio_reset_dyn_buf(AVIOContext *s)
Reset a dynamic buffer.
Definition: aviobuf.c:1477
fail
#define fail()
Definition: checkasm.h:127
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:504
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:76
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:1203
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:1283
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:470
flush_buffer
static void flush_buffer(AVIOContext *s)
Definition: aviobuf.c:194
avassert.h
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:257
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:1488
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:1353
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:622
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:116
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:33
internal.h
ffio_limit
int ffio_limit(AVIOContext *s, int size)
Definition: aviobuf.c:1068
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:1352
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:140
PUT_UTF16
#define PUT_UTF16(val, tmp, PUT_16BIT)
Definition: common.h:557
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:1264
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:1614
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:1289
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:1391
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:1110
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
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:1516
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:1033
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:185
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:1198
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:45
dyn_buf_write
static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
Definition: aviobuf.c:1359
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:1155
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:122
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1230
AVIOContext::write_packet
int(* write_packet)(void *opaque, uint8_t *buf, int buf_size)
Definition: avio.h:236
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:1224
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
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:731
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:1448
bprint.h
URLContext
Definition: url.h:38
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:263
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:1355
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:135
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
checksum
static volatile int checksum
Definition: adler32.c:30
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:226
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:40
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:1141
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:115
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:1353
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:486
AVIO_FLAG_DIRECT
#define AVIO_FLAG_DIRECT
Use direct mode.
Definition: avio.h:648
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:621
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:279
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:1443
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
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:35
DynBuffer::allocated_size
int allocated_size
Definition: aviobuf.c:1353
set_buf_size
static int set_buf_size(AVIOContext *s, int buf_size)
Definition: aviobuf.c:1094
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
d
d
Definition: ffmpeg_filter.c:156
convert_header.str
string str
Definition: convert_header.py:20
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:1548
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
avio_handshake
int avio_handshake(AVIOContext *c)
Perform one step of the protocol handshake to accept a new client.
Definition: aviobuf.c:1344
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:156
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:1257
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:146