Browse code

Merge remote branch 'qatar/master'

* qatar/master:
fate: fix partial run when no samples path is specified
ARM: NEON fixed-point forward MDCT
ARM: NEON fixed-point FFT
lavf: bump minor version and add an APIChanges entry for avio changes
avio: simplify url_open_dyn_buf_internal by using avio_alloc_context()
avio: make url_fdopen internal.
avio: make url_open_dyn_packet_buf internal.
avio: avio_ prefix for url_close_dyn_buf
avio: avio_ prefix for url_open_dyn_buf
avio: introduce an AVIOContext.seekable field
ac3enc: use generic fixed-point mdct
lavfi: add fade filter
Change yadif to not use out of picture lines.
lavc: deprecate AVCodecContext.antialias_algo
lavc: mark mb_qmin/mb_qmax for removal on next major bump.

Conflicts:
doc/filters.texi
libavcodec/ac3enc_fixed.h
libavcodec/ac3enc_float.h
libavfilter/Makefile
libavfilter/allfilters.c
libavfilter/vf_fade.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

Michael Niedermayer authored on 2011/04/04 09:15:12
Showing 74 changed files
... ...
@@ -3314,7 +3314,7 @@ SLIB_CREATE_DEF_CMD=${SLIB_CREATE_DEF_CMD}
3314 3314
 SLIB_EXTRA_CMD=${SLIB_EXTRA_CMD}
3315 3315
 SLIB_INSTALL_EXTRA_CMD=${SLIB_INSTALL_EXTRA_CMD}
3316 3316
 SLIB_UNINSTALL_EXTRA_CMD=${SLIB_UNINSTALL_EXTRA_CMD}
3317
-SAMPLES=${samples:-\$(FATE_SAMPLES)}
3317
+SAMPLES:=${samples:-\$(FATE_SAMPLES)}
3318 3318
 EOF
3319 3319
 
3320 3320
 get_version(){
... ...
@@ -12,6 +12,46 @@ libavutil:   2009-03-08
12 12
 
13 13
 API changes, most recent first:
14 14
 
15
+2011-04-03 - lavf 52.105.0 - avio.h
16
+  Large-scale renaming/deprecating of AVIOContext-related functions:
17
+    724f6a0 deprecate url_fdopen
18
+    403ee83 deprecate url_open_dyn_packet_buf
19
+    6dc7d80 rename url_close_dyn_buf       -> avio_close_dyn_buf
20
+    b92c545 rename url_open_dyn_buf        -> avio_open_dyn_buf
21
+    8978fed introduce an AVIOContext.seekable field as a replacement for
22
+            AVIOContext.is_streamed and url_is_streamed()
23
+    b64030f deprecate get_checksum()
24
+    4c4427a deprecate init_checksum()
25
+    4ec153b deprecate udp_set_remote_url/get_local_port
26
+    933e90a deprecate av_url_read_fseek/fpause
27
+    8d9769a deprecate url_fileno
28
+    b7f2fdd rename put_flush_packet -> avio_flush
29
+    35f1023 deprecate url_close_buf
30
+    83fddae deprecate url_open_buf
31
+    d9d86e0 rename url_fprintf -> avio_printf
32
+    59f65d9 deprecate url_setbufsize
33
+    3e68b3b deprecate url_ferror
34
+    66e5b1d deprecate url_feof
35
+    e8bb2e2 deprecate url_fget_max_packet_size
36
+    76aa876 rename url_fsize -> avio_size
37
+    e519753 deprecate url_fgetc
38
+    655e45e deprecate url_fgets
39
+    a2704c9 rename url_ftell -> avio_tell
40
+    e16ead0 deprecate get_strz() in favor of avio_get_str
41
+    0300db8,2af07d3 rename url_fskip -> avio_skip
42
+    6b4aa5d rename url_fseek -> avio_seek
43
+    61840b4 deprecate put_tag
44
+    22a3212 rename url_fopen/fclose -> avio_open/close.
45
+    0ac8e2b deprecate put_nbyte
46
+    77eb550 rename put_byte          -> avio_w8
47
+                   put_[b/l]e<type>  -> avio_w[b/l]<type>
48
+                   put_buffer        -> avio_write
49
+    b7effd4 rename get_byte          -> avio_r8,
50
+                   get_[b/l]e<type>  -> avio_r[b/l]<type>
51
+                   get_buffer        -> avio_read
52
+    b3db9ce deprecate get_partial_buffer
53
+    8d9ac96 rename av_alloc_put_byte -> avio_alloc_context
54
+
15 55
 2011-03-25 - 34b47d7 - lavc 52.115.0 - AVCodecContext.audio_service_type
16 56
   Add audio_service_type field to AVCodecContext.
17 57
 
... ...
@@ -33,6 +33,8 @@
33 33
 #include "libavformat/os_support.h"
34 34
 #include "libavformat/rtpdec.h"
35 35
 #include "libavformat/rtsp.h"
36
+// XXX for ffio_open_dyn_packet_buffer, to be removed
37
+#include "libavformat/avio_internal.h"
36 38
 #include "libavutil/avstring.h"
37 39
 #include "libavutil/lfg.h"
38 40
 #include "libavutil/random_seed.h"
... ...
@@ -869,10 +871,10 @@ static void close_connection(HTTPContext *c)
869 869
     if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
870 870
         if (ctx->oformat) {
871 871
             /* prepare header */
872
-            if (url_open_dyn_buf(&ctx->pb) >= 0) {
872
+            if (avio_open_dyn_buf(&ctx->pb) >= 0) {
873 873
                 av_write_trailer(ctx);
874 874
                 av_freep(&c->pb_buffer);
875
-                url_close_dyn_buf(ctx->pb, &c->pb_buffer);
875
+                avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
876 876
             }
877 877
         }
878 878
     }
... ...
@@ -1873,7 +1875,7 @@ static void compute_status(HTTPContext *c)
1873 1873
     int i, len;
1874 1874
     AVIOContext *pb;
1875 1875
 
1876
-    if (url_open_dyn_buf(&pb) < 0) {
1876
+    if (avio_open_dyn_buf(&pb) < 0) {
1877 1877
         /* XXX: return an error ? */
1878 1878
         c->buffer_ptr = c->buffer;
1879 1879
         c->buffer_end = c->buffer;
... ...
@@ -2101,7 +2103,7 @@ static void compute_status(HTTPContext *c)
2101 2101
     avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
2102 2102
     avio_printf(pb, "</body>\n</html>\n");
2103 2103
 
2104
-    len = url_close_dyn_buf(pb, &c->pb_buffer);
2104
+    len = avio_close_dyn_buf(pb, &c->pb_buffer);
2105 2105
     c->buffer_ptr = c->pb_buffer;
2106 2106
     c->buffer_end = c->pb_buffer + len;
2107 2107
 }
... ...
@@ -2256,11 +2258,11 @@ static int http_prepare_data(HTTPContext *c)
2256 2256
         c->got_key_frame = 0;
2257 2257
 
2258 2258
         /* prepare header and save header data in a stream */
2259
-        if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2259
+        if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
2260 2260
             /* XXX: potential leak */
2261 2261
             return -1;
2262 2262
         }
2263
-        c->fmt_ctx.pb->is_streamed = 1;
2263
+        c->fmt_ctx.pb->seekable = 0;
2264 2264
 
2265 2265
         /*
2266 2266
          * HACK to avoid mpeg ps muxer to spit many underflow errors
... ...
@@ -2277,7 +2279,7 @@ static int http_prepare_data(HTTPContext *c)
2277 2277
         }
2278 2278
         av_metadata_free(&c->fmt_ctx.metadata);
2279 2279
 
2280
-        len = url_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2280
+        len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
2281 2281
         c->buffer_ptr = c->pb_buffer;
2282 2282
         c->buffer_end = c->pb_buffer + len;
2283 2283
 
... ...
@@ -2389,9 +2391,9 @@ static int http_prepare_data(HTTPContext *c)
2389 2389
                             max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
2390 2390
                         else
2391 2391
                             max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
2392
-                        ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2392
+                        ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
2393 2393
                     } else {
2394
-                        ret = url_open_dyn_buf(&ctx->pb);
2394
+                        ret = avio_open_dyn_buf(&ctx->pb);
2395 2395
                     }
2396 2396
                     if (ret < 0) {
2397 2397
                         /* XXX: potential leak */
... ...
@@ -2399,7 +2401,7 @@ static int http_prepare_data(HTTPContext *c)
2399 2399
                     }
2400 2400
                     ost = ctx->streams[pkt.stream_index];
2401 2401
 
2402
-                    ctx->pb->is_streamed = 1;
2402
+                    ctx->pb->seekable = 0;
2403 2403
                     if (pkt.dts != AV_NOPTS_VALUE)
2404 2404
                         pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
2405 2405
                     if (pkt.pts != AV_NOPTS_VALUE)
... ...
@@ -2410,7 +2412,7 @@ static int http_prepare_data(HTTPContext *c)
2410 2410
                         c->state = HTTPSTATE_SEND_DATA_TRAILER;
2411 2411
                     }
2412 2412
 
2413
-                    len = url_close_dyn_buf(ctx->pb, &c->pb_buffer);
2413
+                    len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2414 2414
                     c->cur_frame_bytes = len;
2415 2415
                     c->buffer_ptr = c->pb_buffer;
2416 2416
                     c->buffer_end = c->pb_buffer + len;
... ...
@@ -2432,13 +2434,13 @@ static int http_prepare_data(HTTPContext *c)
2432 2432
             return -1;
2433 2433
         ctx = &c->fmt_ctx;
2434 2434
         /* prepare header */
2435
-        if (url_open_dyn_buf(&ctx->pb) < 0) {
2435
+        if (avio_open_dyn_buf(&ctx->pb) < 0) {
2436 2436
             /* XXX: potential leak */
2437 2437
             return -1;
2438 2438
         }
2439
-        c->fmt_ctx.pb->is_streamed = 1;
2439
+        c->fmt_ctx.pb->seekable = 0;
2440 2440
         av_write_trailer(ctx);
2441
-        len = url_close_dyn_buf(ctx->pb, &c->pb_buffer);
2441
+        len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
2442 2442
         c->buffer_ptr = c->pb_buffer;
2443 2443
         c->buffer_end = c->pb_buffer + len;
2444 2444
 
... ...
@@ -2503,7 +2505,7 @@ static int http_send_data(HTTPContext *c)
2503 2503
                     /* if already sending something, then wait. */
2504 2504
                     if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
2505 2505
                         break;
2506
-                    if (url_open_dyn_buf(&pb) < 0)
2506
+                    if (avio_open_dyn_buf(&pb) < 0)
2507 2507
                         goto fail1;
2508 2508
                     interleaved_index = c->packet_stream_index * 2;
2509 2509
                     /* RTCP packets are sent at odd indexes */
... ...
@@ -2518,7 +2520,7 @@ static int http_send_data(HTTPContext *c)
2518 2518
                     /* write RTP packet data */
2519 2519
                     c->buffer_ptr += 4;
2520 2520
                     avio_write(pb, c->buffer_ptr, len);
2521
-                    size = url_close_dyn_buf(pb, &c->packet_buffer);
2521
+                    size = avio_close_dyn_buf(pb, &c->packet_buffer);
2522 2522
                     /* prepare asynchronous TCP sending */
2523 2523
                     rtsp_c->packet_buffer_ptr = c->packet_buffer;
2524 2524
                     rtsp_c->packet_buffer_end = c->packet_buffer + size;
... ...
@@ -2723,7 +2725,7 @@ static int http_receive_data(HTTPContext *c)
2723 2723
 
2724 2724
             pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
2725 2725
                                     0, NULL, NULL, NULL, NULL);
2726
-            pb->is_streamed = 1;
2726
+            pb->seekable = 0;
2727 2727
 
2728 2728
             if (av_open_input_stream(&s, pb, c->stream->feed_filename, fmt_in, NULL) < 0) {
2729 2729
                 av_free(pb);
... ...
@@ -2850,7 +2852,7 @@ static int rtsp_parse_request(HTTPContext *c)
2850 2850
     av_strlcpy(c->url, url, sizeof(c->url));
2851 2851
     av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
2852 2852
 
2853
-    if (url_open_dyn_buf(&c->pb) < 0) {
2853
+    if (avio_open_dyn_buf(&c->pb) < 0) {
2854 2854
         /* XXX: cannot do more */
2855 2855
         c->pb = NULL; /* safety */
2856 2856
         return -1;
... ...
@@ -2907,7 +2909,7 @@ static int rtsp_parse_request(HTTPContext *c)
2907 2907
         rtsp_reply_error(c, RTSP_STATUS_METHOD);
2908 2908
 
2909 2909
  the_end:
2910
-    len = url_close_dyn_buf(c->pb, &c->pb_buffer);
2910
+    len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
2911 2911
     c->pb = NULL; /* safety */
2912 2912
     if (len < 0) {
2913 2913
         /* XXX: cannot do more */
... ...
@@ -3444,7 +3446,7 @@ static int rtp_new_av_stream(HTTPContext *c,
3444 3444
              c->stream->filename, stream_index, c->protocol);
3445 3445
 
3446 3446
     /* normally, no packets should be output here, but the packet size may be checked */
3447
-    if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3447
+    if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
3448 3448
         /* XXX: close stream */
3449 3449
         goto fail;
3450 3450
     }
... ...
@@ -3456,7 +3458,7 @@ static int rtp_new_av_stream(HTTPContext *c,
3456 3456
         av_free(ctx);
3457 3457
         return -1;
3458 3458
     }
3459
-    url_close_dyn_buf(ctx->pb, &dummy_buf);
3459
+    avio_close_dyn_buf(ctx->pb, &dummy_buf);
3460 3460
     av_free(dummy_buf);
3461 3461
 
3462 3462
     c->rtp_ctx[stream_index] = ctx;
... ...
@@ -29,6 +29,8 @@
29 29
 //#define DEBUG
30 30
 //#define ASSERT_LEVEL 2
31 31
 
32
+#include <stdint.h>
33
+
32 34
 #include "libavutil/audioconvert.h"
33 35
 #include "libavutil/avassert.h"
34 36
 #include "libavutil/crc.h"
... ...
@@ -39,6 +41,7 @@
39 39
 #include "ac3dsp.h"
40 40
 #include "ac3.h"
41 41
 #include "audioconvert.h"
42
+#include "fft.h"
42 43
 
43 44
 
44 45
 #ifndef CONFIG_AC3ENC_FLOAT
... ...
@@ -55,16 +58,22 @@
55 55
 #define AC3_REMATRIXING_NONE    1
56 56
 #define AC3_REMATRIXING_ALWAYS  3
57 57
 
58
-/** Scale a float value by 2^bits and convert to an integer. */
59
-#define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits)))
60
-
61
-
62 58
 #if CONFIG_AC3ENC_FLOAT
63
-#include "ac3enc_float.h"
59
+#define MAC_COEF(d,a,b) ((d)+=(a)*(b))
60
+typedef float SampleType;
61
+typedef float CoefType;
62
+typedef float CoefSumType;
64 63
 #else
65
-#include "ac3enc_fixed.h"
64
+#define MAC_COEF(d,a,b) MAC64(d,a,b)
65
+typedef int16_t SampleType;
66
+typedef int32_t CoefType;
67
+typedef int64_t CoefSumType;
66 68
 #endif
67 69
 
70
+typedef struct AC3MDCTContext {
71
+    const SampleType *window;           ///< MDCT window function
72
+    FFTContext fft;                     ///< FFT context for MDCT calculation
73
+} AC3MDCTContext;
68 74
 
69 75
 /**
70 76
  * Encoding Options used by AVOption.
... ...
@@ -279,8 +288,6 @@ static av_cold void mdct_end(AC3MDCTContext *mdct);
279 279
 static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
280 280
                              int nbits);
281 281
 
282
-static void mdct512(AC3MDCTContext *mdct, CoefType *out, SampleType *in);
283
-
284 282
 static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input,
285 283
                          const SampleType *window, unsigned int len);
286 284
 
... ...
@@ -386,7 +393,8 @@ static void apply_mdct(AC3EncodeContext *s)
386 386
 
387 387
             block->coeff_shift[ch] = normalize_samples(s);
388 388
 
389
-            mdct512(&s->mdct, block->mdct_coef[ch], s->windowed_samples);
389
+            s->mdct.fft.mdct_calcw(&s->mdct.fft, block->mdct_coef[ch],
390
+                                   s->windowed_samples);
390 391
         }
391 392
     }
392 393
 }
... ...
@@ -26,54 +26,17 @@
26 26
  * fixed-point AC-3 encoder.
27 27
  */
28 28
 
29
+#define CONFIG_FFT_FLOAT 0
29 30
 #undef CONFIG_AC3ENC_FLOAT
30 31
 #include "ac3enc.c"
31 32
 
32 33
 
33
-/** Scale a float value by 2^15, convert to an integer, and clip to range -32767..32767. */
34
-#define FIX15(a) av_clip(SCALE_FLOAT(a, 15), -32767, 32767)
35
-
36
-
37 34
 /**
38 35
  * Finalize MDCT and free allocated memory.
39 36
  */
40 37
 static av_cold void mdct_end(AC3MDCTContext *mdct)
41 38
 {
42
-    mdct->nbits = 0;
43
-    av_freep(&mdct->costab);
44
-    av_freep(&mdct->sintab);
45
-    av_freep(&mdct->xcos1);
46
-    av_freep(&mdct->xsin1);
47
-    av_freep(&mdct->rot_tmp);
48
-    av_freep(&mdct->cplx_tmp);
49
-}
50
-
51
-
52
-/**
53
- * Initialize FFT tables.
54
- * @param ln log2(FFT size)
55
- */
56
-static av_cold int fft_init(AVCodecContext *avctx, AC3MDCTContext *mdct, int ln)
57
-{
58
-    int i, n, n2;
59
-    float alpha;
60
-
61
-    n  = 1 << ln;
62
-    n2 = n >> 1;
63
-
64
-    FF_ALLOC_OR_GOTO(avctx, mdct->costab, n2 * sizeof(*mdct->costab), fft_alloc_fail);
65
-    FF_ALLOC_OR_GOTO(avctx, mdct->sintab, n2 * sizeof(*mdct->sintab), fft_alloc_fail);
66
-
67
-    for (i = 0; i < n2; i++) {
68
-        alpha     = 2.0 * M_PI * i / n;
69
-        mdct->costab[i] = FIX15(cos(alpha));
70
-        mdct->sintab[i] = FIX15(sin(alpha));
71
-    }
72
-
73
-    return 0;
74
-fft_alloc_fail:
75
-    mdct_end(mdct);
76
-    return AVERROR(ENOMEM);
39
+    ff_fft_end(&mdct->fft);
77 40
 }
78 41
 
79 42
 
... ...
@@ -84,167 +47,9 @@ fft_alloc_fail:
84 84
 static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
85 85
                              int nbits)
86 86
 {
87
-    int i, n, n4, ret;
88
-
89
-    n  = 1 << nbits;
90
-    n4 = n >> 2;
91
-
92
-    mdct->nbits = nbits;
93
-
94
-    ret = fft_init(avctx, mdct, nbits - 2);
95
-    if (ret)
96
-        return ret;
97
-
87
+    int ret = ff_mdct_init(&mdct->fft, nbits, 0, 1.0);
98 88
     mdct->window = ff_ac3_window;
99
-
100
-    FF_ALLOC_OR_GOTO(avctx, mdct->xcos1,    n4 * sizeof(*mdct->xcos1),    mdct_alloc_fail);
101
-    FF_ALLOC_OR_GOTO(avctx, mdct->xsin1,    n4 * sizeof(*mdct->xsin1),    mdct_alloc_fail);
102
-    FF_ALLOC_OR_GOTO(avctx, mdct->rot_tmp,  n  * sizeof(*mdct->rot_tmp),  mdct_alloc_fail);
103
-    FF_ALLOC_OR_GOTO(avctx, mdct->cplx_tmp, n4 * sizeof(*mdct->cplx_tmp), mdct_alloc_fail);
104
-
105
-    for (i = 0; i < n4; i++) {
106
-        float alpha = 2.0 * M_PI * (i + 1.0 / 8.0) / n;
107
-        mdct->xcos1[i] = FIX15(-cos(alpha));
108
-        mdct->xsin1[i] = FIX15(-sin(alpha));
109
-    }
110
-
111
-    return 0;
112
-mdct_alloc_fail:
113
-    mdct_end(mdct);
114
-    return AVERROR(ENOMEM);
115
-}
116
-
117
-
118
-/** Butterfly op */
119
-#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1)  \
120
-{                                                       \
121
-  int ax, ay, bx, by;                                   \
122
-  bx  = pre1;                                           \
123
-  by  = pim1;                                           \
124
-  ax  = qre1;                                           \
125
-  ay  = qim1;                                           \
126
-  pre = (bx + ax) >> 1;                                 \
127
-  pim = (by + ay) >> 1;                                 \
128
-  qre = (bx - ax) >> 1;                                 \
129
-  qim = (by - ay) >> 1;                                 \
130
-}
131
-
132
-
133
-/** Complex multiply */
134
-#define CMUL(pre, pim, are, aim, bre, bim, rshift)      \
135
-{                                                       \
136
-   pre = (MUL16(are, bre) - MUL16(aim, bim)) >> rshift; \
137
-   pim = (MUL16(are, bim) + MUL16(bre, aim)) >> rshift; \
138
-}
139
-
140
-
141
-/**
142
- * Calculate a 2^n point complex FFT on 2^ln points.
143
- * @param z  complex input/output samples
144
- * @param ln log2(FFT size)
145
- */
146
-static void fft(AC3MDCTContext *mdct, IComplex *z, int ln)
147
-{
148
-    int j, l, np, np2;
149
-    int nblocks, nloops;
150
-    register IComplex *p,*q;
151
-    int tmp_re, tmp_im;
152
-
153
-    np = 1 << ln;
154
-
155
-    /* reverse */
156
-    for (j = 0; j < np; j++) {
157
-        int k = av_reverse[j] >> (8 - ln);
158
-        if (k < j)
159
-            FFSWAP(IComplex, z[k], z[j]);
160
-    }
161
-
162
-    /* pass 0 */
163
-
164
-    p = &z[0];
165
-    j = np >> 1;
166
-    do {
167
-        BF(p[0].re, p[0].im, p[1].re, p[1].im,
168
-           p[0].re, p[0].im, p[1].re, p[1].im);
169
-        p += 2;
170
-    } while (--j);
171
-
172
-    /* pass 1 */
173
-
174
-    p = &z[0];
175
-    j = np >> 2;
176
-    do {
177
-        BF(p[0].re, p[0].im, p[2].re,  p[2].im,
178
-           p[0].re, p[0].im, p[2].re,  p[2].im);
179
-        BF(p[1].re, p[1].im, p[3].re,  p[3].im,
180
-           p[1].re, p[1].im, p[3].im, -p[3].re);
181
-        p+=4;
182
-    } while (--j);
183
-
184
-    /* pass 2 .. ln-1 */
185
-
186
-    nblocks = np >> 3;
187
-    nloops  =  1 << 2;
188
-    np2     = np >> 1;
189
-    do {
190
-        p = z;
191
-        q = z + nloops;
192
-        for (j = 0; j < nblocks; j++) {
193
-            BF(p->re, p->im, q->re, q->im,
194
-               p->re, p->im, q->re, q->im);
195
-            p++;
196
-            q++;
197
-            for(l = nblocks; l < np2; l += nblocks) {
198
-                CMUL(tmp_re, tmp_im, mdct->costab[l], -mdct->sintab[l], q->re, q->im, 15);
199
-                BF(p->re, p->im, q->re,  q->im,
200
-                   p->re, p->im, tmp_re, tmp_im);
201
-                p++;
202
-                q++;
203
-            }
204
-            p += nloops;
205
-            q += nloops;
206
-        }
207
-        nblocks = nblocks >> 1;
208
-        nloops  = nloops  << 1;
209
-    } while (nblocks);
210
-}
211
-
212
-
213
-/**
214
- * Calculate a 512-point MDCT
215
- * @param out 256 output frequency coefficients
216
- * @param in  512 windowed input audio samples
217
- */
218
-static void mdct512(AC3MDCTContext *mdct, int32_t *out, int16_t *in)
219
-{
220
-    int i, re, im, n, n2, n4;
221
-    int16_t *rot = mdct->rot_tmp;
222
-    IComplex *x  = mdct->cplx_tmp;
223
-
224
-    n  = 1 << mdct->nbits;
225
-    n2 = n >> 1;
226
-    n4 = n >> 2;
227
-
228
-    /* shift to simplify computations */
229
-    for (i = 0; i <n4; i++)
230
-        rot[i] = -in[i + 3*n4];
231
-    memcpy(&rot[n4], &in[0], 3*n4*sizeof(*in));
232
-
233
-    /* pre rotation */
234
-    for (i = 0; i < n4; i++) {
235
-        re =  ((int)rot[   2*i] - (int)rot[ n-1-2*i]) >> 1;
236
-        im = -((int)rot[n2+2*i] - (int)rot[n2-1-2*i]) >> 1;
237
-        CMUL(x[i].re, x[i].im, re, im, -mdct->xcos1[i], mdct->xsin1[i], 15);
238
-    }
239
-
240
-    fft(mdct, x, mdct->nbits - 2);
241
-
242
-    /* post rotation */
243
-    for (i = 0; i < n4; i++) {
244
-        re = x[i].re;
245
-        im = x[i].im;
246
-        CMUL(out[n2-1-2*i], out[2*i], re, im, mdct->xsin1[i], mdct->xcos1[i], 0);
247
-    }
89
+    return ret;
248 90
 }
249 91
 
250 92
 
... ...
@@ -304,101 +109,6 @@ static void scale_coefficients(AC3EncodeContext *s)
304 304
 }
305 305
 
306 306
 
307
-#ifdef TEST
308
-/*************************************************************************/
309
-/* TEST */
310
-
311
-#include "libavutil/lfg.h"
312
-
313
-#define MDCT_NBITS 9
314
-#define MDCT_SAMPLES (1 << MDCT_NBITS)
315
-#define FN (MDCT_SAMPLES/4)
316
-
317
-
318
-static void fft_test(AC3MDCTContext *mdct, AVLFG *lfg)
319
-{
320
-    IComplex in[FN], in1[FN];
321
-    int k, n, i;
322
-    float sum_re, sum_im, a;
323
-
324
-    for (i = 0; i < FN; i++) {
325
-        in[i].re = av_lfg_get(lfg) % 65535 - 32767;
326
-        in[i].im = av_lfg_get(lfg) % 65535 - 32767;
327
-        in1[i]   = in[i];
328
-    }
329
-    fft(mdct, in, 7);
330
-
331
-    /* do it by hand */
332
-    for (k = 0; k < FN; k++) {
333
-        sum_re = 0;
334
-        sum_im = 0;
335
-        for (n = 0; n < FN; n++) {
336
-            a = -2 * M_PI * (n * k) / FN;
337
-            sum_re += in1[n].re * cos(a) - in1[n].im * sin(a);
338
-            sum_im += in1[n].re * sin(a) + in1[n].im * cos(a);
339
-        }
340
-        av_log(NULL, AV_LOG_DEBUG, "%3d: %6d,%6d %6.0f,%6.0f\n",
341
-               k, in[k].re, in[k].im, sum_re / FN, sum_im / FN);
342
-    }
343
-}
344
-
345
-
346
-static void mdct_test(AC3MDCTContext *mdct, AVLFG *lfg)
347
-{
348
-    int16_t input[MDCT_SAMPLES];
349
-    int32_t output[AC3_MAX_COEFS];
350
-    float input1[MDCT_SAMPLES];
351
-    float output1[AC3_MAX_COEFS];
352
-    float s, a, err, e, emax;
353
-    int i, k, n;
354
-
355
-    for (i = 0; i < MDCT_SAMPLES; i++) {
356
-        input[i]  = (av_lfg_get(lfg) % 65535 - 32767) * 9 / 10;
357
-        input1[i] = input[i];
358
-    }
359
-
360
-    mdct512(mdct, output, input);
361
-
362
-    /* do it by hand */
363
-    for (k = 0; k < AC3_MAX_COEFS; k++) {
364
-        s = 0;
365
-        for (n = 0; n < MDCT_SAMPLES; n++) {
366
-            a = (2*M_PI*(2*n+1+MDCT_SAMPLES/2)*(2*k+1) / (4 * MDCT_SAMPLES));
367
-            s += input1[n] * cos(a);
368
-        }
369
-        output1[k] = -2 * s / MDCT_SAMPLES;
370
-    }
371
-
372
-    err  = 0;
373
-    emax = 0;
374
-    for (i = 0; i < AC3_MAX_COEFS; i++) {
375
-        av_log(NULL, AV_LOG_DEBUG, "%3d: %7d %7.0f\n", i, output[i], output1[i]);
376
-        e = output[i] - output1[i];
377
-        if (e > emax)
378
-            emax = e;
379
-        err += e * e;
380
-    }
381
-    av_log(NULL, AV_LOG_DEBUG, "err2=%f emax=%f\n", err / AC3_MAX_COEFS, emax);
382
-}
383
-
384
-
385
-int main(void)
386
-{
387
-    AVLFG lfg;
388
-    AC3MDCTContext mdct;
389
-
390
-    mdct.avctx = NULL;
391
-    av_log_set_level(AV_LOG_DEBUG);
392
-    mdct_init(&mdct, 9);
393
-
394
-    fft_test(&mdct, &lfg);
395
-    mdct_test(&mdct, &lfg);
396
-
397
-    return 0;
398
-}
399
-#endif /* TEST */
400
-
401
-
402 307
 AVCodec ff_ac3_fixed_encoder = {
403 308
     "ac3_fixed",
404 309
     AVMEDIA_TYPE_AUDIO,
405 310
deleted file mode 100644
... ...
@@ -1,61 +0,0 @@
1
-/*
2
- * The simplest AC-3 encoder
3
- * Copyright (c) 2000 Fabrice Bellard
4
- * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
5
- * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
6
- *
7
- * This file is part of FFmpeg.
8
- *
9
- * FFmpeg is free software; you can redistribute it and/or
10
- * modify it under the terms of the GNU Lesser General Public
11
- * License as published by the Free Software Foundation; either
12
- * version 2.1 of the License, or (at your option) any later version.
13
- *
14
- * FFmpeg is distributed in the hope that it will be useful,
15
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
- * Lesser General Public License for more details.
18
- *
19
- * You should have received a copy of the GNU Lesser General Public
20
- * License along with FFmpeg; if not, write to the Free Software
21
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
- */
23
-
24
-/**
25
- * @file
26
- * fixed-point AC-3 encoder header.
27
- */
28
-
29
-#ifndef AVCODEC_AC3ENC_FIXED_H
30
-#define AVCODEC_AC3ENC_FIXED_H
31
-
32
-#include <stdint.h>
33
-
34
-
35
-typedef int16_t SampleType;
36
-typedef int32_t CoefType;
37
-typedef int64_t CoefSumType;
38
-
39
-#define MAC_COEF(d,a,b) MAC64(d,a,b)
40
-
41
-
42
-/**
43
- * Compex number.
44
- * Used in fixed-point MDCT calculation.
45
- */
46
-typedef struct IComplex {
47
-    int16_t re,im;
48
-} IComplex;
49
-
50
-typedef struct AC3MDCTContext {
51
-    const int16_t *window;                  ///< MDCT window function
52
-    int nbits;                              ///< log2(transform size)
53
-    int16_t *costab;                        ///< FFT cos table
54
-    int16_t *sintab;                        ///< FFT sin table
55
-    int16_t *xcos1;                         ///< MDCT cos table
56
-    int16_t *xsin1;                         ///< MDCT sin table
57
-    int16_t *rot_tmp;                       ///< temp buffer for pre-rotated samples
58
-    IComplex *cplx_tmp;                     ///< temp buffer for complex pre-rotated samples
59
-} AC3MDCTContext;
60
-
61
-#endif /* AVCODEC_AC3ENC_FIXED_H */
... ...
@@ -69,17 +69,6 @@ static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
69 69
 
70 70
 
71 71
 /**
72
- * Calculate a 512-point MDCT
73
- * @param out 256 output frequency coefficients
74
- * @param in  512 windowed input audio samples
75
- */
76
-static void mdct512(AC3MDCTContext *mdct, float *out, float *in)
77
-{
78
-    mdct->fft.mdct_calc(&mdct->fft, out, in);
79
-}
80
-
81
-
82
-/**
83 72
  * Apply KBD window to input samples prior to MDCT.
84 73
  */
85 74
 static void apply_window(DSPContext *dsp, float *output, const float *input,
86 75
deleted file mode 100644
... ...
@@ -1,47 +0,0 @@
1
-/*
2
- * The simplest AC-3 encoder
3
- * Copyright (c) 2000 Fabrice Bellard
4
- * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
5
- * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
6
- *
7
- * This file is part of FFmpeg.
8
- *
9
- * FFmpeg is free software; you can redistribute it and/or
10
- * modify it under the terms of the GNU Lesser General Public
11
- * License as published by the Free Software Foundation; either
12
- * version 2.1 of the License, or (at your option) any later version.
13
- *
14
- * FFmpeg is distributed in the hope that it will be useful,
15
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
- * Lesser General Public License for more details.
18
- *
19
- * You should have received a copy of the GNU Lesser General Public
20
- * License along with FFmpeg; if not, write to the Free Software
21
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
- */
23
-
24
-/**
25
- * @file
26
- * floating-point AC-3 encoder header.
27
- */
28
-
29
-#ifndef AVCODEC_AC3ENC_FLOAT_H
30
-#define AVCODEC_AC3ENC_FLOAT_H
31
-
32
-#include "fft.h"
33
-
34
-
35
-typedef float SampleType;
36
-typedef float CoefType;
37
-typedef float CoefSumType;
38
-
39
-#define MAC_COEF(d,a,b) ((d)+=(a)*(b))
40
-
41
-
42
-typedef struct AC3MDCTContext {
43
-    const float *window;    ///< MDCT window function
44
-    FFTContext fft;         ///< FFT context for MDCT calculation
45
-} AC3MDCTContext;
46
-
47
-#endif /* AVCODEC_AC3ENC_FLOAT_H */
... ...
@@ -16,6 +16,7 @@ OBJS-$(CONFIG_H264PRED)                += arm/h264pred_init_arm.o
16 16
 OBJS                                   += arm/dsputil_init_arm.o        \
17 17
                                           arm/dsputil_arm.o             \
18 18
                                           arm/fft_init_arm.o            \
19
+                                          arm/fft_fixed_init_arm.o      \
19 20
                                           arm/fmtconvert_init_arm.o     \
20 21
                                           arm/jrevdct_arm.o             \
21 22
                                           arm/mpegvideo_arm.o           \
... ...
@@ -41,8 +42,10 @@ OBJS-$(HAVE_IWMMXT)                    += arm/dsputil_iwmmxt.o          \
41 41
                                           arm/mpegvideo_iwmmxt.o        \
42 42
 
43 43
 NEON-OBJS-$(CONFIG_FFT)                += arm/fft_neon.o                \
44
+                                          arm/fft_fixed_neon.o          \
44 45
 
45 46
 NEON-OBJS-$(CONFIG_MDCT)               += arm/mdct_neon.o               \
47
+                                          arm/mdct_fixed_neon.o         \
46 48
 
47 49
 NEON-OBJS-$(CONFIG_RDFT)               += arm/rdft_neon.o               \
48 50
 
49 51
new file mode 100644
... ...
@@ -0,0 +1,42 @@
0
+/*
1
+ * Copyright (c) 2009 Mans Rullgard <mans@mansr.com>
2
+ *
3
+ * This file is part of FFmpeg.
4
+ *
5
+ * FFMpeg is free software; you can redistribute it and/or
6
+ * modify it under the terms of the GNU Lesser General Public
7
+ * License as published by the Free Software Foundation; either
8
+ * version 2.1 of the License, or (at your option) any later version.
9
+ *
10
+ * FFmpeg is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
+ * Lesser General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU Lesser General Public
16
+ * License along with FFmpeg; if not, write to the Free Software
17
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
+ */
19
+
20
+#define CONFIG_FFT_FLOAT 0
21
+#include "libavcodec/fft.h"
22
+
23
+void ff_fft_fixed_calc_neon(FFTContext *s, FFTComplex *z);
24
+void ff_mdct_fixed_calc_neon(FFTContext *s, FFTSample *o, const FFTSample *i);
25
+void ff_mdct_fixed_calcw_neon(FFTContext *s, FFTDouble *o, const FFTSample *i);
26
+
27
+av_cold void ff_fft_fixed_init_arm(FFTContext *s)
28
+{
29
+    if (HAVE_NEON) {
30
+        s->fft_permutation = FF_FFT_PERM_SWAP_LSBS;
31
+        s->fft_calc        = ff_fft_fixed_calc_neon;
32
+
33
+#if CONFIG_MDCT
34
+        if (!s->inverse && s->mdct_bits >= 5) {
35
+            s->mdct_permutation = FF_MDCT_PERM_INTERLEAVE;
36
+            s->mdct_calc        = ff_mdct_fixed_calc_neon;
37
+            s->mdct_calcw       = ff_mdct_fixed_calcw_neon;
38
+        }
39
+#endif
40
+    }
41
+}
0 42
new file mode 100644
... ...
@@ -0,0 +1,261 @@
0
+/*
1
+ * Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
2
+ *
3
+ * This file is part of Libav.
4
+ *
5
+ * Libav is free software; you can redistribute it and/or
6
+ * modify it under the terms of the GNU Lesser General Public
7
+ * License as published by the Free Software Foundation; either
8
+ * version 2.1 of the License, or (at your option) any later version.
9
+ *
10
+ * Libav is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
+ * Lesser General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU Lesser General Public
16
+ * License along with Libav; if not, write to the Free Software
17
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
+ */
19
+
20
+#include "asm.S"
21
+
22
+.macro  bflies          d0,  d1,  r0,  r1
23
+        vrev64.32       \r0, \d1                @ t5, t6, t1, t2
24
+        vhsub.s16       \r1, \d1, \r0           @ t1-t5, t2-t6, t5-t1, t6-t2
25
+        vhadd.s16       \r0, \d1, \r0           @ t1+t5, t2+t6, t5+t1, t6+t2
26
+        vext.16         \r1, \r1, \r1, #1       @ t2-t6, t5-t1, t6-t2, t1-t5
27
+        vtrn.32         \r0, \r1                @ t1+t5, t2+t6, t2-t6, t5-t1
28
+                                                @ t5,    t6,    t4,    t3
29
+        vhsub.s16       \d1, \d0, \r0
30
+        vhadd.s16       \d0, \d0, \r0
31
+.endm
32
+
33
+.macro  transform01     q0,  q1,  d3,  c0,  c1,  r0,  w0,  w1
34
+        vrev32.16       \r0, \d3
35
+        vmull.s16       \w0, \d3, \c0
36
+        vmlal.s16       \w0, \r0, \c1
37
+        vshrn.s32       \d3, \w0, #15
38
+        bflies          \q0, \q1, \w0, \w1
39
+.endm
40
+
41
+.macro  transform2      d0,  d1,  d2,  d3,  q0,  q1,  c0,  c1,  c2,  c3, \
42
+                        r0,  r1,  w0,  w1
43
+        vrev32.16       \r0, \d1
44
+        vrev32.16       \r1, \d3
45
+        vmull.s16       \w0, \d1, \c0
46
+        vmlal.s16       \w0, \r0, \c1
47
+        vmull.s16       \w1, \d3, \c2
48
+        vmlal.s16       \w1, \r1, \c3
49
+        vshrn.s32       \d1, \w0, #15
50
+        vshrn.s32       \d3, \w1, #15
51
+        bflies          \q0, \q1, \w0, \w1
52
+.endm
53
+
54
+.macro  fft4            d0,  d1,  r0,  r1
55
+        vhsub.s16       \r0, \d0, \d1           @ t3, t4, t8, t7
56
+        vhsub.s16       \r1, \d1, \d0
57
+        vhadd.s16       \d0, \d0, \d1           @ t1, t2, t6, t5
58
+        vmov.i64        \d1, #0xffff<<32
59
+        vbit            \r0, \r1, \d1
60
+        vrev64.16       \r1, \r0                @ t7, t8, t4, t3
61
+        vtrn.32         \r0, \r1                @ t3, t4, t7, t8
62
+        vtrn.32         \d0, \r0                @ t1, t2, t3, t4, t6, t5, t8, t7
63
+        vhsub.s16       \d1, \d0, \r0           @ r2, i2, r3, i1
64
+        vhadd.s16       \d0, \d0, \r0           @ r0, i0, r1, i3
65
+.endm
66
+
67
+.macro  fft8            d0,  d1,  d2,  d3,  q0,  q1,  c0,  c1,  r0,  r1, w0, w1
68
+        fft4            \d0, \d1, \r0, \r1
69
+        vtrn.32         \d0, \d1                @ z0, z2, z1, z3
70
+        vhadd.s16       \r0, \d2, \d3           @ t1, t2, t3, t4
71
+        vhsub.s16       \d3, \d2, \d3           @ z5, z7
72
+        vmov            \d2, \r0
73
+        transform01     \q0, \q1, \d3, \c0, \c1, \r0, \w0, \w1
74
+.endm
75
+
76
+function fft4_neon
77
+        vld1.16         {d0-d1},  [r0,:128]
78
+        fft4            d0,  d1,  d2,  d3
79
+        vst1.16         {d0-d1},  [r0,:128]
80
+        bx              lr
81
+endfunc
82
+
83
+function fft8_neon
84
+        vld1.16         {d0-d3},  [r0,:128]
85
+        movrel          r1,  coefs
86
+        vld1.16         {d30},    [r1,:64]
87
+        vdup.16         d31, d30[0]
88
+        fft8            d0,  d1,  d2,  d3,  q0,  q1,  d31, d30, d20, d21, q8, q9
89
+        vtrn.32         d0,  d1
90
+        vtrn.32         d2,  d3
91
+        vst1.16         {d0-d3},  [r0,:128]
92
+        bx              lr
93
+endfunc
94
+
95
+function fft16_neon
96
+        vld1.16         {d0-d3},  [r0,:128]!
97
+        vld1.16         {d4-d7},  [r0,:128]
98
+        movrel          r1,  coefs
99
+        sub             r0,  r0,  #32
100
+        vld1.16         {d28-d31},[r1,:128]
101
+        vdup.16         d31, d28[0]
102
+        fft8            d0,  d1,  d2,  d3,  q0,  q1,  d31, d28, d20, d21, q8, q9
103
+        vswp            d5,  d6
104
+        fft4            q2,  q3,  q8,  q9
105
+        vswp            d5,  d6
106
+        vtrn.32         q0,  q1             @ z0, z4, z2, z6, z1, z5, z3, z7
107
+        vtrn.32         q2,  q3             @ z8, z12,z10,z14,z9, z13,z11,z15
108
+        vswp            d1,  d2
109
+        vdup.16         d31, d28[0]
110
+        transform01     q0,  q2,  d5,  d31, d28, d20, q8, q9
111
+        vdup.16         d26, d29[0]
112
+        vdup.16         d27, d30[0]
113
+        transform2      d2,  d6,  d3,  d7,  q1,  q3,  d26, d30, d27, d29, \
114
+                        d20, d21, q8,  q9
115
+        vtrn.32         q0,  q1
116
+        vtrn.32         q2,  q3
117
+        vst1.16         {d0-d3},  [r0,:128]!
118
+        vst1.16         {d4-d7},  [r0,:128]
119
+        bx              lr
120
+endfunc
121
+
122
+function fft_pass_neon
123
+        push            {r4,lr}
124
+        movrel          lr,  coefs + 24
125
+        vld1.16         {d30},    [lr,:64]
126
+        lsl             r12, r2,  #3
127
+        vmov            d31, d30
128
+        add             r3,  r1,  r2,  lsl #2
129
+        mov             lr,  #-8
130
+        sub             r3,  r3,  #2
131
+        mov             r4,  r0
132
+        vld1.16         {d27[]},  [r3,:16]
133
+        sub             r3,  r3,  #6
134
+        vld1.16         {q0},     [r4,:128], r12
135
+        vld1.16         {q1},     [r4,:128], r12
136
+        vld1.16         {q2},     [r4,:128], r12
137
+        vld1.16         {q3},     [r4,:128], r12
138
+        vld1.16         {d28},    [r1,:64]!
139
+        vld1.16         {d29},    [r3,:64], lr
140
+        vswp            d1,  d2
141
+        vswp            d5,  d6
142
+        vtrn.32         d0,  d1
143
+        vtrn.32         d4,  d5
144
+        vdup.16         d25, d28[1]
145
+        vmul.s16        d27, d27, d31
146
+        transform01     q0,  q2,  d5,  d25, d27, d20, q8,  q9
147
+        b               2f
148
+1:
149
+        mov             r4,  r0
150
+        vdup.16         d26, d29[0]
151
+        vld1.16         {q0},     [r4,:128], r12
152
+        vld1.16         {q1},     [r4,:128], r12
153
+        vld1.16         {q2},     [r4,:128], r12
154
+        vld1.16         {q3},     [r4,:128], r12
155
+        vld1.16         {d28},    [r1,:64]!
156
+        vld1.16         {d29},    [r3,:64], lr
157
+        vswp            d1,  d2
158
+        vswp            d5,  d6
159
+        vtrn.32         d0,  d1
160
+        vtrn.32         d4,  d5
161
+        vdup.16         d24, d28[0]
162
+        vdup.16         d25, d28[1]
163
+        vdup.16         d27, d29[3]
164
+        vmul.s16        q13, q13, q15
165
+        transform2      d0,  d4,  d1,  d5,  q0,  q2,  d24, d26, d25, d27, \
166
+                        d16, d17, q9,  q10
167
+2:
168
+        vtrn.32         d2,  d3
169
+        vtrn.32         d6,  d7
170
+        vdup.16         d24, d28[2]
171
+        vdup.16         d26, d29[2]
172
+        vdup.16         d25, d28[3]
173
+        vdup.16         d27, d29[1]
174
+        vmul.s16        q13, q13, q15
175
+        transform2      d2,  d6,  d3,  d7,  q1,  q3,  d24, d26, d25, d27, \
176
+                        d16, d17, q9,  q10
177
+        vtrn.32         d0,  d1
178
+        vtrn.32         d2,  d3
179
+        vtrn.32         d4,  d5
180
+        vtrn.32         d6,  d7
181
+        vswp            d1,  d2
182
+        vswp            d5,  d6
183
+        mov             r4,  r0
184
+        vst1.16         {q0},     [r4,:128], r12
185
+        vst1.16         {q1},     [r4,:128], r12
186
+        vst1.16         {q2},     [r4,:128], r12
187
+        vst1.16         {q3},     [r4,:128], r12
188
+        add             r0,  r0,  #16
189
+        subs            r2,  r2,  #2
190
+        bgt             1b
191
+        pop             {r4,pc}
192
+endfunc
193
+
194
+#define F_SQRT1_2   23170
195
+#define F_COS_16_1  30274
196
+#define F_COS_16_3  12540
197
+
198
+const   coefs, align=4
199
+        .short          F_SQRT1_2, -F_SQRT1_2, -F_SQRT1_2,  F_SQRT1_2
200
+        .short          F_COS_16_1,-F_COS_16_1,-F_COS_16_1, F_COS_16_1
201
+        .short          F_COS_16_3,-F_COS_16_3,-F_COS_16_3, F_COS_16_3
202
+        .short          1,         -1,         -1,          1
203
+endconst
204
+
205
+.macro  def_fft n, n2, n4
206
+function fft\n\()_neon
207
+        push            {r4, lr}
208
+        mov             r4,  r0
209
+        bl              fft\n2\()_neon
210
+        add             r0,  r4,  #\n4*2*4
211
+        bl              fft\n4\()_neon
212
+        add             r0,  r4,  #\n4*3*4
213
+        bl              fft\n4\()_neon
214
+        mov             r0,  r4
215
+        pop             {r4, lr}
216
+        movrel          r1,  X(ff_cos_\n\()_fixed)
217
+        mov             r2,  #\n4/2
218
+        b               fft_pass_neon
219
+endfunc
220
+.endm
221
+
222
+        def_fft    32,    16,     8
223
+        def_fft    64,    32,    16
224
+        def_fft   128,    64,    32
225
+        def_fft   256,   128,    64
226
+        def_fft   512,   256,   128
227
+        def_fft  1024,   512,   256
228
+        def_fft  2048,  1024,   512
229
+        def_fft  4096,  2048,  1024
230
+        def_fft  8192,  4096,  2048
231
+        def_fft 16384,  8192,  4096
232
+        def_fft 32768, 16384,  8192
233
+        def_fft 65536, 32768, 16384
234
+
235
+function ff_fft_fixed_calc_neon, export=1
236
+        ldr             r2,  [r0]
237
+        sub             r2,  r2,  #2
238
+        movrel          r3,  fft_fixed_tab_neon
239
+        ldr             r3,  [r3, r2, lsl #2]
240
+        mov             r0,  r1
241
+        bx              r3
242
+endfunc
243
+
244
+const   fft_fixed_tab_neon
245
+        .word fft4_neon
246
+        .word fft8_neon
247
+        .word fft16_neon
248
+        .word fft32_neon
249
+        .word fft64_neon
250
+        .word fft128_neon
251
+        .word fft256_neon
252
+        .word fft512_neon
253
+        .word fft1024_neon
254
+        .word fft2048_neon
255
+        .word fft4096_neon
256
+        .word fft8192_neon
257
+        .word fft16384_neon
258
+        .word fft32768_neon
259
+        .word fft65536_neon
260
+endconst
0 261
new file mode 100644
... ...
@@ -0,0 +1,195 @@
0
+/*
1
+ * Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
2
+ *
3
+ * This file is part of Libav.
4
+ *
5
+ * Libav is free software; you can redistribute it and/or
6
+ * modify it under the terms of the GNU Lesser General Public
7
+ * License as published by the Free Software Foundation; either
8
+ * version 2.1 of the License, or (at your option) any later version.
9
+ *
10
+ * Libav is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
+ * Lesser General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU Lesser General Public
16
+ * License along with Libav; if not, write to the Free Software
17
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
+ */
19
+
20
+#include "asm.S"
21
+
22
+        preserve8
23
+
24
+.macro  prerot          dst, rt
25
+        lsr             r3,  r6,  #2            @ n4
26
+        add             \rt, r4,  r6,  lsr #1   @ revtab + n4
27
+        add             r9,  r3,  r3,  lsl #1   @ n3
28
+        add             r8,  r7,  r6            @ tcos + n4
29
+        add             r3,  r2,  r6,  lsr #1   @ in + n4
30
+        add             r9,  r2,  r9,  lsl #1   @ in + n3
31
+        sub             r8,  r8,  #16
32
+        sub             r10, r3,  #16
33
+        sub             r11, r9,  #16
34
+        mov             r12, #-16
35
+1:
36
+        vld2.16         {d0,d1},  [r9, :128]!
37
+        vld2.16         {d2,d3},  [r11,:128], r12
38
+        vld2.16         {d4,d5},  [r3, :128]!
39
+        vld2.16         {d6,d7},  [r10,:128], r12
40
+        vld2.16         {d16,d17},[r7, :128]!   @ cos, sin
41
+        vld2.16         {d18,d19},[r8, :128], r12
42
+        vrev64.16       q1,  q1
43
+        vrev64.16       q3,  q3
44
+        vrev64.16       q9,  q9
45
+        vneg.s16        d0,  d0
46
+        vneg.s16        d2,  d2
47
+        vneg.s16        d16, d16
48
+        vneg.s16        d18, d18
49
+        vhsub.s16       d0,  d0,  d3            @ re
50
+        vhsub.s16       d4,  d7,  d4            @ im
51
+        vhsub.s16       d6,  d6,  d5
52
+        vhsub.s16       d2,  d2,  d1
53
+        vmull.s16       q10, d0,  d16
54
+        vmlsl.s16       q10, d4,  d17
55
+        vmull.s16       q11, d0,  d17
56
+        vmlal.s16       q11, d4,  d16
57
+        vmull.s16       q12, d6,  d18
58
+        vmlsl.s16       q12, d2,  d19
59
+        vmull.s16       q13, d6,  d19
60
+        vmlal.s16       q13, d2,  d18
61
+        vshrn.s32       d0,  q10, #15
62
+        vshrn.s32       d1,  q11, #15
63
+        vshrn.s32       d2,  q12, #15
64
+        vshrn.s32       d3,  q13, #15
65
+        vzip.16         d0,  d1
66
+        vzip.16         d2,  d3
67
+        ldrh            lr,  [r4], #2
68
+        ldrh            r2,  [\rt, #-2]!
69
+        add             lr,  \dst, lr,  lsl #2
70
+        add             r2,  \dst, r2,  lsl #2
71
+        vst1.32         {d0[0]},  [lr,:32]
72
+        vst1.32         {d2[0]},  [r2,:32]
73
+        ldrh            lr,  [r4], #2
74
+        ldrh            r2,  [\rt, #-2]!
75
+        add             lr,  \dst, lr,  lsl #2
76
+        add             r2,  \dst, r2,  lsl #2
77
+        vst1.32         {d0[1]},  [lr,:32]
78
+        vst1.32         {d2[1]},  [r2,:32]
79
+        ldrh            lr,  [r4], #2
80
+        ldrh            r2,  [\rt, #-2]!
81
+        add             lr,  \dst, lr,  lsl #2
82
+        add             r2,  \dst, r2,  lsl #2
83
+        vst1.32         {d1[0]},  [lr,:32]
84
+        vst1.32         {d3[0]},  [r2,:32]
85
+        ldrh            lr,  [r4], #2
86
+        ldrh            r2,  [\rt, #-2]!
87
+        add             lr,  \dst, lr,  lsl #2
88
+        add             r2,  \dst, r2,  lsl #2
89
+        vst1.32         {d1[1]},  [lr,:32]
90
+        vst1.32         {d3[1]},  [r2,:32]
91
+        subs            r6,  r6,  #32
92
+        bgt             1b
93
+.endm
94
+
95
+function ff_mdct_fixed_calc_neon, export=1
96
+        push            {r1,r4-r11,lr}
97
+
98
+        ldr             r4,  [r0, #8]           @ revtab
99
+        ldr             r6,  [r0, #16]          @ mdct_size; n
100
+        ldr             r7,  [r0, #24]          @ tcos
101
+
102
+        prerot          r1,  r5
103
+
104
+        mov             r4,  r0
105
+        bl              X(ff_fft_fixed_calc_neon)
106
+
107
+        pop             {r5}
108
+        mov             r12, #-16
109
+        ldr             r6,  [r4, #16]          @ mdct_size; n
110
+        ldr             r7,  [r4, #24]          @ tcos
111
+        add             r5,  r5,  r6,  lsr #1
112
+        add             r7,  r7,  r6,  lsr #1
113
+        sub             r1,  r5,  #16
114
+        sub             r2,  r7,  #16
115
+1:
116
+        vld2.16         {d4,d5},  [r7,:128]!
117
+        vld2.16         {d6,d7},  [r2,:128], r12
118
+        vld2.16         {d0,d1},  [r5,:128]
119
+        vld2.16         {d2,d3},  [r1,:128]
120
+        vrev64.16       q3,  q3
121
+        vrev64.16       q1,  q1
122
+        vneg.s16        q3,  q3
123
+        vneg.s16        q2,  q2
124
+        vmull.s16       q11, d2,  d6
125
+        vmlal.s16       q11, d3,  d7
126
+        vmull.s16       q8,  d0,  d5
127
+        vmlsl.s16       q8,  d1,  d4
128
+        vmull.s16       q9,  d0,  d4
129
+        vmlal.s16       q9,  d1,  d5
130
+        vmull.s16       q10, d2,  d7
131
+        vmlsl.s16       q10, d3,  d6
132
+        vshrn.s32       d0,  q11, #15
133
+        vshrn.s32       d1,  q8,  #15
134
+        vshrn.s32       d2,  q9,  #15
135
+        vshrn.s32       d3,  q10, #15
136
+        vrev64.16       q0,  q0
137
+        vst2.16         {d2,d3},  [r5,:128]!
138
+        vst2.16         {d0,d1},  [r1,:128], r12
139
+        subs            r6,  r6,  #32
140
+        bgt             1b
141
+
142
+        pop             {r4-r11,pc}
143
+endfunc
144
+
145
+function ff_mdct_fixed_calcw_neon, export=1
146
+        push            {r1,r4-r11,lr}
147
+
148
+        ldrd            r4,  r5,  [r0, #8]      @ revtab, tmp_buf
149
+        ldr             r6,  [r0, #16]          @ mdct_size; n
150
+        ldr             r7,  [r0, #24]          @ tcos
151
+
152
+        prerot          r5,  r1
153
+
154
+        mov             r4,  r0
155
+        mov             r1,  r5
156
+        bl              X(ff_fft_fixed_calc_neon)
157
+
158
+        pop             {r7}
159
+        mov             r12, #-16
160
+        ldr             r6,  [r4, #16]          @ mdct_size; n
161
+        ldr             r9,  [r4, #24]          @ tcos
162
+        add             r5,  r5,  r6,  lsr #1
163
+        add             r7,  r7,  r6
164
+        add             r9,  r9,  r6,  lsr #1
165
+        sub             r3,  r5,  #16
166
+        sub             r1,  r7,  #16
167
+        sub             r2,  r9,  #16
168
+1:
169
+        vld2.16         {d4,d5},  [r9,:128]!
170
+        vld2.16         {d6,d7},  [r2,:128], r12
171
+        vld2.16         {d0,d1},  [r5,:128]!
172
+        vld2.16         {d2,d3},  [r3,:128], r12
173
+        vrev64.16       q3,  q3
174
+        vrev64.16       q1,  q1
175
+        vneg.s16        q3,  q3
176
+        vneg.s16        q2,  q2
177
+        vmull.s16       q8,  d2,  d6
178
+        vmlal.s16       q8,  d3,  d7
179
+        vmull.s16       q9,  d0,  d5
180
+        vmlsl.s16       q9,  d1,  d4
181
+        vmull.s16       q10, d0,  d4
182
+        vmlal.s16       q10, d1,  d5
183
+        vmull.s16       q11, d2,  d7
184
+        vmlsl.s16       q11, d3,  d6
185
+        vrev64.32       q8,  q8
186
+        vrev64.32       q9,  q9
187
+        vst2.32         {q10,q11},[r7,:128]!
188
+        vst2.32         {d16,d18},[r1,:128], r12
189
+        vst2.32         {d17,d19},[r1,:128], r12
190
+        subs            r6,  r6,  #32
191
+        bgt             1b
192
+
193
+        pop             {r4-r11,pc}
194
+endfunc
... ...
@@ -1829,19 +1829,21 @@ typedef struct AVCodecContext {
1829 1829
      */
1830 1830
     uint64_t error[4];
1831 1831
 
1832
+#if FF_API_MB_Q
1832 1833
     /**
1833 1834
      * minimum MB quantizer
1834 1835
      * - encoding: unused
1835 1836
      * - decoding: unused
1836 1837
      */
1837
-    int mb_qmin;
1838
+    attribute_deprecated int mb_qmin;
1838 1839
 
1839 1840
     /**
1840 1841
      * maximum MB quantizer
1841 1842
      * - encoding: unused
1842 1843
      * - decoding: unused
1843 1844
      */
1844
-    int mb_qmax;
1845
+    attribute_deprecated int mb_qmax;
1846
+#endif
1845 1847
 
1846 1848
     /**
1847 1849
      * motion estimation comparison function
... ...
@@ -2162,16 +2164,19 @@ typedef struct AVCodecContext {
2162 2162
      */
2163 2163
     int error_rate;
2164 2164
 
2165
+#if FF_API_ANTIALIAS_ALGO
2165 2166
     /**
2166 2167
      * MP3 antialias algorithm, see FF_AA_* below.
2167 2168
      * - encoding: unused
2168 2169
      * - decoding: Set by user.
2169 2170
      */
2170
-    int antialias_algo;
2171
+    attribute_deprecated int antialias_algo;
2171 2172
 #define FF_AA_AUTO    0
2172 2173
 #define FF_AA_FASTINT 1 //not implemented yet
2173 2174
 #define FF_AA_INT     2
2174 2175
 #define FF_AA_FLOAT   3
2176
+#endif
2177
+
2175 2178
     /**
2176 2179
      * quantizer noise shaping
2177 2180
      * - encoding: Set by user.
... ...
@@ -126,6 +126,7 @@ av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
126 126
     if (CONFIG_MDCT)  s->mdct_calcw = s->mdct_calc;
127 127
 #else
128 128
     if (CONFIG_MDCT)  s->mdct_calcw = ff_mdct_calcw_c;
129
+    if (ARCH_ARM)     ff_fft_fixed_init_arm(s);
129 130
 #endif
130 131
 
131 132
     for(j=4; j<=nbits; j++) {
... ...
@@ -132,9 +132,13 @@ void ff_init_ff_cos_tabs(int index);
132 132
  */
133 133
 int ff_fft_init(FFTContext *s, int nbits, int inverse);
134 134
 
135
+#if CONFIG_FFT_FLOAT
135 136
 void ff_fft_init_altivec(FFTContext *s);
136 137
 void ff_fft_init_mmx(FFTContext *s);
137 138
 void ff_fft_init_arm(FFTContext *s);
139
+#else
140
+void ff_fft_fixed_init_arm(FFTContext *s);
141
+#endif
138 142
 
139 143
 void ff_fft_end(FFTContext *s);
140 144
 
... ...
@@ -259,8 +259,10 @@ static const AVOption options[]={
259 259
 {"pf", "forward predicted MVs of P-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_P_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},
260 260
 {"bf", "forward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_FOR, INT_MIN, INT_MAX, V|D, "debug_mv"},
261 261
 {"bb", "backward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST, FF_DEBUG_VIS_MV_B_BACK, INT_MIN, INT_MAX, V|D, "debug_mv"},
262
+#if FF_API_MB_Q
262 263
 {"mb_qmin", "obsolete, use qmin", OFFSET(mb_qmin), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
263 264
 {"mb_qmax", "obsolete, use qmax", OFFSET(mb_qmax), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
265
+#endif
264 266
 {"cmp", "full pel me compare function", OFFSET(me_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
265 267
 {"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
266 268
 {"mbcmp", "macroblock compare function", OFFSET(mb_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
... ...
@@ -317,7 +319,9 @@ static const AVOption options[]={
317 317
 {"inter_threshold", NULL, OFFSET(inter_threshold), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
318 318
 {"flags2", NULL, OFFSET(flags2), FF_OPT_TYPE_FLAGS, CODEC_FLAG2_FASTPSKIP|CODEC_FLAG2_BIT_RESERVOIR|CODEC_FLAG2_PSY|CODEC_FLAG2_MBTREE, 0, UINT_MAX, V|A|E|D, "flags2"},
319 319
 {"error", NULL, OFFSET(error_rate), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
320
+#if FF_API_ANTIALIAS_ALGO
320 321
 {"antialias", "MP3 antialias algorithm", OFFSET(antialias_algo), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|D, "aa"},
322
+#endif
321 323
 {"auto", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_AUTO, INT_MIN, INT_MAX, V|D, "aa"},
322 324
 {"fastint", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_FASTINT, INT_MIN, INT_MAX, V|D, "aa"},
323 325
 {"int", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_INT, INT_MIN, INT_MAX, V|D, "aa"},
... ...
@@ -77,5 +77,11 @@
77 77
 #ifndef FF_API_RATE_EMU
78 78
 #define FF_API_RATE_EMU         (LIBAVCODEC_VERSION_MAJOR < 53)
79 79
 #endif
80
+#ifndef FF_API_MB_Q
81
+#define FF_API_MB_Q             (LIBAVCODEC_VERSION_MAJOR < 53)
82
+#endif
83
+#ifndef FF_API_ANTIALIAS_ALGO
84
+#define FF_API_ANTIALIAS_ALGO   (LIBAVCODEC_VERSION_MAJOR < 54)
85
+#endif
80 86
 
81 87
 #endif /* AVCODEC_VERSION_H */
... ...
@@ -26,7 +26,7 @@
26 26
 #include "libavutil/samplefmt.h"
27 27
 
28 28
 #define LIBAVFILTER_VERSION_MAJOR  1
29
-#define LIBAVFILTER_VERSION_MINOR 76
29
+#define LIBAVFILTER_VERSION_MINOR 77
30 30
 #define LIBAVFILTER_VERSION_MICRO  0
31 31
 
32 32
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
... ...
@@ -238,7 +238,7 @@ static int aiff_read_header(AVFormatContext *s,
238 238
             offset += avio_tell(pb);    /* Compute absolute data offset */
239 239
             if (st->codec->block_align)    /* Assume COMM already parsed */
240 240
                 goto got_sound;
241
-            if (url_is_streamed(pb)) {
241
+            if (!pb->seekable) {
242 242
                 av_log(s, AV_LOG_ERROR, "file is not seekable\n");
243 243
                 return -1;
244 244
             }
... ...
@@ -124,7 +124,7 @@ static int aiff_write_trailer(AVFormatContext *s)
124 124
         end_size++;
125 125
     }
126 126
 
127
-    if (!url_is_streamed(s->pb)) {
127
+    if (s->pb->seekable) {
128 128
         /* File length */
129 129
         avio_seek(pb, aiff->form, SEEK_SET);
130 130
         avio_wb32(pb, file_size - aiff->form - 4);
... ...
@@ -296,7 +296,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
296 296
     ape_dumpinfo(s, ape);
297 297
 
298 298
     /* try to read APE tags */
299
-    if (!url_is_streamed(pb)) {
299
+    if (pb->seekable) {
300 300
         ff_ape_parse_tag(s);
301 301
         avio_seek(pb, 0, SEEK_SET);
302 302
     }
... ...
@@ -234,11 +234,11 @@ static void put_str16(AVIOContext *s, const char *tag)
234 234
     int len;
235 235
     uint8_t *pb;
236 236
     AVIOContext *dyn_buf;
237
-    if (url_open_dyn_buf(&dyn_buf) < 0)
237
+    if (avio_open_dyn_buf(&dyn_buf) < 0)
238 238
         return;
239 239
 
240 240
     avio_put_str16le(dyn_buf, tag);
241
-    len = url_close_dyn_buf(dyn_buf, &pb);
241
+    len = avio_close_dyn_buf(dyn_buf, &pb);
242 242
     avio_wl16(s, len);
243 243
     avio_write(s, pb, len);
244 244
     av_freep(&pb);
... ...
@@ -347,7 +347,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
347 347
     avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
348 348
     avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
349 349
     avio_wl64(pb, PREROLL_TIME); /* start time stamp */
350
-    avio_wl32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */
350
+    avio_wl32(pb, (asf->is_streamed || !pb->seekable ) ? 3 : 2); /* ??? */
351 351
     avio_wl32(pb, s->packet_size); /* packet size */
352 352
     avio_wl32(pb, s->packet_size); /* packet size */
353 353
     avio_wl32(pb, bit_rate); /* Nominal data rate in bps */
... ...
@@ -366,7 +366,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
366 366
         uint8_t *buf;
367 367
         AVIOContext *dyn_buf;
368 368
 
369
-        if (url_open_dyn_buf(&dyn_buf) < 0)
369
+        if (avio_open_dyn_buf(&dyn_buf) < 0)
370 370
             return AVERROR(ENOMEM);
371 371
 
372 372
         hpos = put_header(pb, &ff_asf_comment_header);
... ...
@@ -375,7 +375,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
375 375
             len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
376 376
             avio_wl16(pb, len);
377 377
         }
378
-        len = url_close_dyn_buf(dyn_buf, &buf);
378
+        len = avio_close_dyn_buf(dyn_buf, &buf);
379 379
         avio_write(pb, buf, len);
380 380
         av_freep(&buf);
381 381
         end_header(pb, hpos);
... ...
@@ -497,11 +497,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
497 497
         else
498 498
             desc = p ? p->name : enc->codec_name;
499 499
 
500
-        if ( url_open_dyn_buf(&dyn_buf) < 0)
500
+        if ( avio_open_dyn_buf(&dyn_buf) < 0)
501 501
             return AVERROR(ENOMEM);
502 502
 
503 503
         avio_put_str16le(dyn_buf, desc);
504
-        len = url_close_dyn_buf(dyn_buf, &buf);
504
+        len = avio_close_dyn_buf(dyn_buf, &buf);
505 505
         avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2
506 506
 
507 507
         avio_write(pb, buf, len);
... ...
@@ -866,7 +866,7 @@ static int asf_write_trailer(AVFormatContext *s)
866 866
     }
867 867
     avio_flush(s->pb);
868 868
 
869
-    if (asf->is_streamed || url_is_streamed(s->pb)) {
869
+    if (asf->is_streamed || !s->pb->seekable) {
870 870
         put_chunk(s, 0x4524, 0, 0); /* end of stream */
871 871
     } else {
872 872
         /* rewrite an updated header */
... ...
@@ -91,7 +91,7 @@ static int au_write_trailer(AVFormatContext *s)
91 91
     AVIOContext *pb = s->pb;
92 92
     int64_t file_size;
93 93
 
94
-    if (!url_is_streamed(s->pb)) {
94
+    if (s->pb->seekable) {
95 95
 
96 96
         /* update file size */
97 97
         file_size = avio_tell(pb);
... ...
@@ -89,14 +89,14 @@ int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
89 89
 int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
90 90
 {
91 91
     AVIOContext *pb;
92
-    int ret = url_open_dyn_buf(&pb);
92
+    int ret = avio_open_dyn_buf(&pb);
93 93
     if(ret < 0)
94 94
         return ret;
95 95
 
96 96
     ff_avc_parse_nal_units(pb, buf_in, *size);
97 97
 
98 98
     av_freep(buf);
99
-    *size = url_close_dyn_buf(pb, buf);
99
+    *size = avio_close_dyn_buf(pb, buf);
100 100
     return 0;
101 101
 }
102 102
 
... ...
@@ -665,7 +665,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
665 665
             break;
666 666
         case MKTAG('i', 'n', 'd', 'x'):
667 667
             i= avio_tell(pb);
668
-            if(!url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX)){
668
+            if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX)){
669 669
                 read_braindead_odml_indx(s, 0);
670 670
             }
671 671
             avio_seek(pb, i+size, SEEK_SET);
... ...
@@ -721,7 +721,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
721 721
         return -1;
722 722
     }
723 723
 
724
-    if(!avi->index_loaded && !url_is_streamed(pb))
724
+    if(!avi->index_loaded && pb->seekable)
725 725
         avi_load_index(s);
726 726
     avi->index_loaded = 1;
727 727
     avi->non_interleaved |= guess_ni_flag(s);
... ...
@@ -197,7 +197,7 @@ static int avi_write_header(AVFormatContext *s)
197 197
     }
198 198
     avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
199 199
     avio_wl32(pb, 0); /* padding */
200
-    if (url_is_streamed(pb))
200
+    if (!pb->seekable)
201 201
         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
202 202
     else
203 203
         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
... ...
@@ -259,7 +259,7 @@ static int avi_write_header(AVFormatContext *s)
259 259
 
260 260
         avio_wl32(pb, 0); /* start */
261 261
         avist->frames_hdr_strm = avio_tell(pb); /* remember this offset to fill later */
262
-        if (url_is_streamed(pb))
262
+        if (!pb->seekable)
263 263
             avio_wl32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */
264 264
         else
265 265
             avio_wl32(pb, 0); /* length, XXX: filled later */
... ...
@@ -303,7 +303,7 @@ static int avi_write_header(AVFormatContext *s)
303 303
         }
304 304
       }
305 305
 
306
-        if (!url_is_streamed(pb)) {
306
+        if (pb->seekable) {
307 307
             unsigned char tag[5];
308 308
             int j;
309 309
 
... ...
@@ -362,7 +362,7 @@ static int avi_write_header(AVFormatContext *s)
362 362
         ff_end_tag(pb, list2);
363 363
     }
364 364
 
365
-    if (!url_is_streamed(pb)) {
365
+    if (pb->seekable) {
366 366
         /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
367 367
         avi->odml_list = ff_start_tag(pb, "JUNK");
368 368
         ffio_wfourcc(pb, "odml");
... ...
@@ -406,7 +406,7 @@ static int avi_write_ix(AVFormatContext *s)
406 406
     char ix_tag[] = "ix00";
407 407
     int i, j;
408 408
 
409
-    assert(!url_is_streamed(pb));
409
+    assert(pb->seekable);
410 410
 
411 411
     if (avi->riff_id > AVI_MASTER_INDEX_SIZE)
412 412
         return -1;
... ...
@@ -464,7 +464,7 @@ static int avi_write_idx1(AVFormatContext *s)
464 464
     int i;
465 465
     char tag[5];
466 466
 
467
-    if (!url_is_streamed(pb)) {
467
+    if (pb->seekable) {
468 468
         AVIStream *avist;
469 469
         AVIIentry* ie = 0, *tie;
470 470
         int empty, stream_id = -1;
... ...
@@ -532,7 +532,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
532 532
     avist->packet_count++;
533 533
 
534 534
     // Make sure to put an OpenDML chunk when the file size exceeds the limits
535
-    if (!url_is_streamed(pb) &&
535
+    if (pb->seekable &&
536 536
         (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
537 537
 
538 538
         avi_write_ix(s);
... ...
@@ -552,7 +552,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
552 552
        avist->audio_strm_length += size;
553 553
     }
554 554
 
555
-    if (!url_is_streamed(s->pb)) {
555
+    if (s->pb->seekable) {
556 556
         AVIIndex* idx = &avist->indexes;
557 557
         int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE;
558 558
         int id = idx->entry % AVI_INDEX_CLUSTER_SIZE;
... ...
@@ -590,7 +590,7 @@ static int avi_write_trailer(AVFormatContext *s)
590 590
     int i, j, n, nb_frames;
591 591
     int64_t file_size;
592 592
 
593
-    if (!url_is_streamed(pb)){
593
+    if (pb->seekable){
594 594
         if (avi->riff_id == 1) {
595 595
             ff_end_tag(pb, avi->movi_list);
596 596
             res = avi_write_idx1(s);
... ...
@@ -332,6 +332,8 @@ attribute_deprecated int av_register_protocol(URLProtocol *protocol);
332 332
  */
333 333
 int av_register_protocol2(URLProtocol *protocol, int size);
334 334
 
335
+#define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */
336
+
335 337
 /**
336 338
  * Bytestream IO Context.
337 339
  * New fields can be added to the end with minor version bumps.
... ...
@@ -351,7 +353,9 @@ typedef struct {
351 351
     int must_flush; /**< true if the next seek should flush */
352 352
     int eof_reached; /**< true if eof reached */
353 353
     int write_flag;  /**< true if open for writing */
354
-    int is_streamed;
354
+#if FF_API_OLD_AVIO
355
+    attribute_deprecated int is_streamed;
356
+#endif
355 357
     int max_packet_size;
356 358
     unsigned long checksum;
357 359
     unsigned char *checksum_ptr;
... ...
@@ -360,6 +364,10 @@ typedef struct {
360 360
     int (*read_pause)(void *opaque, int pause);
361 361
     int64_t (*read_seek)(void *opaque, int stream_index,
362 362
                          int64_t timestamp, int flags);
363
+    /**
364
+     * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
365
+     */
366
+    int seekable;
363 367
 } AVIOContext;
364 368
 
365 369
 #if FF_API_OLD_AVIO
... ...
@@ -439,6 +447,10 @@ attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...) __att
439 439
 attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...);
440 440
 #endif
441 441
 attribute_deprecated void put_flush_packet(AVIOContext *s);
442
+attribute_deprecated int url_open_dyn_buf(AVIOContext **s);
443
+attribute_deprecated int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
444
+attribute_deprecated int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
445
+attribute_deprecated int url_fdopen(AVIOContext **s, URLContext *h);
442 446
 /**
443 447
  * @}
444 448
  */
... ...
@@ -603,23 +615,15 @@ unsigned int avio_rb24(AVIOContext *s);
603 603
 unsigned int avio_rb32(AVIOContext *s);
604 604
 uint64_t     avio_rb64(AVIOContext *s);
605 605
 
606
-static inline int url_is_streamed(AVIOContext *s)
607
-{
608
-    return s->is_streamed;
609
-}
610
-
606
+#if FF_API_OLD_AVIO
611 607
 /**
612
- * Create and initialize a AVIOContext for accessing the
613
- * resource referenced by the URLContext h.
614
- * @note When the URLContext h has been opened in read+write mode, the
615
- * AVIOContext can be used only for writing.
616
- *
617
- * @param s Used to return the pointer to the created AVIOContext.
618
- * In case of failure the pointed to value is set to NULL.
619
- * @return 0 in case of success, a negative value corresponding to an
620
- * AVERROR code in case of failure
608
+ * @deprecated Use AVIOContext.seekable field directly.
621 609
  */
622
-int url_fdopen(AVIOContext **s, URLContext *h);
610
+attribute_deprecated static inline int url_is_streamed(AVIOContext *s)
611
+{
612
+    return !s->seekable;
613
+}
614
+#endif
623 615
 
624 616
 #if FF_API_URL_RESETBUF
625 617
 /** Reset the buffer for reading or writing.
... ...
@@ -666,30 +670,18 @@ attribute_deprecated int url_close_buf(AVIOContext *s);
666 666
  * @param s new IO context
667 667
  * @return zero if no error.
668 668
  */
669
-int url_open_dyn_buf(AVIOContext **s);
670
-
671
-/**
672
- * Open a write only packetized memory stream with a maximum packet
673
- * size of 'max_packet_size'.  The stream is stored in a memory buffer
674
- * with a big endian 4 byte header giving the packet size in bytes.
675
- *
676
- * @param s new IO context
677
- * @param max_packet_size maximum packet size (must be > 0)
678
- * @return zero if no error.
679
- */
680
-int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
669
+int avio_open_dyn_buf(AVIOContext **s);
681 670
 
682 671
 /**
683 672
  * Return the written size and a pointer to the buffer. The buffer
684
- * must be freed with av_free(). If the buffer is opened with
685
- * url_open_dyn_buf, then padding of FF_INPUT_BUFFER_PADDING_SIZE is
686
- * added; if opened with url_open_dyn_packet_buf, no padding is added.
673
+ * must be freed with av_free().
674
+ * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
687 675
  *
688 676
  * @param s IO context
689 677
  * @param pbuffer pointer to a byte buffer
690 678
  * @return the length of the byte buffer
691 679
  */
692
-int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
680
+int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
693 681
 
694 682
 #if FF_API_UDP_GET_FILE
695 683
 int udp_get_file_handle(URLContext *h);
... ...
@@ -81,4 +81,28 @@ unsigned long ffio_get_checksum(AVIOContext *s);
81 81
 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
82 82
                                     unsigned int len);
83 83
 
84
+/**
85
+ * Open a write only packetized memory stream with a maximum packet
86
+ * size of 'max_packet_size'.  The stream is stored in a memory buffer
87
+ * with a big endian 4 byte header giving the packet size in bytes.
88
+ *
89
+ * @param s new IO context
90
+ * @param max_packet_size maximum packet size (must be > 0)
91
+ * @return zero if no error.
92
+ */
93
+int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
94
+
95
+/**
96
+ * Create and initialize a AVIOContext for accessing the
97
+ * resource referenced by the URLContext h.
98
+ * @note When the URLContext h has been opened in read+write mode, the
99
+ * AVIOContext can be used only for writing.
100
+ *
101
+ * @param s Used to return the pointer to the created AVIOContext.
102
+ * In case of failure the pointed to value is set to NULL.
103
+ * @return 0 in case of success, a negative value corresponding to an
104
+ * AVERROR code in case of failure
105
+ */
106
+int ffio_fdopen(AVIOContext **s, URLContext *h);
107
+
84 108
 #endif // AVFORMAT_AVIO_INTERNAL_H
... ...
@@ -62,7 +62,10 @@ int ffio_init_context(AVIOContext *s,
62 62
     s->must_flush = 0;
63 63
     s->eof_reached = 0;
64 64
     s->error = 0;
65
+#if FF_API_OLD_AVIO
65 66
     s->is_streamed = 0;
67
+#endif
68
+    s->seekable = AVIO_SEEKABLE_NORMAL;
66 69
     s->max_packet_size = 0;
67 70
     s->update_checksum= NULL;
68 71
     if(!read_packet && !write_flag){
... ...
@@ -202,7 +205,7 @@ int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
202 202
         offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
203 203
         /* can do the seek inside the buffer */
204 204
         s->buf_ptr = s->buffer + offset1;
205
-    } else if ((s->is_streamed ||
205
+    } else if ((!s->seekable ||
206 206
                offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
207 207
                !s->write_flag && offset1 >= 0 &&
208 208
               (whence != SEEK_END || force)) {
... ...
@@ -425,6 +428,22 @@ unsigned long get_checksum(AVIOContext *s)
425 425
 {
426 426
     return ffio_get_checksum(s);
427 427
 }
428
+int url_open_dyn_buf(AVIOContext **s)
429
+{
430
+    return avio_open_dyn_buf(s);
431
+}
432
+int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
433
+{
434
+    return ffio_open_dyn_packet_buf(s, max_packet_size);
435
+}
436
+int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
437
+{
438
+    return avio_close_dyn_buf(s, pbuffer);
439
+}
440
+int url_fdopen(AVIOContext **s, URLContext *h)
441
+{
442
+    return ffio_fdopen(s, h);
443
+}
428 444
 #endif
429 445
 
430 446
 int avio_put_str(AVIOContext *s, const char *str)
... ...
@@ -812,7 +831,7 @@ uint64_t ffio_read_varlen(AVIOContext *bc){
812 812
     return val;
813 813
 }
814 814
 
815
-int url_fdopen(AVIOContext **s, URLContext *h)
815
+int ffio_fdopen(AVIOContext **s, URLContext *h)
816 816
 {
817 817
     uint8_t *buffer;
818 818
     int buffer_size, max_packet_size;
... ...
@@ -840,7 +859,10 @@ int url_fdopen(AVIOContext **s, URLContext *h)
840 840
         av_freep(s);
841 841
         return AVERROR(EIO);
842 842
     }
843
+#if FF_API_OLD_AVIO
843 844
     (*s)->is_streamed = h->is_streamed;
845
+#endif
846
+    (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
844 847
     (*s)->max_packet_size = max_packet_size;
845 848
     if(h->prot) {
846 849
         (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
... ...
@@ -934,7 +956,7 @@ int avio_open(AVIOContext **s, const char *filename, int flags)
934 934
     err = url_open(&h, filename, flags);
935 935
     if (err < 0)
936 936
         return err;
937
-    err = url_fdopen(s, h);
937
+    err = ffio_fdopen(s, h);
938 938
     if (err < 0) {
939 939
         url_close(h);
940 940
         return err;
... ...
@@ -1026,7 +1048,7 @@ int64_t ffio_read_seek(AVIOContext *s, int stream_index,
1026 1026
     return ret;
1027 1027
 }
1028 1028
 
1029
-/* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
1029
+/* avio_open_dyn_buf and avio_close_dyn_buf are used in rtp.c to send a response
1030 1030
  * back to the server even if CONFIG_MUXERS is false. */
1031 1031
 #if CONFIG_MUXERS || CONFIG_NETWORK
1032 1032
 /* buffer handling */
... ...
@@ -1123,7 +1145,6 @@ static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
1123 1123
 static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
1124 1124
 {
1125 1125
     DynBuffer *d;
1126
-    int ret;
1127 1126
     unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
1128 1127
 
1129 1128
     if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
... ...
@@ -1131,38 +1152,31 @@ static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
1131 1131
     d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
1132 1132
     if (!d)
1133 1133
         return AVERROR(ENOMEM);
1134
-    *s = av_mallocz(sizeof(AVIOContext));
1134
+    d->io_buffer_size = io_buffer_size;
1135
+    *s = avio_alloc_context(d->io_buffer, d->io_buffer_size, 1, d, NULL,
1136
+                            max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
1137
+                            max_packet_size ? NULL : dyn_buf_seek);
1135 1138
     if(!*s) {
1136 1139
         av_free(d);
1137 1140
         return AVERROR(ENOMEM);
1138 1141
     }
1139
-    d->io_buffer_size = io_buffer_size;
1140
-    ret = ffio_init_context(*s, d->io_buffer, io_buffer_size,
1141
-                        1, d, NULL,
1142
-                        max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
1143
-                        max_packet_size ? NULL : dyn_buf_seek);
1144
-    if (ret == 0) {
1145
-        (*s)->max_packet_size = max_packet_size;
1146
-    } else {
1147
-        av_free(d);
1148
-        av_freep(s);
1149
-    }
1150
-    return ret;
1142
+    (*s)->max_packet_size = max_packet_size;
1143
+    return 0;
1151 1144
 }
1152 1145
 
1153
-int url_open_dyn_buf(AVIOContext **s)
1146
+int avio_open_dyn_buf(AVIOContext **s)
1154 1147
 {
1155 1148
     return url_open_dyn_buf_internal(s, 0);
1156 1149
 }
1157 1150
 
1158
-int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
1151
+int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
1159 1152
 {
1160 1153
     if (max_packet_size <= 0)
1161 1154
         return -1;
1162 1155
     return url_open_dyn_buf_internal(s, max_packet_size);
1163 1156
 }
1164 1157
 
1165
-int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1158
+int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1166 1159
 {
1167 1160
     DynBuffer *d = s->opaque;
1168 1161
     int size;
... ...
@@ -247,7 +247,7 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
247 247
     BinkDemuxContext *bink = s->priv_data;
248 248
     AVStream *vst = s->streams[0];
249 249
 
250
-    if (url_is_streamed(s->pb))
250
+    if (!s->pb->seekable)
251 251
         return -1;
252 252
 
253 253
     /* seek to the first frame */
... ...
@@ -223,7 +223,7 @@ static int read_header(AVFormatContext *s,
223 223
 
224 224
         /* stop at data chunk if seeking is not supported or
225 225
            data chunk size is unknown */
226
-        if (found_data && (caf->data_size < 0 || url_is_streamed(pb)))
226
+        if (found_data && (caf->data_size < 0 || !pb->seekable))
227 227
             break;
228 228
 
229 229
         tag  = avio_rb32(pb);
... ...
@@ -236,7 +236,7 @@ static int read_header(AVFormatContext *s,
236 236
             avio_skip(pb, 4); /* edit count */
237 237
             caf->data_start = avio_tell(pb);
238 238
             caf->data_size  = size < 0 ? -1 : size - 4;
239
-            if (caf->data_size > 0 && !url_is_streamed(pb))
239
+            if (caf->data_size > 0 && pb->seekable)
240 240
                 avio_skip(pb, caf->data_size);
241 241
             found_data = 1;
242 242
             break;
... ...
@@ -281,7 +281,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
281 281
         goto fail;
282 282
     ffm->write_index = avio_rb64(pb);
283 283
     /* get also filesize */
284
-    if (!url_is_streamed(pb)) {
284
+    if (pb->seekable) {
285 285
         ffm->file_size = avio_size(pb);
286 286
         if (ffm->write_index)
287 287
             adjust_write_index(s);
... ...
@@ -40,7 +40,7 @@ static int read_header(AVFormatContext *s,
40 40
     AVIOContext *pb = s->pb;
41 41
     AVStream *st;
42 42
 
43
-    if (url_is_streamed(s->pb))
43
+    if (!s->pb->seekable)
44 44
         return AVERROR(EIO);
45 45
 
46 46
     avio_seek(pb, avio_size(pb) - 36, SEEK_SET);
... ...
@@ -98,7 +98,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
98 98
     if (!ff_flac_is_extradata_valid(s->streams[0]->codec, &format, &streaminfo))
99 99
         return -1;
100 100
 
101
-    if (!url_is_streamed(pb)) {
101
+    if (pb->seekable) {
102 102
         /* rewrite the STREAMINFO header block data */
103 103
         file_size = avio_tell(pb);
104 104
         avio_seek(pb, 8, SEEK_SET);
... ...
@@ -428,7 +428,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
428 428
  }
429 429
 
430 430
     // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
431
-    if(!url_is_streamed(s->pb) && (!s->duration || s->duration==AV_NOPTS_VALUE)){
431
+    if(s->pb->seekable && (!s->duration || s->duration==AV_NOPTS_VALUE)){
432 432
         int size;
433 433
         const int64_t pos= avio_tell(s->pb);
434 434
         const int64_t fsize= avio_size(s->pb);
... ...
@@ -530,7 +530,7 @@ static int flv_read_seek2(AVFormatContext *s, int stream_index,
530 530
 
531 531
     if (ts - min_ts > (uint64_t)(max_ts - ts)) flags |= AVSEEK_FLAG_BACKWARD;
532 532
 
533
-    if (url_is_streamed(s->pb)) {
533
+    if (!s->pb->seekable) {
534 534
         if (stream_index < 0) {
535 535
             stream_index = av_find_default_stream_index(s);
536 536
             if (stream_index < 0)
... ...
@@ -634,7 +634,7 @@ static int gxf_write_header(AVFormatContext *s)
634 634
     uint8_t tracks[255] = {0};
635 635
     int i, media_info = 0;
636 636
 
637
-    if (url_is_streamed(pb)) {
637
+    if (!pb->seekable) {
638 638
         av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, patch welcome");
639 639
         return -1;
640 640
     }
... ...
@@ -229,7 +229,7 @@ void ff_id3v1_read(AVFormatContext *s)
229 229
     uint8_t buf[ID3v1_TAG_SIZE];
230 230
     int64_t filesize, position = avio_tell(s->pb);
231 231
 
232
-    if (!url_is_streamed(s->pb)) {
232
+    if (s->pb->seekable) {
233 233
         /* XXX: change that */
234 234
         filesize = avio_size(s->pb);
235 235
         if (filesize > 128) {
... ...
@@ -1120,7 +1120,7 @@ static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
1120 1120
     int i;
1121 1121
 
1122 1122
     // we should not do any seeking in the streaming case
1123
-    if (url_is_streamed(matroska->ctx->pb) ||
1123
+    if (!matroska->ctx->pb->seekable ||
1124 1124
         (matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
1125 1125
         return;
1126 1126
 
... ...
@@ -455,7 +455,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecCo
455 455
     uint8_t *codecpriv;
456 456
     int ret, codecpriv_size;
457 457
 
458
-    ret = url_open_dyn_buf(&dyn_cp);
458
+    ret = avio_open_dyn_buf(&dyn_cp);
459 459
     if(ret < 0)
460 460
         return ret;
461 461
 
... ...
@@ -498,7 +498,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecCo
498 498
         ff_put_wav_header(dyn_cp, codec);
499 499
     }
500 500
 
501
-    codecpriv_size = url_close_dyn_buf(dyn_cp, &codecpriv);
501
+    codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
502 502
     if (codecpriv_size)
503 503
         put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size);
504 504
     av_free(codecpriv);
... ...
@@ -852,7 +852,7 @@ static int mkv_write_header(AVFormatContext *s)
852 852
         if (ret < 0) return ret;
853 853
     }
854 854
 
855
-    if (url_is_streamed(s->pb))
855
+    if (!s->pb->seekable)
856 856
         mkv_write_seekhead(pb, mkv->main_seekhead);
857 857
 
858 858
     mkv->cues = mkv_start_cues(mkv->segment_offset);
... ...
@@ -1007,7 +1007,7 @@ static void mkv_flush_dynbuf(AVFormatContext *s)
1007 1007
     if (!mkv->dyn_bc)
1008 1008
         return;
1009 1009
 
1010
-    bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
1010
+    bufsize = avio_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
1011 1011
     avio_write(s->pb, dyn_buf, bufsize);
1012 1012
     av_free(dyn_buf);
1013 1013
     mkv->dyn_bc = NULL;
... ...
@@ -1028,9 +1028,9 @@ static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
1028 1028
         return AVERROR(EINVAL);
1029 1029
     }
1030 1030
 
1031
-    if (url_is_streamed(s->pb)) {
1031
+    if (!s->pb->seekable) {
1032 1032
         if (!mkv->dyn_bc)
1033
-            url_open_dyn_buf(&mkv->dyn_bc);
1033
+            avio_open_dyn_buf(&mkv->dyn_bc);
1034 1034
         pb = mkv->dyn_bc;
1035 1035
     }
1036 1036
 
... ...
@@ -1080,16 +1080,16 @@ static int mkv_copy_packet(MatroskaMuxContext *mkv, const AVPacket *pkt)
1080 1080
 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
1081 1081
 {
1082 1082
     MatroskaMuxContext *mkv = s->priv_data;
1083
-    AVIOContext *pb = url_is_streamed(s->pb) ? mkv->dyn_bc : s->pb;
1083
+    AVIOContext *pb = s->pb->seekable ? s->pb : mkv->dyn_bc;
1084 1084
     AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
1085 1085
     int ret, keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
1086 1086
     int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
1087
-    int cluster_size = avio_tell(pb) - (url_is_streamed(s->pb) ? 0 : mkv->cluster_pos);
1087
+    int cluster_size = avio_tell(pb) - (s->pb->seekable ? mkv->cluster_pos : 0);
1088 1088
 
1089 1089
     // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1090 1090
     // after 4k and on a keyframe
1091 1091
     if (mkv->cluster_pos &&
1092
-        ((url_is_streamed(s->pb) && (cluster_size > 32*1024 || ts > mkv->cluster_pts + 1000))
1092
+        ((!s->pb->seekable && (cluster_size > 32*1024 || ts > mkv->cluster_pts + 1000))
1093 1093
          ||                      cluster_size > 5*1024*1024 || ts > mkv->cluster_pts + 5000
1094 1094
          || (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe && cluster_size > 4*1024))) {
1095 1095
         av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
... ...
@@ -1143,7 +1143,7 @@ static int mkv_write_trailer(AVFormatContext *s)
1143 1143
         end_ebml_master(pb, mkv->cluster);
1144 1144
     }
1145 1145
 
1146
-    if (!url_is_streamed(pb)) {
1146
+    if (pb->seekable) {
1147 1147
         cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams);
1148 1148
 
1149 1149
         ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES    , cuespos);
... ...
@@ -133,7 +133,7 @@ static int mmf_write_trailer(AVFormatContext *s)
133 133
     int64_t pos, size;
134 134
     int gatetime;
135 135
 
136
-    if (!url_is_streamed(s->pb)) {
136
+    if (s->pb->seekable) {
137 137
         /* Fill in length fields */
138 138
         end_tag_be(pb, mmf->awapos);
139 139
         end_tag_be(pb, mmf->atrpos);
... ...
@@ -304,7 +304,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
304 304
             if (err < 0)
305 305
                 return err;
306 306
             if (c->found_moov && c->found_mdat &&
307
-                (url_is_streamed(pb) || start_pos + a.size == avio_size(pb)))
307
+                (!pb->seekable || start_pos + a.size == avio_size(pb)))
308 308
                 return 0;
309 309
             left = a.size - avio_tell(pb) + start_pos;
310 310
             if (left > 0) /* skip garbage at atom end */
... ...
@@ -2354,7 +2354,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
2354 2354
 
2355 2355
     mov->fc = s;
2356 2356
     /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
2357
-    if(!url_is_streamed(pb))
2357
+    if(pb->seekable)
2358 2358
         atom.size = avio_size(pb);
2359 2359
     else
2360 2360
         atom.size = INT64_MAX;
... ...
@@ -2370,7 +2370,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
2370 2370
     }
2371 2371
     av_dlog(mov->fc, "on_parse_exit_offset=%lld\n", avio_tell(pb));
2372 2372
 
2373
-    if (!url_is_streamed(pb) && mov->chapter_track > 0)
2373
+    if (pb->seekable && mov->chapter_track > 0)
2374 2374
         mov_read_chapters(s);
2375 2375
 
2376 2376
     return 0;
... ...
@@ -2388,8 +2388,8 @@ static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
2388 2388
             AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
2389 2389
             int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
2390 2390
             av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
2391
-            if (!sample || (url_is_streamed(s->pb) && current_sample->pos < sample->pos) ||
2392
-                (!url_is_streamed(s->pb) &&
2391
+            if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) ||
2392
+                (s->pb->seekable &&
2393 2393
                  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
2394 2394
                  ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
2395 2395
                   (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
... ...
@@ -2413,7 +2413,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
2413 2413
     sample = mov_find_next_sample(s, &st);
2414 2414
     if (!sample) {
2415 2415
         mov->found_mdat = 0;
2416
-        if (!url_is_streamed(s->pb) ||
2416
+        if (s->pb->seekable||
2417 2417
             mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
2418 2418
             url_feof(s->pb))
2419 2419
             return AVERROR_EOF;
... ...
@@ -1653,7 +1653,7 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
1653 1653
             return 0;
1654 1654
         }
1655 1655
 
1656
-    ret = url_open_dyn_buf(&pb_buf);
1656
+    ret = avio_open_dyn_buf(&pb_buf);
1657 1657
     if(ret < 0)
1658 1658
         return ret;
1659 1659
 
... ...
@@ -1684,7 +1684,7 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
1684 1684
         if (s->nb_chapters)
1685 1685
             mov_write_chpl_tag(pb_buf, s);
1686 1686
 
1687
-    if ((size = url_close_dyn_buf(pb_buf, &buf)) > 0) {
1687
+    if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) {
1688 1688
         avio_wb32(pb, size+8);
1689 1689
         ffio_wfourcc(pb, "udta");
1690 1690
         avio_write(pb, buf, size);
... ...
@@ -1948,7 +1948,7 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
1948 1948
     unsigned int samplesInChunk = 0;
1949 1949
     int size= pkt->size;
1950 1950
 
1951
-    if (url_is_streamed(s->pb)) return 0; /* Can't handle that */
1951
+    if (!s->pb->seekable) return 0; /* Can't handle that */
1952 1952
     if (!size) return 0; /* Discard 0 sized packets */
1953 1953
 
1954 1954
     if (enc->codec_id == CODEC_ID_AMR_NB) {
... ...
@@ -2083,7 +2083,7 @@ static int mov_write_header(AVFormatContext *s)
2083 2083
     MOVMuxContext *mov = s->priv_data;
2084 2084
     int i, hint_track = 0;
2085 2085
 
2086
-    if (url_is_streamed(s->pb)) {
2086
+    if (!s->pb->seekable) {
2087 2087
         av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
2088 2088
         return -1;
2089 2089
     }
... ...
@@ -23,6 +23,7 @@
23 23
 #include "libavutil/intreadwrite.h"
24 24
 #include "internal.h"
25 25
 #include "rtpenc_chain.h"
26
+#include "avio_internal.h"
26 27
 
27 28
 int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
28 29
 {
... ...
@@ -408,8 +409,8 @@ int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt,
408 408
 
409 409
     /* Fetch the output from the RTP muxer, open a new output buffer
410 410
      * for next time. */
411
-    size = url_close_dyn_buf(rtp_ctx->pb, &buf);
412
-    if ((ret = url_open_dyn_packet_buf(&rtp_ctx->pb,
411
+    size = avio_close_dyn_buf(rtp_ctx->pb, &buf);
412
+    if ((ret = ffio_open_dyn_packet_buf(&rtp_ctx->pb,
413 413
                                        RTP_MAX_PACKET_SIZE)) < 0)
414 414
         goto done;
415 415
 
... ...
@@ -417,14 +418,14 @@ int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt,
417 417
         goto done;
418 418
 
419 419
     /* Open a buffer for writing the hint */
420
-    if ((ret = url_open_dyn_buf(&hintbuf)) < 0)
420
+    if ((ret = avio_open_dyn_buf(&hintbuf)) < 0)
421 421
         goto done;
422 422
     av_init_packet(&hint_pkt);
423 423
     count = write_hint_packets(hintbuf, buf, size, trk, &hint_pkt.dts);
424 424
     av_freep(&buf);
425 425
 
426 426
     /* Write the hint data into the hint track */
427
-    hint_pkt.size = size = url_close_dyn_buf(hintbuf, &buf);
427
+    hint_pkt.size = size = avio_close_dyn_buf(hintbuf, &buf);
428 428
     hint_pkt.data = buf;
429 429
     hint_pkt.pts  = hint_pkt.dts;
430 430
     hint_pkt.stream_index = track_index;
... ...
@@ -448,7 +449,7 @@ void ff_mov_close_hinting(MOVTrack *track) {
448 448
         return;
449 449
     if (rtp_ctx->pb) {
450 450
         av_write_trailer(rtp_ctx);
451
-        url_close_dyn_buf(rtp_ctx->pb, &ptr);
451
+        avio_close_dyn_buf(rtp_ctx->pb, &ptr);
452 452
         av_free(ptr);
453 453
     }
454 454
     avformat_free_context(rtp_ctx);
... ...
@@ -96,7 +96,7 @@ static int id3v2_put_ttag(AVFormatContext *s, const char *str1, const char *str2
96 96
     uint8_t *pb;
97 97
     int (*put)(AVIOContext*, const char*);
98 98
     AVIOContext *dyn_buf;
99
-    if (url_open_dyn_buf(&dyn_buf) < 0)
99
+    if (avio_open_dyn_buf(&dyn_buf) < 0)
100 100
         return AVERROR(ENOMEM);
101 101
 
102 102
     /* check if the strings are ASCII-only and use UTF16 only if
... ...
@@ -115,7 +115,7 @@ static int id3v2_put_ttag(AVFormatContext *s, const char *str1, const char *str2
115 115
     put(dyn_buf, str1);
116 116
     if (str2)
117 117
         put(dyn_buf, str2);
118
-    len = url_close_dyn_buf(dyn_buf, &pb);
118
+    len = avio_close_dyn_buf(dyn_buf, &pb);
119 119
 
120 120
     avio_wb32(s->pb, tag);
121 121
     id3v2_put_size(s, len);
... ...
@@ -93,7 +93,7 @@ static int mpc_read_header(AVFormatContext *s, AVFormatParameters *ap)
93 93
     st->duration = c->fcount;
94 94
 
95 95
     /* try to read APE tags */
96
-    if (!url_is_streamed(s->pb)) {
96
+    if (s->pb->seekable) {
97 97
         int64_t pos = avio_tell(s->pb);
98 98
         ff_ape_parse_tag(s);
99 99
         if (!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
... ...
@@ -403,7 +403,7 @@ static int mpegps_read_pes_header(AVFormatContext *s,
403 403
         int i;
404 404
         for(i=0; i<s->nb_streams; i++){
405 405
             if(startcode == s->streams[i]->id &&
406
-               !url_is_streamed(s->pb) /* index useless on streams anyway */) {
406
+               s->pb->seekable /* index useless on streams anyway */) {
407 407
                 ff_reduce_index(s, i);
408 408
                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
409 409
             }
... ...
@@ -1784,7 +1784,7 @@ static int mxf_write_footer(AVFormatContext *s)
1784 1784
     mxf_write_klv_fill(s);
1785 1785
     mxf_write_random_index_pack(s);
1786 1786
 
1787
-    if (!url_is_streamed(s->pb)) {
1787
+    if (s->pb->seekable) {
1788 1788
         avio_seek(pb, 0, SEEK_SET);
1789 1789
         if (mxf->edit_unit_byte_count) {
1790 1790
             mxf_write_partition(s, 1, 2, header_closed_partition_key, 1);
... ...
@@ -653,7 +653,7 @@ static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
653 653
 
654 654
     s->data_offset= pos-8;
655 655
 
656
-    if(!url_is_streamed(bc)){
656
+    if(bc->seekable){
657 657
         int64_t orig_pos= avio_tell(bc);
658 658
         find_and_decode_index(nut);
659 659
         avio_seek(bc, orig_pos, SEEK_SET);
... ...
@@ -281,7 +281,7 @@ static inline void put_s_trace(AVIOContext *bc, int64_t v, char *file, char *fun
281 281
 //FIXME remove calculate_checksum
282 282
 static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, int calculate_checksum, uint64_t startcode){
283 283
     uint8_t *dyn_buf=NULL;
284
-    int dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf);
284
+    int dyn_size= avio_close_dyn_buf(dyn_bc, &dyn_buf);
285 285
     int forw_ptr= dyn_size + 4*calculate_checksum;
286 286
 
287 287
     if(forw_ptr > 4096)
... ...
@@ -436,7 +436,7 @@ static int write_globalinfo(NUTContext *nut, AVIOContext *bc){
436 436
     AVIOContext *dyn_bc;
437 437
     uint8_t *dyn_buf=NULL;
438 438
     int count=0, dyn_size;
439
-    int ret = url_open_dyn_buf(&dyn_bc);
439
+    int ret = avio_open_dyn_buf(&dyn_bc);
440 440
     if(ret < 0)
441 441
         return ret;
442 442
 
... ...
@@ -450,7 +450,7 @@ static int write_globalinfo(NUTContext *nut, AVIOContext *bc){
450 450
 
451 451
     ff_put_v(bc, count);
452 452
 
453
-    dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf);
453
+    dyn_size= avio_close_dyn_buf(dyn_bc, &dyn_buf);
454 454
     avio_write(bc, dyn_buf, dyn_size);
455 455
     av_free(dyn_buf);
456 456
     return 0;
... ...
@@ -462,7 +462,7 @@ static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
462 462
     AVIOContext *dyn_bc;
463 463
     uint8_t *dyn_buf=NULL;
464 464
     int count=0, dyn_size, i;
465
-    int ret = url_open_dyn_buf(&dyn_bc);
465
+    int ret = avio_open_dyn_buf(&dyn_bc);
466 466
     if(ret < 0)
467 467
         return ret;
468 468
 
... ...
@@ -470,7 +470,7 @@ static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
470 470
         if (st->disposition & ff_nut_dispositions[i].flag)
471 471
             count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str);
472 472
     }
473
-    dyn_size = url_close_dyn_buf(dyn_bc, &dyn_buf);
473
+    dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
474 474
 
475 475
     if (count) {
476 476
         ff_put_v(bc, stream_id + 1); //stream_id_plus1
... ...
@@ -495,7 +495,7 @@ static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
495 495
     AVChapter *ch    = nut->avf->chapters[id];
496 496
     int ret, dyn_size, count = 0;
497 497
 
498
-    ret = url_open_dyn_buf(&dyn_bc);
498
+    ret = avio_open_dyn_buf(&dyn_bc);
499 499
     if (ret < 0)
500 500
         return ret;
501 501
 
... ...
@@ -509,7 +509,7 @@ static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
509 509
 
510 510
     ff_put_v(bc, count);
511 511
 
512
-    dyn_size = url_close_dyn_buf(dyn_bc, &dyn_buf);
512
+    dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
513 513
     avio_write(bc, dyn_buf, dyn_size);
514 514
     av_freep(&dyn_buf);
515 515
     return 0;
... ...
@@ -522,14 +522,14 @@ static int write_headers(AVFormatContext *avctx, AVIOContext *bc){
522 522
 
523 523
     ff_metadata_conv_ctx(avctx, ff_nut_metadata_conv, NULL);
524 524
 
525
-    ret = url_open_dyn_buf(&dyn_bc);
525
+    ret = avio_open_dyn_buf(&dyn_bc);
526 526
     if(ret < 0)
527 527
         return ret;
528 528
     write_mainheader(nut, dyn_bc);
529 529
     put_packet(nut, bc, dyn_bc, 1, MAIN_STARTCODE);
530 530
 
531 531
     for (i=0; i < nut->avf->nb_streams; i++){
532
-        ret = url_open_dyn_buf(&dyn_bc);
532
+        ret = avio_open_dyn_buf(&dyn_bc);
533 533
         if(ret < 0)
534 534
             return ret;
535 535
         if ((ret = write_streamheader(avctx, dyn_bc, nut->avf->streams[i], i)) < 0)
... ...
@@ -537,14 +537,14 @@ static int write_headers(AVFormatContext *avctx, AVIOContext *bc){
537 537
         put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE);
538 538
     }
539 539
 
540
-    ret = url_open_dyn_buf(&dyn_bc);
540
+    ret = avio_open_dyn_buf(&dyn_bc);
541 541
     if(ret < 0)
542 542
         return ret;
543 543
     write_globalinfo(nut, dyn_bc);
544 544
     put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
545 545
 
546 546
     for (i = 0; i < nut->avf->nb_streams; i++) {
547
-        ret = url_open_dyn_buf(&dyn_bc);
547
+        ret = avio_open_dyn_buf(&dyn_bc);
548 548
         if(ret < 0)
549 549
             return ret;
550 550
         ret = write_streaminfo(nut, dyn_bc, i);
... ...
@@ -554,19 +554,19 @@ static int write_headers(AVFormatContext *avctx, AVIOContext *bc){
554 554
             put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
555 555
         else {
556 556
             uint8_t* buf;
557
-            url_close_dyn_buf(dyn_bc, &buf);
557
+            avio_close_dyn_buf(dyn_bc, &buf);
558 558
             av_free(buf);
559 559
         }
560 560
     }
561 561
 
562 562
     for (i = 0; i < nut->avf->nb_chapters; i++) {
563
-        ret = url_open_dyn_buf(&dyn_bc);
563
+        ret = avio_open_dyn_buf(&dyn_bc);
564 564
         if (ret < 0)
565 565
             return ret;
566 566
         ret = write_chapter(nut, dyn_bc, i);
567 567
         if (ret < 0) {
568 568
             uint8_t *buf;
569
-            url_close_dyn_buf(dyn_bc, &buf);
569
+            avio_close_dyn_buf(dyn_bc, &buf);
570 570
             av_freep(&buf);
571 571
             return ret;
572 572
         }
... ...
@@ -728,7 +728,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){
728 728
                          NULL);
729 729
 
730 730
         nut->last_syncpoint_pos= avio_tell(bc);
731
-        ret = url_open_dyn_buf(&dyn_bc);
731
+        ret = avio_open_dyn_buf(&dyn_bc);
732 732
         if(ret < 0)
733 733
             return ret;
734 734
         put_tt(nut, nus->time_base, dyn_bc, pkt->dts);
... ...
@@ -455,7 +455,7 @@ ogg_get_length (AVFormatContext * s)
455 455
     int i;
456 456
     int64_t size, end;
457 457
 
458
-    if(url_is_streamed(s->pb))
458
+    if(!s->pb->seekable)
459 459
         return 0;
460 460
 
461 461
 // already set
... ...
@@ -82,7 +82,7 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
82 82
     int ret, size;
83 83
     uint8_t *buf;
84 84
 
85
-    ret = url_open_dyn_buf(&pb);
85
+    ret = avio_open_dyn_buf(&pb);
86 86
     if (ret < 0)
87 87
         return ret;
88 88
     ffio_init_checksum(pb, ff_crc04C11DB7_update, 0);
... ...
@@ -101,7 +101,7 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
101 101
     ogg_update_checksum(s, pb, crc_offset);
102 102
     avio_flush(pb);
103 103
 
104
-    size = url_close_dyn_buf(pb, &buf);
104
+    size = avio_close_dyn_buf(pb, &buf);
105 105
     if (size < 0)
106 106
         return size;
107 107
 
... ...
@@ -177,7 +177,7 @@ static int r3d_read_header(AVFormatContext *s, AVFormatParameters *ap)
177 177
 
178 178
     s->data_offset = avio_tell(s->pb);
179 179
     av_dlog(s, "data offset %#llx\n", s->data_offset);
180
-    if (url_is_streamed(s->pb))
180
+    if (!s->pb->seekable)
181 181
         return 0;
182 182
     // find REOB/REOF/REOS to load index
183 183
     avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET);
... ...
@@ -481,7 +481,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
481 481
 
482 482
     if (!data_off)
483 483
         data_off = avio_tell(pb) - 18;
484
-    if (indx_off && !url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
484
+    if (indx_off && pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
485 485
         avio_seek(pb, indx_off, SEEK_SET) >= 0) {
486 486
         rm_read_index(s);
487 487
         avio_seek(pb, data_off + 18, SEEK_SET);
... ...
@@ -118,7 +118,7 @@ static int rv10_write_header(AVFormatContext *ctx,
118 118
     avio_wb32(s, 0);           /* data offset : will be patched after */
119 119
     avio_wb16(s, ctx->nb_streams);    /* num streams */
120 120
     flags = 1 | 2; /* save allowed & perfect play */
121
-    if (url_is_streamed(s))
121
+    if (!s->seekable)
122 122
         flags |= 4; /* live broadcast */
123 123
     avio_wb16(s, flags);
124 124
 
... ...
@@ -170,7 +170,7 @@ static int rv10_write_header(AVFormatContext *ctx,
170 170
         avio_wb32(s, 0);           /* start time */
171 171
         avio_wb32(s, BUFFER_DURATION);           /* preroll */
172 172
         /* duration */
173
-        if (url_is_streamed(s) || !stream->total_frames)
173
+        if (!s->seekable || !stream->total_frames)
174 174
             avio_wb32(s, (int)(3600 * 1000));
175 175
         else
176 176
             avio_wb32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
... ...
@@ -434,7 +434,7 @@ static int rm_write_trailer(AVFormatContext *s)
434 434
     int data_size, index_pos, i;
435 435
     AVIOContext *pb = s->pb;
436 436
 
437
-    if (!url_is_streamed(s->pb)) {
437
+    if (s->pb->seekable) {
438 438
         /* end of file: finish to write header */
439 439
         index_pos = avio_tell(pb);
440 440
         data_size = index_pos - rm->data_pos;
... ...
@@ -38,7 +38,7 @@ static int rso_write_header(AVFormatContext *s)
38 38
         return AVERROR_INVALIDDATA;
39 39
     }
40 40
 
41
-    if (url_is_streamed(s->pb)) {
41
+    if (!s->pb->seekable) {
42 42
         av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
43 43
         return AVERROR_INVALIDDATA;
44 44
     }
... ...
@@ -41,7 +41,7 @@
41 41
          buffer to 'rtp_write_packet' contains all the packets for ONE
42 42
          frame. Each packet should have a four byte header containing
43 43
          the length in big endian format (same trick as
44
-         'url_open_dyn_packet_buf')
44
+         'ffio_open_dyn_packet_buf')
45 45
 */
46 46
 
47 47
 static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {
... ...
@@ -264,7 +264,7 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
264 264
         return -1;
265 265
     s->last_octet_count = s->octet_count;
266 266
 
267
-    if (url_open_dyn_buf(&pb) < 0)
267
+    if (avio_open_dyn_buf(&pb) < 0)
268 268
         return -1;
269 269
 
270 270
     // Receiver Report
... ...
@@ -321,7 +321,7 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
321 321
     }
322 322
 
323 323
     avio_flush(pb);
324
-    len = url_close_dyn_buf(pb, &buf);
324
+    len = avio_close_dyn_buf(pb, &buf);
325 325
     if ((len > 0) && buf) {
326 326
         int result;
327 327
         av_dlog(s->ic, "sending %d bytes of RR\n", len);
... ...
@@ -339,7 +339,7 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
339 339
     int len;
340 340
 
341 341
     /* Send a small RTP packet */
342
-    if (url_open_dyn_buf(&pb) < 0)
342
+    if (avio_open_dyn_buf(&pb) < 0)
343 343
         return;
344 344
 
345 345
     avio_w8(pb, (RTP_VERSION << 6));
... ...
@@ -349,13 +349,13 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
349 349
     avio_wb32(pb, 0); /* SSRC */
350 350
 
351 351
     avio_flush(pb);
352
-    len = url_close_dyn_buf(pb, &buf);
352
+    len = avio_close_dyn_buf(pb, &buf);
353 353
     if ((len > 0) && buf)
354 354
         url_write(rtp_handle, buf, len);
355 355
     av_free(buf);
356 356
 
357 357
     /* Send a minimal RTCP RR */
358
-    if (url_open_dyn_buf(&pb) < 0)
358
+    if (avio_open_dyn_buf(&pb) < 0)
359 359
         return;
360 360
 
361 361
     avio_w8(pb, (RTP_VERSION << 6));
... ...
@@ -364,7 +364,7 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
364 364
     avio_wb32(pb, 0); /* our own SSRC */
365 365
 
366 366
     avio_flush(pb);
367
-    len = url_close_dyn_buf(pb, &buf);
367
+    len = avio_close_dyn_buf(pb, &buf);
368 368
     if ((len > 0) && buf)
369 369
         url_write(rtp_handle, buf, len);
370 370
     av_free(buf);
... ...
@@ -203,12 +203,12 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
203 203
                  */
204 204
                 if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) {
205 205
                     uint8_t *p;
206
-                    url_close_dyn_buf(asf->pktbuf, &p);
206
+                    avio_close_dyn_buf(asf->pktbuf, &p);
207 207
                     asf->pktbuf = NULL;
208 208
                     av_free(p);
209 209
                 }
210 210
                 if (!len_off && !asf->pktbuf &&
211
-                    (res = url_open_dyn_buf(&asf->pktbuf)) < 0)
211
+                    (res = avio_open_dyn_buf(&asf->pktbuf)) < 0)
212 212
                     return res;
213 213
                 if (!asf->pktbuf)
214 214
                     return AVERROR(EIO);
... ...
@@ -217,7 +217,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
217 217
                 avio_skip(pb, len - off);
218 218
                 if (!(flags & RTP_FLAG_MARKER))
219 219
                     return -1;
220
-                out_len     = url_close_dyn_buf(asf->pktbuf, &asf->buf);
220
+                out_len     = avio_close_dyn_buf(asf->pktbuf, &asf->buf);
221 221
                 asf->pktbuf = NULL;
222 222
             } else {
223 223
                 /**
... ...
@@ -272,7 +272,7 @@ static void asfrtp_free_context(PayloadContext *asf)
272 272
 {
273 273
     if (asf->pktbuf) {
274 274
         uint8_t *p = NULL;
275
-        url_close_dyn_buf(asf->pktbuf, &p);
275
+        avio_close_dyn_buf(asf->pktbuf, &p);
276 276
         asf->pktbuf = NULL;
277 277
         av_free(p);
278 278
     }
... ...
@@ -43,7 +43,7 @@ static void latm_free_context(PayloadContext *data)
43 43
         return;
44 44
     if (data->dyn_buf) {
45 45
         uint8_t *p;
46
-        url_close_dyn_buf(data->dyn_buf, &p);
46
+        avio_close_dyn_buf(data->dyn_buf, &p);
47 47
         av_free(p);
48 48
     }
49 49
     av_free(data->buf);
... ...
@@ -60,12 +60,12 @@ static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
60 60
         if (!data->dyn_buf || data->timestamp != *timestamp) {
61 61
             av_freep(&data->buf);
62 62
             if (data->dyn_buf)
63
-                url_close_dyn_buf(data->dyn_buf, &data->buf);
63
+                avio_close_dyn_buf(data->dyn_buf, &data->buf);
64 64
             data->dyn_buf = NULL;
65 65
             av_freep(&data->buf);
66 66
 
67 67
             data->timestamp = *timestamp;
68
-            if ((ret = url_open_dyn_buf(&data->dyn_buf)) < 0)
68
+            if ((ret = avio_open_dyn_buf(&data->dyn_buf)) < 0)
69 69
                 return ret;
70 70
         }
71 71
         avio_write(data->dyn_buf, buf, len);
... ...
@@ -73,7 +73,7 @@ static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
73 73
         if (!(flags & RTP_FLAG_MARKER))
74 74
             return AVERROR(EAGAIN);
75 75
         av_free(data->buf);
76
-        data->len = url_close_dyn_buf(data->dyn_buf, &data->buf);
76
+        data->len = avio_close_dyn_buf(data->dyn_buf, &data->buf);
77 77
         data->dyn_buf = NULL;
78 78
         data->pos = 0;
79 79
     }
... ...
@@ -83,10 +83,10 @@ static int svq3_parse_packet (AVFormatContext *s, PayloadContext *sv,
83 83
 
84 84
         if (sv->pktbuf) {
85 85
             uint8_t *tmp;
86
-            url_close_dyn_buf(sv->pktbuf, &tmp);
86
+            avio_close_dyn_buf(sv->pktbuf, &tmp);
87 87
             av_free(tmp);
88 88
         }
89
-        if ((res = url_open_dyn_buf(&sv->pktbuf)) < 0)
89
+        if ((res = avio_open_dyn_buf(&sv->pktbuf)) < 0)
90 90
             return res;
91 91
         sv->timestamp   = *timestamp;
92 92
     }
... ...
@@ -100,7 +100,7 @@ static int svq3_parse_packet (AVFormatContext *s, PayloadContext *sv,
100 100
         av_init_packet(pkt);
101 101
         pkt->stream_index = st->index;
102 102
         *timestamp        = sv->timestamp;
103
-        pkt->size         = url_close_dyn_buf(sv->pktbuf, &pkt->data);
103
+        pkt->size         = avio_close_dyn_buf(sv->pktbuf, &pkt->data);
104 104
         pkt->destruct     = av_destruct_packet;
105 105
         sv->pktbuf        = NULL;
106 106
         return 0;
... ...
@@ -118,7 +118,7 @@ static void svq3_extradata_free(PayloadContext *sv)
118 118
 {
119 119
     if (sv->pktbuf) {
120 120
         uint8_t *buf;
121
-        url_close_dyn_buf(sv->pktbuf, &buf);
121
+        avio_close_dyn_buf(sv->pktbuf, &buf);
122 122
         av_free(buf);
123 123
     }
124 124
     av_free(sv);
... ...
@@ -41,7 +41,7 @@ static void prepare_packet(AVPacket *pkt, PayloadContext *vp8, int stream)
41 41
     av_init_packet(pkt);
42 42
     pkt->stream_index = stream;
43 43
     pkt->flags        = vp8->is_keyframe ? AV_PKT_FLAG_KEY : 0;
44
-    pkt->size         = url_close_dyn_buf(vp8->data, &pkt->data);
44
+    pkt->size         = avio_close_dyn_buf(vp8->data, &pkt->data);
45 45
     pkt->destruct     = av_destruct_packet;
46 46
     vp8->data         = NULL;
47 47
 }
... ...
@@ -85,7 +85,7 @@ static int vp8_handle_packet(AVFormatContext *ctx,
85 85
             // that for the next av_get_packet call
86 86
             ret = end_packet ? 1 : 0;
87 87
         }
88
-        if ((res = url_open_dyn_buf(&vp8->data)) < 0)
88
+        if ((res = avio_open_dyn_buf(&vp8->data)) < 0)
89 89
             return res;
90 90
         vp8->is_keyframe = *buf & 1;
91 91
         vp8->timestamp   = ts;
... ...
@@ -138,7 +138,7 @@ static void vp8_free_context(PayloadContext *vp8)
138 138
 {
139 139
     if (vp8->data) {
140 140
         uint8_t *tmp;
141
-        url_close_dyn_buf(vp8->data, &tmp);
141
+        avio_close_dyn_buf(vp8->data, &tmp);
142 142
         av_free(tmp);
143 143
     }
144 144
     av_free(vp8);
... ...
@@ -57,7 +57,7 @@ static inline void free_fragment_if_needed(PayloadContext * data)
57 57
 {
58 58
     if (data->fragment) {
59 59
         uint8_t* p;
60
-        url_close_dyn_buf(data->fragment, &p);
60
+        avio_close_dyn_buf(data->fragment, &p);
61 61
         av_free(p);
62 62
         data->fragment = NULL;
63 63
     }
... ...
@@ -176,7 +176,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
176 176
         // end packet has been lost somewhere, so drop buffered data
177 177
         free_fragment_if_needed(data);
178 178
 
179
-        if((res = url_open_dyn_buf(&data->fragment)) < 0)
179
+        if((res = avio_open_dyn_buf(&data->fragment)) < 0)
180 180
             return res;
181 181
 
182 182
         avio_write(data->fragment, buf, pkt_len);
... ...
@@ -203,7 +203,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
203 203
         if (fragmented == 3) {
204 204
             // end of xiph data packet
205 205
             av_init_packet(pkt);
206
-            pkt->size = url_close_dyn_buf(data->fragment, &pkt->data);
206
+            pkt->size = avio_close_dyn_buf(data->fragment, &pkt->data);
207 207
 
208 208
             if (pkt->size < 0) {
209 209
                 av_log(ctx, AV_LOG_ERROR,
... ...
@@ -20,7 +20,9 @@
20 20
  */
21 21
 
22 22
 #include "avformat.h"
23
+#include "avio_internal.h"
23 24
 #include "rtpenc_chain.h"
25
+#include "avio_internal.h"
24 26
 
25 27
 AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
26 28
                                        URLContext *handle, int packet_size)
... ...
@@ -53,9 +55,9 @@ AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
53 53
     avcodec_copy_context(rtpctx->streams[0]->codec, st->codec);
54 54
 
55 55
     if (handle) {
56
-        url_fdopen(&rtpctx->pb, handle);
56
+        ffio_fdopen(&rtpctx->pb, handle);
57 57
     } else
58
-        url_open_dyn_packet_buf(&rtpctx->pb, packet_size);
58
+        ffio_open_dyn_packet_buf(&rtpctx->pb, packet_size);
59 59
     ret = av_write_header(rtpctx);
60 60
 
61 61
     if (ret) {
... ...
@@ -63,7 +65,7 @@ AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
63 63
             avio_close(rtpctx->pb);
64 64
         } else {
65 65
             uint8_t *ptr;
66
-            url_close_dyn_buf(rtpctx->pb, &ptr);
66
+            avio_close_dyn_buf(rtpctx->pb, &ptr);
67 67
             av_free(ptr);
68 68
         }
69 69
         avformat_free_context(rtpctx);
... ...
@@ -495,7 +495,7 @@ void ff_rtsp_undo_setup(AVFormatContext *s)
495 495
                 av_write_trailer(rtpctx);
496 496
                 if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
497 497
                     uint8_t *ptr;
498
-                    url_close_dyn_buf(rtpctx->pb, &ptr);
498
+                    avio_close_dyn_buf(rtpctx->pb, &ptr);
499 499
                     av_free(ptr);
500 500
                 } else {
501 501
                     avio_close(rtpctx->pb);
... ...
@@ -29,6 +29,7 @@
29 29
 #include "os_support.h"
30 30
 #include "rtsp.h"
31 31
 #include "internal.h"
32
+#include "avio_internal.h"
32 33
 #include "libavutil/intreadwrite.h"
33 34
 #include "libavutil/avstring.h"
34 35
 
... ...
@@ -135,14 +136,14 @@ static int tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
135 135
     int size;
136 136
     uint8_t *interleave_header, *interleaved_packet;
137 137
 
138
-    size = url_close_dyn_buf(rtpctx->pb, &buf);
138
+    size = avio_close_dyn_buf(rtpctx->pb, &buf);
139 139
     ptr = buf;
140 140
     while (size > 4) {
141 141
         uint32_t packet_len = AV_RB32(ptr);
142 142
         int id;
143 143
         /* The interleaving header is exactly 4 bytes, which happens to be
144 144
          * the same size as the packet length header from
145
-         * url_open_dyn_packet_buf. So by writing the interleaving header
145
+         * ffio_open_dyn_packet_buf. So by writing the interleaving header
146 146
          * over these bytes, we get a consecutive interleaved packet
147 147
          * that can be written in one call. */
148 148
         interleaved_packet = interleave_header = ptr;
... ...
@@ -162,7 +163,7 @@ static int tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
162 162
         size -= packet_len;
163 163
     }
164 164
     av_free(buf);
165
-    url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
165
+    ffio_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
166 166
     return 0;
167 167
 }
168 168
 
... ...
@@ -96,7 +96,7 @@ static int sox_write_trailer(AVFormatContext *s)
96 96
     AVIOContext *pb = s->pb;
97 97
     AVCodecContext *enc = s->streams[0]->codec;
98 98
 
99
-    if (!url_is_streamed(s->pb)) {
99
+    if (s->pb->seekable) {
100 100
         /* update number of samples */
101 101
         int64_t file_size = avio_tell(pb);
102 102
         int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;
... ...
@@ -492,7 +492,7 @@ static int swf_write_trailer(AVFormatContext *s)
492 492
     avio_flush(s->pb);
493 493
 
494 494
     /* patch file size and number of frames if not streamed */
495
-    if (!url_is_streamed(s->pb) && video_enc) {
495
+    if (s->pb->seekable && video_enc) {
496 496
         file_size = avio_tell(pb);
497 497
         avio_seek(pb, 4, SEEK_SET);
498 498
         avio_wl32(pb, file_size);
... ...
@@ -88,7 +88,7 @@ static int read_header(AVFormatContext *avctx,
88 88
     /* simulate tty display speed */
89 89
     s->chars_per_frame = FFMAX(av_q2d(st->time_base) * (ap->sample_rate ? ap->sample_rate : LINE_RATE), 1);
90 90
 
91
-    if (!url_is_streamed(avctx->pb)) {
91
+    if (avctx->pb->seekable) {
92 92
         s->fsize = avio_size(avctx->pb);
93 93
         st->duration = (s->fsize + s->chars_per_frame - 1) / s->chars_per_frame;
94 94
 
... ...
@@ -2037,7 +2037,7 @@ static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2037 2037
 
2038 2038
     if ((!strcmp(ic->iformat->name, "mpeg") ||
2039 2039
          !strcmp(ic->iformat->name, "mpegts")) &&
2040
-        file_size && !url_is_streamed(ic->pb)) {
2040
+        file_size && ic->pb->seekable) {
2041 2041
         /* get accurate estimate from the PTSes */
2042 2042
         av_estimate_timings_from_pts(ic, old_offset);
2043 2043
     } else if (av_has_duration(ic)) {
... ...
@@ -73,7 +73,7 @@ static int vc1test_write_trailer(AVFormatContext *s)
73 73
     RCVContext *ctx = s->priv_data;
74 74
     AVIOContext *pb = s->pb;
75 75
 
76
-    if (!url_is_streamed(s->pb)) {
76
+    if (s->pb->seekable) {
77 77
         avio_seek(pb, 0, SEEK_SET);
78 78
         avio_wl24(pb, ctx->frames);
79 79
         avio_flush(pb);
... ...
@@ -78,7 +78,7 @@ voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
78 78
             return AVERROR(EIO);
79 79
         voc->remaining_size = avio_rl24(pb);
80 80
         if (!voc->remaining_size) {
81
-            if (url_is_streamed(s->pb))
81
+            if (!s->pb->seekable)
82 82
                 return AVERROR(EIO);
83 83
             voc->remaining_size = avio_size(pb) - avio_tell(pb);
84 84
         }
... ...
@@ -57,7 +57,7 @@ static int wav_write_header(AVFormatContext *s)
57 57
     ff_end_tag(pb, fmt);
58 58
 
59 59
     if (s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */
60
-        && !url_is_streamed(s->pb)) {
60
+        && s->pb->seekable) {
61 61
         fact = ff_start_tag(pb, "fact");
62 62
         avio_wl32(pb, 0);
63 63
         ff_end_tag(pb, fact);
... ...
@@ -97,7 +97,7 @@ static int wav_write_trailer(AVFormatContext *s)
97 97
 
98 98
     avio_flush(pb);
99 99
 
100
-    if (!url_is_streamed(s->pb)) {
100
+    if (s->pb->seekable) {
101 101
         ff_end_tag(pb, wav->data);
102 102
 
103 103
         /* update file size */
... ...
@@ -121,7 +121,7 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb, int appen
121 121
     }
122 122
     if((rate == -1 || !chan) && !wc->block_parsed){
123 123
         int64_t block_end = avio_tell(pb) + wc->blksize - 24;
124
-        if(url_is_streamed(pb)){
124
+        if(!pb->seekable){
125 125
             av_log(ctx, AV_LOG_ERROR, "Cannot determine additional parameters\n");
126 126
             return -1;
127 127
         }
... ...
@@ -223,7 +223,7 @@ static int wv_read_header(AVFormatContext *s,
223 223
     st->start_time = 0;
224 224
     st->duration = wc->samples;
225 225
 
226
-    if(!url_is_streamed(s->pb)) {
226
+    if(s->pb->seekable) {
227 227
         int64_t cur = avio_tell(s->pb);
228 228
         ff_ape_parse_tag(s);
229 229
         if(!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
... ...
@@ -1,2 +1,2 @@
1
-346073c97eada69330f61e103a170ca1 *./tests/data/acodec/ac3.rm
1
+408f47ee5a60866fc751f7bc2314cbd6 *./tests/data/acodec/ac3.rm
2 2
 98751 ./tests/data/acodec/ac3.rm
... ...
@@ -1,2 +1,2 @@
1
-7b7ede9548a09346675edad36acfbf19 *./tests/data/lavf/lavf.rm
1
+da74fe749c2eb21bbead7de81d2f3078 *./tests/data/lavf/lavf.rm
2 2
 346706 ./tests/data/lavf/lavf.rm