eden-emu/FFmpeg
19
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote branch 'qatar/master'

Browse source 
* 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>
This commit is contained in:
Michael Niedermayer 2011-04-04 02:15:12 +02:00
commit 2cae9809e2
74 changed files with 833 additions and 637 deletions
Download patch file Download diff file Expand all files Collapse all files

2
configure vendored
View file

@ -3314,7 +3314,7 @@ SLIB_CREATE_DEF_CMD=${SLIB_CREATE_DEF_CMD}
SLIB_EXTRA_CMD=${SLIB_EXTRA_CMD} SLIB_EXTRA_CMD=${SLIB_EXTRA_CMD}
SLIB_INSTALL_EXTRA_CMD=${SLIB_INSTALL_EXTRA_CMD} SLIB_INSTALL_EXTRA_CMD=${SLIB_INSTALL_EXTRA_CMD}
SLIB_UNINSTALL_EXTRA_CMD=${SLIB_UNINSTALL_EXTRA_CMD} SLIB_UNINSTALL_EXTRA_CMD=${SLIB_UNINSTALL_EXTRA_CMD}
SAMPLES=${samples:-\$(FATE_SAMPLES)} SAMPLES:=${samples:-\$(FATE_SAMPLES)}
EOF EOF
get_version(){ get_version(){

40
doc/APIchanges
View file

@ -12,6 +12,46 @@ libavutil: 2009-03-08
API changes, most recent first: API changes, most recent first:
2011-04-03 - lavf 52.105.0 - avio.h
Large-scale renaming/deprecating of AVIOContext-related functions:
724f6a0 deprecate url_fdopen
403ee83 deprecate url_open_dyn_packet_buf
6dc7d80 rename url_close_dyn_buf -> avio_close_dyn_buf
b92c545 rename url_open_dyn_buf -> avio_open_dyn_buf
8978fed introduce an AVIOContext.seekable field as a replacement for
AVIOContext.is_streamed and url_is_streamed()
b64030f deprecate get_checksum()
4c4427a deprecate init_checksum()
4ec153b deprecate udp_set_remote_url/get_local_port
933e90a deprecate av_url_read_fseek/fpause
8d9769a deprecate url_fileno
b7f2fdd rename put_flush_packet -> avio_flush
35f1023 deprecate url_close_buf
83fddae deprecate url_open_buf
d9d86e0 rename url_fprintf -> avio_printf
59f65d9 deprecate url_setbufsize
3e68b3b deprecate url_ferror
66e5b1d deprecate url_feof
e8bb2e2 deprecate url_fget_max_packet_size
76aa876 rename url_fsize -> avio_size
e519753 deprecate url_fgetc
655e45e deprecate url_fgets
a2704c9 rename url_ftell -> avio_tell
e16ead0 deprecate get_strz() in favor of avio_get_str
0300db8,2af07d3 rename url_fskip -> avio_skip
6b4aa5d rename url_fseek -> avio_seek
61840b4 deprecate put_tag
22a3212 rename url_fopen/fclose -> avio_open/close.
0ac8e2b deprecate put_nbyte
77eb550 rename put_byte -> avio_w8
put_[b/l]e<type> -> avio_w[b/l]<type>
put_buffer -> avio_write
b7effd4 rename get_byte -> avio_r8,
get_[b/l]e<type> -> avio_r[b/l]<type>
get_buffer -> avio_read
b3db9ce deprecate get_partial_buffer
8d9ac96 rename av_alloc_put_byte -> avio_alloc_context
2011-03-25 - 34b47d7 - lavc 52.115.0 - AVCodecContext.audio_service_type 2011-03-25 - 34b47d7 - lavc 52.115.0 - AVCodecContext.audio_service_type
Add audio_service_type field to AVCodecContext. Add audio_service_type field to AVCodecContext.

44
ffserver.c
View file

@ -33,6 +33,8 @@
#include "libavformat/os_support.h" #include "libavformat/os_support.h"
#include "libavformat/rtpdec.h" #include "libavformat/rtpdec.h"
#include "libavformat/rtsp.h" #include "libavformat/rtsp.h"
// XXX for ffio_open_dyn_packet_buffer, to be removed
#include "libavformat/avio_internal.h"
#include "libavutil/avstring.h" #include "libavutil/avstring.h"
#include "libavutil/lfg.h" #include "libavutil/lfg.h"
#include "libavutil/random_seed.h" #include "libavutil/random_seed.h"
@ -869,10 +871,10 @@ static void close_connection(HTTPContext *c)
if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) { if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
if (ctx->oformat) { if (ctx->oformat) {
/* prepare header */ /* prepare header */
if (url_open_dyn_buf(&ctx->pb) >= 0) { if (avio_open_dyn_buf(&ctx->pb) >= 0) {
av_write_trailer(ctx); av_write_trailer(ctx);
av_freep(&c->pb_buffer); av_freep(&c->pb_buffer);
url_close_dyn_buf(ctx->pb, &c->pb_buffer); avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
} }
} }
} }
@ -1873,7 +1875,7 @@ static void compute_status(HTTPContext *c)
int i, len; int i, len;
AVIOContext *pb; AVIOContext *pb;
if (url_open_dyn_buf(&pb) < 0) { if (avio_open_dyn_buf(&pb) < 0) {
/* XXX: return an error ? */ /* XXX: return an error ? */
c->buffer_ptr = c->buffer; c->buffer_ptr = c->buffer;
c->buffer_end = c->buffer; c->buffer_end = c->buffer;
@ -2101,7 +2103,7 @@ static void compute_status(HTTPContext *c)
avio_printf(pb, "<hr size=1 noshade>Generated at %s", p); avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
avio_printf(pb, "</body>\n</html>\n"); avio_printf(pb, "</body>\n</html>\n");
len = url_close_dyn_buf(pb, &c->pb_buffer); len = avio_close_dyn_buf(pb, &c->pb_buffer);
c->buffer_ptr = c->pb_buffer; c->buffer_ptr = c->pb_buffer;
c->buffer_end = c->pb_buffer + len; c->buffer_end = c->pb_buffer + len;
} }
@ -2256,11 +2258,11 @@ static int http_prepare_data(HTTPContext *c)
c->got_key_frame = 0; c->got_key_frame = 0;
/* prepare header and save header data in a stream */ /* prepare header and save header data in a stream */
if (url_open_dyn_buf(&c->fmt_ctx.pb) < 0) { if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
/* XXX: potential leak */ /* XXX: potential leak */
return -1; return -1;
} }
c->fmt_ctx.pb->is_streamed = 1; c->fmt_ctx.pb->seekable = 0;
/* /*
* HACK to avoid mpeg ps muxer to spit many underflow errors * HACK to avoid mpeg ps muxer to spit many underflow errors
@ -2277,7 +2279,7 @@ static int http_prepare_data(HTTPContext *c)
} }
av_metadata_free(&c->fmt_ctx.metadata); av_metadata_free(&c->fmt_ctx.metadata);
len = url_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer); len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
c->buffer_ptr = c->pb_buffer; c->buffer_ptr = c->pb_buffer;
c->buffer_end = c->pb_buffer + len; c->buffer_end = c->pb_buffer + len;
@ -2389,9 +2391,9 @@ static int http_prepare_data(HTTPContext *c)
max_packet_size = RTSP_TCP_MAX_PACKET_SIZE; max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
else else
max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]); max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size); ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
} else { } else {
ret = url_open_dyn_buf(&ctx->pb); ret = avio_open_dyn_buf(&ctx->pb);
} }
if (ret < 0) { if (ret < 0) {
/* XXX: potential leak */ /* XXX: potential leak */
@ -2399,7 +2401,7 @@ static int http_prepare_data(HTTPContext *c)
} }
ost = ctx->streams[pkt.stream_index]; ost = ctx->streams[pkt.stream_index];
ctx->pb->is_streamed = 1; ctx->pb->seekable = 0;
if (pkt.dts != AV_NOPTS_VALUE) if (pkt.dts != AV_NOPTS_VALUE)
pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base); pkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base);
if (pkt.pts != AV_NOPTS_VALUE) if (pkt.pts != AV_NOPTS_VALUE)
@ -2410,7 +2412,7 @@ static int http_prepare_data(HTTPContext *c)
c->state = HTTPSTATE_SEND_DATA_TRAILER; c->state = HTTPSTATE_SEND_DATA_TRAILER;
} }
len = url_close_dyn_buf(ctx->pb, &c->pb_buffer); len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
c->cur_frame_bytes = len; c->cur_frame_bytes = len;
c->buffer_ptr = c->pb_buffer; c->buffer_ptr = c->pb_buffer;
c->buffer_end = c->pb_buffer + len; c->buffer_end = c->pb_buffer + len;
@ -2432,13 +2434,13 @@ static int http_prepare_data(HTTPContext *c)
return -1; return -1;
ctx = &c->fmt_ctx; ctx = &c->fmt_ctx;
/* prepare header */ /* prepare header */
if (url_open_dyn_buf(&ctx->pb) < 0) { if (avio_open_dyn_buf(&ctx->pb) < 0) {
/* XXX: potential leak */ /* XXX: potential leak */
return -1; return -1;
} }
c->fmt_ctx.pb->is_streamed = 1; c->fmt_ctx.pb->seekable = 0;
av_write_trailer(ctx); av_write_trailer(ctx);
len = url_close_dyn_buf(ctx->pb, &c->pb_buffer); len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
c->buffer_ptr = c->pb_buffer; c->buffer_ptr = c->pb_buffer;
c->buffer_end = c->pb_buffer + len; c->buffer_end = c->pb_buffer + len;
@ -2503,7 +2505,7 @@ static int http_send_data(HTTPContext *c)
/* if already sending something, then wait. */ /* if already sending something, then wait. */
if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST) if (rtsp_c->state != RTSPSTATE_WAIT_REQUEST)
break; break;
if (url_open_dyn_buf(&pb) < 0) if (avio_open_dyn_buf(&pb) < 0)
goto fail1; goto fail1;
interleaved_index = c->packet_stream_index * 2; interleaved_index = c->packet_stream_index * 2;
/* RTCP packets are sent at odd indexes */ /* RTCP packets are sent at odd indexes */
@ -2518,7 +2520,7 @@ static int http_send_data(HTTPContext *c)
/* write RTP packet data */ /* write RTP packet data */
c->buffer_ptr += 4; c->buffer_ptr += 4;
avio_write(pb, c->buffer_ptr, len); avio_write(pb, c->buffer_ptr, len);
size = url_close_dyn_buf(pb, &c->packet_buffer); size = avio_close_dyn_buf(pb, &c->packet_buffer);
/* prepare asynchronous TCP sending */ /* prepare asynchronous TCP sending */
rtsp_c->packet_buffer_ptr = c->packet_buffer; rtsp_c->packet_buffer_ptr = c->packet_buffer;
rtsp_c->packet_buffer_end = c->packet_buffer + size; rtsp_c->packet_buffer_end = c->packet_buffer + size;
@ -2723,7 +2725,7 @@ static int http_receive_data(HTTPContext *c)
pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer, pb = avio_alloc_context(c->buffer, c->buffer_end - c->buffer,
0, NULL, NULL, NULL, NULL); 0, NULL, NULL, NULL, NULL);
pb->is_streamed = 1; pb->seekable = 0;
if (av_open_input_stream(&s, pb, c->stream->feed_filename, fmt_in, NULL) < 0) { if (av_open_input_stream(&s, pb, c->stream->feed_filename, fmt_in, NULL) < 0) {
av_free(pb); av_free(pb);
@ -2850,7 +2852,7 @@ static int rtsp_parse_request(HTTPContext *c)
av_strlcpy(c->url, url, sizeof(c->url)); av_strlcpy(c->url, url, sizeof(c->url));
av_strlcpy(c->protocol, protocol, sizeof(c->protocol)); av_strlcpy(c->protocol, protocol, sizeof(c->protocol));
if (url_open_dyn_buf(&c->pb) < 0) { if (avio_open_dyn_buf(&c->pb) < 0) {
/* XXX: cannot do more */ /* XXX: cannot do more */
c->pb = NULL; /* safety */ c->pb = NULL; /* safety */
return -1; return -1;
@ -2907,7 +2909,7 @@ static int rtsp_parse_request(HTTPContext *c)
rtsp_reply_error(c, RTSP_STATUS_METHOD); rtsp_reply_error(c, RTSP_STATUS_METHOD);
the_end: the_end:
len = url_close_dyn_buf(c->pb, &c->pb_buffer); len = avio_close_dyn_buf(c->pb, &c->pb_buffer);
c->pb = NULL; /* safety */ c->pb = NULL; /* safety */
if (len < 0) { if (len < 0) {
/* XXX: cannot do more */ /* XXX: cannot do more */
@ -3444,7 +3446,7 @@ static int rtp_new_av_stream(HTTPContext *c,
c->stream->filename, stream_index, c->protocol); c->stream->filename, stream_index, c->protocol);
/* normally, no packets should be output here, but the packet size may be checked */ /* normally, no packets should be output here, but the packet size may be checked */
if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) { if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
/* XXX: close stream */ /* XXX: close stream */
goto fail; goto fail;
} }
@ -3456,7 +3458,7 @@ static int rtp_new_av_stream(HTTPContext *c,
av_free(ctx); av_free(ctx);
return -1; return -1;
} }
url_close_dyn_buf(ctx->pb, &dummy_buf); avio_close_dyn_buf(ctx->pb, &dummy_buf);
av_free(dummy_buf); av_free(dummy_buf);
c->rtp_ctx[stream_index] = ctx; c->rtp_ctx[stream_index] = ctx;

26
libavcodec/ac3enc.c
View file

@ -29,6 +29,8 @@
//#define DEBUG //#define DEBUG
//#define ASSERT_LEVEL 2 //#define ASSERT_LEVEL 2
#include <stdint.h>
#include "libavutil/audioconvert.h" #include "libavutil/audioconvert.h"
#include "libavutil/avassert.h" #include "libavutil/avassert.h"
#include "libavutil/crc.h" #include "libavutil/crc.h"
@ -39,6 +41,7 @@
#include "ac3dsp.h" #include "ac3dsp.h"
#include "ac3.h" #include "ac3.h"
#include "audioconvert.h" #include "audioconvert.h"
#include "fft.h"
#ifndef CONFIG_AC3ENC_FLOAT #ifndef CONFIG_AC3ENC_FLOAT
@ -55,16 +58,22 @@
#define AC3_REMATRIXING_NONE 1 #define AC3_REMATRIXING_NONE 1
#define AC3_REMATRIXING_ALWAYS 3 #define AC3_REMATRIXING_ALWAYS 3
/** Scale a float value by 2^bits and convert to an integer. */
#define SCALE_FLOAT(a, bits) lrintf((a) * (float)(1 << (bits)))
#if CONFIG_AC3ENC_FLOAT #if CONFIG_AC3ENC_FLOAT
#include "ac3enc_float.h" #define MAC_COEF(d,a,b) ((d)+=(a)*(b))
typedef float SampleType;
typedef float CoefType;
typedef float CoefSumType;
#else #else
#include "ac3enc_fixed.h" #define MAC_COEF(d,a,b) MAC64(d,a,b)
typedef int16_t SampleType;
typedef int32_t CoefType;
typedef int64_t CoefSumType;
#endif #endif
typedef struct AC3MDCTContext {
const SampleType *window; ///< MDCT window function
FFTContext fft; ///< FFT context for MDCT calculation
} AC3MDCTContext;
/** /**
* Encoding Options used by AVOption. * Encoding Options used by AVOption.
@ -279,8 +288,6 @@ static av_cold void mdct_end(AC3MDCTContext *mdct);
static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
int nbits); int nbits);
static void mdct512(AC3MDCTContext *mdct, CoefType *out, SampleType *in);
static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input, static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input,
const SampleType *window, unsigned int len); const SampleType *window, unsigned int len);
@ -386,7 +393,8 @@ static void apply_mdct(AC3EncodeContext *s)
block->coeff_shift[ch] = normalize_samples(s); block->coeff_shift[ch] = normalize_samples(s);
mdct512(&s->mdct, block->mdct_coef[ch], s->windowed_samples); s->mdct.fft.mdct_calcw(&s->mdct.fft, block->mdct_coef[ch],
s->windowed_samples);
} }
} }
} }

298
libavcodec/ac3enc_fixed.c
View file

@ -26,54 +26,17 @@
* fixed-point AC-3 encoder. * fixed-point AC-3 encoder.
*/ */
#define CONFIG_FFT_FLOAT 0
#undef CONFIG_AC3ENC_FLOAT #undef CONFIG_AC3ENC_FLOAT
#include "ac3enc.c" #include "ac3enc.c"
/** Scale a float value by 2^15, convert to an integer, and clip to range -32767..32767. */
#define FIX15(a) av_clip(SCALE_FLOAT(a, 15), -32767, 32767)
/** /**
* Finalize MDCT and free allocated memory. * Finalize MDCT and free allocated memory.
*/ */
static av_cold void mdct_end(AC3MDCTContext *mdct) static av_cold void mdct_end(AC3MDCTContext *mdct)
{ {
mdct->nbits = 0; ff_fft_end(&mdct->fft);
av_freep(&mdct->costab);
av_freep(&mdct->sintab);
av_freep(&mdct->xcos1);
av_freep(&mdct->xsin1);
av_freep(&mdct->rot_tmp);
av_freep(&mdct->cplx_tmp);
}
/**
* Initialize FFT tables.
* @param ln log2(FFT size)
*/
static av_cold int fft_init(AVCodecContext *avctx, AC3MDCTContext *mdct, int ln)
{
int i, n, n2;
float alpha;
n = 1 << ln;
n2 = n >> 1;
FF_ALLOC_OR_GOTO(avctx, mdct->costab, n2 * sizeof(*mdct->costab), fft_alloc_fail);
FF_ALLOC_OR_GOTO(avctx, mdct->sintab, n2 * sizeof(*mdct->sintab), fft_alloc_fail);
for (i = 0; i < n2; i++) {
alpha = 2.0 * M_PI * i / n;
mdct->costab[i] = FIX15(cos(alpha));
mdct->sintab[i] = FIX15(sin(alpha));
}
return 0;
fft_alloc_fail:
mdct_end(mdct);
return AVERROR(ENOMEM);
} }
@ -84,167 +47,9 @@ fft_alloc_fail:
static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
int nbits) int nbits)
{ {
int i, n, n4, ret; int ret = ff_mdct_init(&mdct->fft, nbits, 0, 1.0);
n = 1 << nbits;
n4 = n >> 2;
mdct->nbits = nbits;
ret = fft_init(avctx, mdct, nbits - 2);
if (ret)
return ret;
mdct->window = ff_ac3_window; mdct->window = ff_ac3_window;
return ret;
FF_ALLOC_OR_GOTO(avctx, mdct->xcos1, n4 * sizeof(*mdct->xcos1), mdct_alloc_fail);
FF_ALLOC_OR_GOTO(avctx, mdct->xsin1, n4 * sizeof(*mdct->xsin1), mdct_alloc_fail);
FF_ALLOC_OR_GOTO(avctx, mdct->rot_tmp, n * sizeof(*mdct->rot_tmp), mdct_alloc_fail);
FF_ALLOC_OR_GOTO(avctx, mdct->cplx_tmp, n4 * sizeof(*mdct->cplx_tmp), mdct_alloc_fail);
for (i = 0; i < n4; i++) {
float alpha = 2.0 * M_PI * (i + 1.0 / 8.0) / n;
mdct->xcos1[i] = FIX15(-cos(alpha));
mdct->xsin1[i] = FIX15(-sin(alpha));
}
return 0;
mdct_alloc_fail:
mdct_end(mdct);
return AVERROR(ENOMEM);
}
/** Butterfly op */
#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \
{ \
int ax, ay, bx, by; \
bx = pre1; \
by = pim1; \
ax = qre1; \
ay = qim1; \
pre = (bx + ax) >> 1; \
pim = (by + ay) >> 1; \
qre = (bx - ax) >> 1; \
qim = (by - ay) >> 1; \
}
/** Complex multiply */
#define CMUL(pre, pim, are, aim, bre, bim, rshift) \
{ \
pre = (MUL16(are, bre) - MUL16(aim, bim)) >> rshift; \
pim = (MUL16(are, bim) + MUL16(bre, aim)) >> rshift; \
}
/**
* Calculate a 2^n point complex FFT on 2^ln points.
* @param z complex input/output samples
* @param ln log2(FFT size)
*/
static void fft(AC3MDCTContext *mdct, IComplex *z, int ln)
{
int j, l, np, np2;
int nblocks, nloops;
register IComplex *p,*q;
int tmp_re, tmp_im;
np = 1 << ln;
/* reverse */
for (j = 0; j < np; j++) {
int k = av_reverse[j] >> (8 - ln);
if (k < j)
FFSWAP(IComplex, z[k], z[j]);
}
/* pass 0 */
p = &z[0];
j = np >> 1;
do {
BF(p[0].re, p[0].im, p[1].re, p[1].im,
p[0].re, p[0].im, p[1].re, p[1].im);
p += 2;
} while (--j);
/* pass 1 */
p = &z[0];
j = np >> 2;
do {
BF(p[0].re, p[0].im, p[2].re, p[2].im,
p[0].re, p[0].im, p[2].re, p[2].im);
BF(p[1].re, p[1].im, p[3].re, p[3].im,
p[1].re, p[1].im, p[3].im, -p[3].re);
p+=4;
} while (--j);
/* pass 2 .. ln-1 */
nblocks = np >> 3;
nloops = 1 << 2;
np2 = np >> 1;
do {
p = z;
q = z + nloops;
for (j = 0; j < nblocks; j++) {
BF(p->re, p->im, q->re, q->im,
p->re, p->im, q->re, q->im);
p++;
q++;
for(l = nblocks; l < np2; l += nblocks) {
CMUL(tmp_re, tmp_im, mdct->costab[l], -mdct->sintab[l], q->re, q->im, 15);
BF(p->re, p->im, q->re, q->im,
p->re, p->im, tmp_re, tmp_im);
p++;
q++;
}
p += nloops;
q += nloops;
}
nblocks = nblocks >> 1;
nloops = nloops << 1;
} while (nblocks);
}
/**
* Calculate a 512-point MDCT
* @param out 256 output frequency coefficients
* @param in 512 windowed input audio samples
*/
static void mdct512(AC3MDCTContext *mdct, int32_t *out, int16_t *in)
{
int i, re, im, n, n2, n4;
int16_t *rot = mdct->rot_tmp;
IComplex *x = mdct->cplx_tmp;
n = 1 << mdct->nbits;
n2 = n >> 1;
n4 = n >> 2;
/* shift to simplify computations */
for (i = 0; i <n4; i++)
rot[i] = -in[i + 3*n4];
memcpy(&rot[n4], &in[0], 3*n4*sizeof(*in));
/* pre rotation */
for (i = 0; i < n4; i++) {
re = ((int)rot[ 2*i] - (int)rot[ n-1-2*i]) >> 1;
im = -((int)rot[n2+2*i] - (int)rot[n2-1-2*i]) >> 1;
CMUL(x[i].re, x[i].im, re, im, -mdct->xcos1[i], mdct->xsin1[i], 15);
}
fft(mdct, x, mdct->nbits - 2);
/* post rotation */
for (i = 0; i < n4; i++) {
re = x[i].re;
im = x[i].im;
CMUL(out[n2-1-2*i], out[2*i], re, im, mdct->xsin1[i], mdct->xcos1[i], 0);
}
} }
@ -304,101 +109,6 @@ static void scale_coefficients(AC3EncodeContext *s)
} }
#ifdef TEST
/*************************************************************************/
/* TEST */
#include "libavutil/lfg.h"
#define MDCT_NBITS 9
#define MDCT_SAMPLES (1 << MDCT_NBITS)
#define FN (MDCT_SAMPLES/4)
static void fft_test(AC3MDCTContext *mdct, AVLFG *lfg)
{
IComplex in[FN], in1[FN];
int k, n, i;
float sum_re, sum_im, a;
for (i = 0; i < FN; i++) {
in[i].re = av_lfg_get(lfg) % 65535 - 32767;
in[i].im = av_lfg_get(lfg) % 65535 - 32767;
in1[i] = in[i];
}
fft(mdct, in, 7);
/* do it by hand */
for (k = 0; k < FN; k++) {
sum_re = 0;
sum_im = 0;
for (n = 0; n < FN; n++) {
a = -2 * M_PI * (n * k) / FN;
sum_re += in1[n].re * cos(a) - in1[n].im * sin(a);
sum_im += in1[n].re * sin(a) + in1[n].im * cos(a);
}
av_log(NULL, AV_LOG_DEBUG, "%3d: %6d,%6d %6.0f,%6.0f\n",
k, in[k].re, in[k].im, sum_re / FN, sum_im / FN);
}
}
static void mdct_test(AC3MDCTContext *mdct, AVLFG *lfg)
{
int16_t input[MDCT_SAMPLES];
int32_t output[AC3_MAX_COEFS];
float input1[MDCT_SAMPLES];
float output1[AC3_MAX_COEFS];
float s, a, err, e, emax;
int i, k, n;
for (i = 0; i < MDCT_SAMPLES; i++) {
input[i] = (av_lfg_get(lfg) % 65535 - 32767) * 9 / 10;
input1[i] = input[i];
}
mdct512(mdct, output, input);
/* do it by hand */
for (k = 0; k < AC3_MAX_COEFS; k++) {
s = 0;
for (n = 0; n < MDCT_SAMPLES; n++) {
a = (2*M_PI*(2*n+1+MDCT_SAMPLES/2)*(2*k+1) / (4 * MDCT_SAMPLES));
s += input1[n] * cos(a);
}
output1[k] = -2 * s / MDCT_SAMPLES;
}
err = 0;
emax = 0;
for (i = 0; i < AC3_MAX_COEFS; i++) {
av_log(NULL, AV_LOG_DEBUG, "%3d: %7d %7.0f\n", i, output[i], output1[i]);
e = output[i] - output1[i];
if (e > emax)
emax = e;
err += e * e;
}
av_log(NULL, AV_LOG_DEBUG, "err2=%f emax=%f\n", err / AC3_MAX_COEFS, emax);
}
int main(void)
{
AVLFG lfg;
AC3MDCTContext mdct;
mdct.avctx = NULL;
av_log_set_level(AV_LOG_DEBUG);
mdct_init(&mdct, 9);
fft_test(&mdct, &lfg);
mdct_test(&mdct, &lfg);
return 0;
}
#endif /* TEST */
AVCodec ff_ac3_fixed_encoder = { AVCodec ff_ac3_fixed_encoder = {
"ac3_fixed", "ac3_fixed",
AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_AUDIO,

61
libavcodec/ac3enc_fixed.h
View file

@ -1,61 +0,0 @@
/*
* The simplest AC-3 encoder
* Copyright (c) 2000 Fabrice Bellard
* Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
* Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* fixed-point AC-3 encoder header.
*/
#ifndef AVCODEC_AC3ENC_FIXED_H
#define AVCODEC_AC3ENC_FIXED_H
#include <stdint.h>
typedef int16_t SampleType;
typedef int32_t CoefType;
typedef int64_t CoefSumType;
#define MAC_COEF(d,a,b) MAC64(d,a,b)
/**
* Compex number.
* Used in fixed-point MDCT calculation.
*/
typedef struct IComplex {
int16_t re,im;
} IComplex;
typedef struct AC3MDCTContext {
const int16_t *window; ///< MDCT window function
int nbits; ///< log2(transform size)
int16_t *costab; ///< FFT cos table
int16_t *sintab; ///< FFT sin table
int16_t *xcos1; ///< MDCT cos table
int16_t *xsin1; ///< MDCT sin table
int16_t *rot_tmp; ///< temp buffer for pre-rotated samples
IComplex *cplx_tmp; ///< temp buffer for complex pre-rotated samples
} AC3MDCTContext;
#endif /* AVCODEC_AC3ENC_FIXED_H */

11
libavcodec/ac3enc_float.c
View file

@ -68,17 +68,6 @@ static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
} }
/**
* Calculate a 512-point MDCT
* @param out 256 output frequency coefficients
* @param in 512 windowed input audio samples
*/
static void mdct512(AC3MDCTContext *mdct, float *out, float *in)
{
mdct->fft.mdct_calc(&mdct->fft, out, in);
}
/** /**
* Apply KBD window to input samples prior to MDCT. * Apply KBD window to input samples prior to MDCT.
*/ */

47
libavcodec/ac3enc_float.h
View file

@ -1,47 +0,0 @@
/*
* The simplest AC-3 encoder
* Copyright (c) 2000 Fabrice Bellard
* Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
* Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* floating-point AC-3 encoder header.
*/
#ifndef AVCODEC_AC3ENC_FLOAT_H
#define AVCODEC_AC3ENC_FLOAT_H
#include "fft.h"
typedef float SampleType;
typedef float CoefType;
typedef float CoefSumType;
#define MAC_COEF(d,a,b) ((d)+=(a)*(b))
typedef struct AC3MDCTContext {
const float *window; ///< MDCT window function
FFTContext fft; ///< FFT context for MDCT calculation
} AC3MDCTContext;
#endif /* AVCODEC_AC3ENC_FLOAT_H */

3
libavcodec/arm/Makefile
View file

@ -16,6 +16,7 @@ OBJS-$(CONFIG_H264PRED) += arm/h264pred_init_arm.o
OBJS += arm/dsputil_init_arm.o \ OBJS += arm/dsputil_init_arm.o \
arm/dsputil_arm.o \ arm/dsputil_arm.o \
arm/fft_init_arm.o \ arm/fft_init_arm.o \
arm/fft_fixed_init_arm.o \
arm/fmtconvert_init_arm.o \ arm/fmtconvert_init_arm.o \
arm/jrevdct_arm.o \ arm/jrevdct_arm.o \
arm/mpegvideo_arm.o \ arm/mpegvideo_arm.o \
@ -41,8 +42,10 @@ OBJS-$(HAVE_IWMMXT) += arm/dsputil_iwmmxt.o \
arm/mpegvideo_iwmmxt.o \ arm/mpegvideo_iwmmxt.o \
NEON-OBJS-$(CONFIG_FFT) += arm/fft_neon.o \ NEON-OBJS-$(CONFIG_FFT) += arm/fft_neon.o \
arm/fft_fixed_neon.o \
NEON-OBJS-$(CONFIG_MDCT) += arm/mdct_neon.o \ NEON-OBJS-$(CONFIG_MDCT) += arm/mdct_neon.o \
arm/mdct_fixed_neon.o \
NEON-OBJS-$(CONFIG_RDFT) += arm/rdft_neon.o \ NEON-OBJS-$(CONFIG_RDFT) += arm/rdft_neon.o \

42
libavcodec/arm/fft_fixed_init_arm.c Normal file
View file

@ -0,0 +1,42 @@
/*
* Copyright (c) 2009 Mans Rullgard <mans@mansr.com>
*
* This file is part of FFmpeg.
*
* FFMpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define CONFIG_FFT_FLOAT 0
#include "libavcodec/fft.h"
void ff_fft_fixed_calc_neon(FFTContext *s, FFTComplex *z);
void ff_mdct_fixed_calc_neon(FFTContext *s, FFTSample *o, const FFTSample *i);
void ff_mdct_fixed_calcw_neon(FFTContext *s, FFTDouble *o, const FFTSample *i);
av_cold void ff_fft_fixed_init_arm(FFTContext *s)
{
if (HAVE_NEON) {
s->fft_permutation = FF_FFT_PERM_SWAP_LSBS;
s->fft_calc = ff_fft_fixed_calc_neon;
#if CONFIG_MDCT
if (!s->inverse && s->mdct_bits >= 5) {
s->mdct_permutation = FF_MDCT_PERM_INTERLEAVE;
s->mdct_calc = ff_mdct_fixed_calc_neon;
s->mdct_calcw = ff_mdct_fixed_calcw_neon;
}
#endif
}
}

261
libavcodec/arm/fft_fixed_neon.S Normal file
View file

@ -0,0 +1,261 @@
/*
* Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "asm.S"
.macro bflies d0, d1, r0, r1
vrev64.32 \r0, \d1 @ t5, t6, t1, t2
vhsub.s16 \r1, \d1, \r0 @ t1-t5, t2-t6, t5-t1, t6-t2
vhadd.s16 \r0, \d1, \r0 @ t1+t5, t2+t6, t5+t1, t6+t2
vext.16 \r1, \r1, \r1, #1 @ t2-t6, t5-t1, t6-t2, t1-t5
vtrn.32 \r0, \r1 @ t1+t5, t2+t6, t2-t6, t5-t1
@ t5, t6, t4, t3
vhsub.s16 \d1, \d0, \r0
vhadd.s16 \d0, \d0, \r0
.endm
.macro transform01 q0, q1, d3, c0, c1, r0, w0, w1
vrev32.16 \r0, \d3
vmull.s16 \w0, \d3, \c0
vmlal.s16 \w0, \r0, \c1
vshrn.s32 \d3, \w0, #15
bflies \q0, \q1, \w0, \w1
.endm
.macro transform2 d0, d1, d2, d3, q0, q1, c0, c1, c2, c3, \
r0, r1, w0, w1
vrev32.16 \r0, \d1
vrev32.16 \r1, \d3
vmull.s16 \w0, \d1, \c0
vmlal.s16 \w0, \r0, \c1
vmull.s16 \w1, \d3, \c2
vmlal.s16 \w1, \r1, \c3
vshrn.s32 \d1, \w0, #15
vshrn.s32 \d3, \w1, #15
bflies \q0, \q1, \w0, \w1
.endm
.macro fft4 d0, d1, r0, r1
vhsub.s16 \r0, \d0, \d1 @ t3, t4, t8, t7
vhsub.s16 \r1, \d1, \d0
vhadd.s16 \d0, \d0, \d1 @ t1, t2, t6, t5
vmov.i64 \d1, #0xffff<<32
vbit \r0, \r1, \d1
vrev64.16 \r1, \r0 @ t7, t8, t4, t3
vtrn.32 \r0, \r1 @ t3, t4, t7, t8
vtrn.32 \d0, \r0 @ t1, t2, t3, t4, t6, t5, t8, t7
vhsub.s16 \d1, \d0, \r0 @ r2, i2, r3, i1
vhadd.s16 \d0, \d0, \r0 @ r0, i0, r1, i3
.endm
.macro fft8 d0, d1, d2, d3, q0, q1, c0, c1, r0, r1, w0, w1
fft4 \d0, \d1, \r0, \r1
vtrn.32 \d0, \d1 @ z0, z2, z1, z3
vhadd.s16 \r0, \d2, \d3 @ t1, t2, t3, t4
vhsub.s16 \d3, \d2, \d3 @ z5, z7
vmov \d2, \r0
transform01 \q0, \q1, \d3, \c0, \c1, \r0, \w0, \w1
.endm
function fft4_neon
vld1.16 {d0-d1}, [r0,:128]
fft4 d0, d1, d2, d3
vst1.16 {d0-d1}, [r0,:128]
bx lr
endfunc
function fft8_neon
vld1.16 {d0-d3}, [r0,:128]
movrel r1, coefs
vld1.16 {d30}, [r1,:64]
vdup.16 d31, d30[0]
fft8 d0, d1, d2, d3, q0, q1, d31, d30, d20, d21, q8, q9
vtrn.32 d0, d1
vtrn.32 d2, d3
vst1.16 {d0-d3}, [r0,:128]
bx lr
endfunc
function fft16_neon
vld1.16 {d0-d3}, [r0,:128]!
vld1.16 {d4-d7}, [r0,:128]
movrel r1, coefs
sub r0, r0, #32
vld1.16 {d28-d31},[r1,:128]
vdup.16 d31, d28[0]
fft8 d0, d1, d2, d3, q0, q1, d31, d28, d20, d21, q8, q9
vswp d5, d6
fft4 q2, q3, q8, q9
vswp d5, d6
vtrn.32 q0, q1 @ z0, z4, z2, z6, z1, z5, z3, z7
vtrn.32 q2, q3 @ z8, z12,z10,z14,z9, z13,z11,z15
vswp d1, d2
vdup.16 d31, d28[0]
transform01 q0, q2, d5, d31, d28, d20, q8, q9
vdup.16 d26, d29[0]
vdup.16 d27, d30[0]
transform2 d2, d6, d3, d7, q1, q3, d26, d30, d27, d29, \
d20, d21, q8, q9
vtrn.32 q0, q1
vtrn.32 q2, q3
vst1.16 {d0-d3}, [r0,:128]!
vst1.16 {d4-d7}, [r0,:128]
bx lr
endfunc
function fft_pass_neon
push {r4,lr}
movrel lr, coefs + 24
vld1.16 {d30}, [lr,:64]
lsl r12, r2, #3
vmov d31, d30
add r3, r1, r2, lsl #2
mov lr, #-8
sub r3, r3, #2
mov r4, r0
vld1.16 {d27[]}, [r3,:16]
sub r3, r3, #6
vld1.16 {q0}, [r4,:128], r12
vld1.16 {q1}, [r4,:128], r12
vld1.16 {q2}, [r4,:128], r12
vld1.16 {q3}, [r4,:128], r12
vld1.16 {d28}, [r1,:64]!
vld1.16 {d29}, [r3,:64], lr
vswp d1, d2
vswp d5, d6
vtrn.32 d0, d1
vtrn.32 d4, d5
vdup.16 d25, d28[1]
vmul.s16 d27, d27, d31
transform01 q0, q2, d5, d25, d27, d20, q8, q9
b 2f
1:
mov r4, r0
vdup.16 d26, d29[0]
vld1.16 {q0}, [r4,:128], r12
vld1.16 {q1}, [r4,:128], r12
vld1.16 {q2}, [r4,:128], r12
vld1.16 {q3}, [r4,:128], r12
vld1.16 {d28}, [r1,:64]!
vld1.16 {d29}, [r3,:64], lr
vswp d1, d2
vswp d5, d6
vtrn.32 d0, d1
vtrn.32 d4, d5
vdup.16 d24, d28[0]
vdup.16 d25, d28[1]
vdup.16 d27, d29[3]
vmul.s16 q13, q13, q15
transform2 d0, d4, d1, d5, q0, q2, d24, d26, d25, d27, \
d16, d17, q9, q10
2:
vtrn.32 d2, d3
vtrn.32 d6, d7
vdup.16 d24, d28[2]
vdup.16 d26, d29[2]
vdup.16 d25, d28[3]
vdup.16 d27, d29[1]
vmul.s16 q13, q13, q15
transform2 d2, d6, d3, d7, q1, q3, d24, d26, d25, d27, \
d16, d17, q9, q10
vtrn.32 d0, d1
vtrn.32 d2, d3
vtrn.32 d4, d5
vtrn.32 d6, d7
vswp d1, d2
vswp d5, d6
mov r4, r0
vst1.16 {q0}, [r4,:128], r12
vst1.16 {q1}, [r4,:128], r12
vst1.16 {q2}, [r4,:128], r12
vst1.16 {q3}, [r4,:128], r12
add r0, r0, #16
subs r2, r2, #2
bgt 1b
pop {r4,pc}
endfunc
#define F_SQRT1_2 23170
#define F_COS_16_1 30274
#define F_COS_16_3 12540
const coefs, align=4
.short F_SQRT1_2, -F_SQRT1_2, -F_SQRT1_2, F_SQRT1_2
.short F_COS_16_1,-F_COS_16_1,-F_COS_16_1, F_COS_16_1
.short F_COS_16_3,-F_COS_16_3,-F_COS_16_3, F_COS_16_3
.short 1, -1, -1, 1
endconst
.macro def_fft n, n2, n4
function fft\n\()_neon
push {r4, lr}
mov r4, r0
bl fft\n2\()_neon
add r0, r4, #\n4*2*4
bl fft\n4\()_neon
add r0, r4, #\n4*3*4
bl fft\n4\()_neon
mov r0, r4
pop {r4, lr}
movrel r1, X(ff_cos_\n\()_fixed)
mov r2, #\n4/2
b fft_pass_neon
endfunc
.endm
def_fft 32, 16, 8
def_fft 64, 32, 16
def_fft 128, 64, 32
def_fft 256, 128, 64
def_fft 512, 256, 128
def_fft 1024, 512, 256
def_fft 2048, 1024, 512
def_fft 4096, 2048, 1024
def_fft 8192, 4096, 2048
def_fft 16384, 8192, 4096
def_fft 32768, 16384, 8192
def_fft 65536, 32768, 16384
function ff_fft_fixed_calc_neon, export=1
ldr r2, [r0]
sub r2, r2, #2
movrel r3, fft_fixed_tab_neon
ldr r3, [r3, r2, lsl #2]
mov r0, r1
bx r3
endfunc
const fft_fixed_tab_neon
.word fft4_neon
.word fft8_neon
.word fft16_neon
.word fft32_neon
.word fft64_neon
.word fft128_neon
.word fft256_neon
.word fft512_neon
.word fft1024_neon
.word fft2048_neon
.word fft4096_neon
.word fft8192_neon
.word fft16384_neon
.word fft32768_neon
.word fft65536_neon
endconst

195
libavcodec/arm/mdct_fixed_neon.S Normal file
View file

@ -0,0 +1,195 @@
/*
* Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "asm.S"
preserve8
.macro prerot dst, rt
lsr r3, r6, #2 @ n4
add \rt, r4, r6, lsr #1 @ revtab + n4
add r9, r3, r3, lsl #1 @ n3
add r8, r7, r6 @ tcos + n4
add r3, r2, r6, lsr #1 @ in + n4
add r9, r2, r9, lsl #1 @ in + n3
sub r8, r8, #16
sub r10, r3, #16
sub r11, r9, #16
mov r12, #-16
1:
vld2.16 {d0,d1}, [r9, :128]!
vld2.16 {d2,d3}, [r11,:128], r12
vld2.16 {d4,d5}, [r3, :128]!
vld2.16 {d6,d7}, [r10,:128], r12
vld2.16 {d16,d17},[r7, :128]! @ cos, sin
vld2.16 {d18,d19},[r8, :128], r12
vrev64.16 q1, q1
vrev64.16 q3, q3
vrev64.16 q9, q9
vneg.s16 d0, d0
vneg.s16 d2, d2
vneg.s16 d16, d16
vneg.s16 d18, d18
vhsub.s16 d0, d0, d3 @ re
vhsub.s16 d4, d7, d4 @ im
vhsub.s16 d6, d6, d5
vhsub.s16 d2, d2, d1
vmull.s16 q10, d0, d16
vmlsl.s16 q10, d4, d17
vmull.s16 q11, d0, d17
vmlal.s16 q11, d4, d16
vmull.s16 q12, d6, d18
vmlsl.s16 q12, d2, d19
vmull.s16 q13, d6, d19
vmlal.s16 q13, d2, d18
vshrn.s32 d0, q10, #15
vshrn.s32 d1, q11, #15
vshrn.s32 d2, q12, #15
vshrn.s32 d3, q13, #15
vzip.16 d0, d1
vzip.16 d2, d3
ldrh lr, [r4], #2
ldrh r2, [\rt, #-2]!
add lr, \dst, lr, lsl #2
add r2, \dst, r2, lsl #2
vst1.32 {d0[0]}, [lr,:32]
vst1.32 {d2[0]}, [r2,:32]
ldrh lr, [r4], #2
ldrh r2, [\rt, #-2]!
add lr, \dst, lr, lsl #2
add r2, \dst, r2, lsl #2
vst1.32 {d0[1]}, [lr,:32]
vst1.32 {d2[1]}, [r2,:32]
ldrh lr, [r4], #2
ldrh r2, [\rt, #-2]!
add lr, \dst, lr, lsl #2
add r2, \dst, r2, lsl #2
vst1.32 {d1[0]}, [lr,:32]
vst1.32 {d3[0]}, [r2,:32]
ldrh lr, [r4], #2
ldrh r2, [\rt, #-2]!
add lr, \dst, lr, lsl #2
add r2, \dst, r2, lsl #2
vst1.32 {d1[1]}, [lr,:32]
vst1.32 {d3[1]}, [r2,:32]
subs r6, r6, #32
bgt 1b
.endm
function ff_mdct_fixed_calc_neon, export=1
push {r1,r4-r11,lr}
ldr r4, [r0, #8] @ revtab
ldr r6, [r0, #16] @ mdct_size; n
ldr r7, [r0, #24] @ tcos
prerot r1, r5
mov r4, r0
bl X(ff_fft_fixed_calc_neon)
pop {r5}
mov r12, #-16
ldr r6, [r4, #16] @ mdct_size; n
ldr r7, [r4, #24] @ tcos
add r5, r5, r6, lsr #1
add r7, r7, r6, lsr #1
sub r1, r5, #16
sub r2, r7, #16
1:
vld2.16 {d4,d5}, [r7,:128]!
vld2.16 {d6,d7}, [r2,:128], r12
vld2.16 {d0,d1}, [r5,:128]
vld2.16 {d2,d3}, [r1,:128]
vrev64.16 q3, q3
vrev64.16 q1, q1
vneg.s16 q3, q3
vneg.s16 q2, q2
vmull.s16 q11, d2, d6
vmlal.s16 q11, d3, d7
vmull.s16 q8, d0, d5
vmlsl.s16 q8, d1, d4
vmull.s16 q9, d0, d4
vmlal.s16 q9, d1, d5
vmull.s16 q10, d2, d7
vmlsl.s16 q10, d3, d6
vshrn.s32 d0, q11, #15
vshrn.s32 d1, q8, #15
vshrn.s32 d2, q9, #15
vshrn.s32 d3, q10, #15
vrev64.16 q0, q0
vst2.16 {d2,d3}, [r5,:128]!
vst2.16 {d0,d1}, [r1,:128], r12
subs r6, r6, #32
bgt 1b
pop {r4-r11,pc}
endfunc
function ff_mdct_fixed_calcw_neon, export=1
push {r1,r4-r11,lr}
ldrd r4, r5, [r0, #8] @ revtab, tmp_buf
ldr r6, [r0, #16] @ mdct_size; n
ldr r7, [r0, #24] @ tcos
prerot r5, r1
mov r4, r0
mov r1, r5
bl X(ff_fft_fixed_calc_neon)
pop {r7}
mov r12, #-16
ldr r6, [r4, #16] @ mdct_size; n
ldr r9, [r4, #24] @ tcos
add r5, r5, r6, lsr #1
add r7, r7, r6
add r9, r9, r6, lsr #1
sub r3, r5, #16
sub r1, r7, #16
sub r2, r9, #16
1:
vld2.16 {d4,d5}, [r9,:128]!
vld2.16 {d6,d7}, [r2,:128], r12
vld2.16 {d0,d1}, [r5,:128]!
vld2.16 {d2,d3}, [r3,:128], r12
vrev64.16 q3, q3
vrev64.16 q1, q1
vneg.s16 q3, q3
vneg.s16 q2, q2
vmull.s16 q8, d2, d6
vmlal.s16 q8, d3, d7
vmull.s16 q9, d0, d5
vmlsl.s16 q9, d1, d4
vmull.s16 q10, d0, d4
vmlal.s16 q10, d1, d5
vmull.s16 q11, d2, d7
vmlsl.s16 q11, d3, d6
vrev64.32 q8, q8
vrev64.32 q9, q9
vst2.32 {q10,q11},[r7,:128]!
vst2.32 {d16,d18},[r1,:128], r12
vst2.32 {d17,d19},[r1,:128], r12
subs r6, r6, #32
bgt 1b
pop {r4-r11,pc}
endfunc

11
libavcodec/avcodec.h
View file

@ -1829,19 +1829,21 @@ typedef struct AVCodecContext {
*/ */
uint64_t error[4]; uint64_t error[4];
#if FF_API_MB_Q
/** /**
* minimum MB quantizer * minimum MB quantizer
* - encoding: unused * - encoding: unused
* - decoding: unused * - decoding: unused
*/ */
int mb_qmin; attribute_deprecated int mb_qmin;
/** /**
* maximum MB quantizer * maximum MB quantizer
* - encoding: unused * - encoding: unused
* - decoding: unused * - decoding: unused
*/ */
int mb_qmax; attribute_deprecated int mb_qmax;
#endif
/** /**
* motion estimation comparison function * motion estimation comparison function
@ -2162,16 +2164,19 @@ typedef struct AVCodecContext {
*/ */
int error_rate; int error_rate;
#if FF_API_ANTIALIAS_ALGO
/** /**
* MP3 antialias algorithm, see FF_AA_* below. * MP3 antialias algorithm, see FF_AA_* below.
* - encoding: unused * - encoding: unused
* - decoding: Set by user. * - decoding: Set by user.
*/ */
int antialias_algo; attribute_deprecated int antialias_algo;
#define FF_AA_AUTO 0 #define FF_AA_AUTO 0
#define FF_AA_FASTINT 1 //not implemented yet #define FF_AA_FASTINT 1 //not implemented yet
#define FF_AA_INT 2 #define FF_AA_INT 2
#define FF_AA_FLOAT 3 #define FF_AA_FLOAT 3
#endif
/** /**
* quantizer noise shaping * quantizer noise shaping
* - encoding: Set by user. * - encoding: Set by user.

1
libavcodec/fft.c
View file

@ -126,6 +126,7 @@ av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
if (CONFIG_MDCT) s->mdct_calcw = s->mdct_calc; if (CONFIG_MDCT) s->mdct_calcw = s->mdct_calc;
#else #else
if (CONFIG_MDCT) s->mdct_calcw = ff_mdct_calcw_c; if (CONFIG_MDCT) s->mdct_calcw = ff_mdct_calcw_c;
if (ARCH_ARM) ff_fft_fixed_init_arm(s);
#endif #endif
for(j=4; j<=nbits; j++) { for(j=4; j<=nbits; j++) {

4
libavcodec/fft.h
View file

@ -132,9 +132,13 @@ void ff_init_ff_cos_tabs(int index);
*/ */
int ff_fft_init(FFTContext *s, int nbits, int inverse); int ff_fft_init(FFTContext *s, int nbits, int inverse);
#if CONFIG_FFT_FLOAT
void ff_fft_init_altivec(FFTContext *s); void ff_fft_init_altivec(FFTContext *s);
void ff_fft_init_mmx(FFTContext *s); void ff_fft_init_mmx(FFTContext *s);
void ff_fft_init_arm(FFTContext *s); void ff_fft_init_arm(FFTContext *s);
#else
void ff_fft_fixed_init_arm(FFTContext *s);
#endif
void ff_fft_end(FFTContext *s); void ff_fft_end(FFTContext *s);

4
libavcodec/options.c
View file

@ -259,8 +259,10 @@ static const AVOption options[]={
{"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"}, {"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"},
{"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"}, {"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"},
{"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"}, {"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"},
#if FF_API_MB_Q
{"mb_qmin", "obsolete, use qmin", OFFSET(mb_qmin), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E}, {"mb_qmin", "obsolete, use qmin", OFFSET(mb_qmin), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
{"mb_qmax", "obsolete, use qmax", OFFSET(mb_qmax), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E}, {"mb_qmax", "obsolete, use qmax", OFFSET(mb_qmax), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
#endif
{"cmp", "full pel me compare function", OFFSET(me_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"}, {"cmp", "full pel me compare function", OFFSET(me_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
{"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"}, {"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"},
{"mbcmp", "macroblock compare function", OFFSET(mb_cmp), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E, "cmp_func"}, {"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[]={
{"inter_threshold", NULL, OFFSET(inter_threshold), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E}, {"inter_threshold", NULL, OFFSET(inter_threshold), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
{"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"}, {"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"},
{"error", NULL, OFFSET(error_rate), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E}, {"error", NULL, OFFSET(error_rate), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|E},
#if FF_API_ANTIALIAS_ALGO
{"antialias", "MP3 antialias algorithm", OFFSET(antialias_algo), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|D, "aa"}, {"antialias", "MP3 antialias algorithm", OFFSET(antialias_algo), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, V|D, "aa"},
#endif
{"auto", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_AUTO, INT_MIN, INT_MAX, V|D, "aa"}, {"auto", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_AUTO, INT_MIN, INT_MAX, V|D, "aa"},
{"fastint", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_FASTINT, INT_MIN, INT_MAX, V|D, "aa"}, {"fastint", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_FASTINT, INT_MIN, INT_MAX, V|D, "aa"},
{"int", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_INT, INT_MIN, INT_MAX, V|D, "aa"}, {"int", NULL, 0, FF_OPT_TYPE_CONST, FF_AA_INT, INT_MIN, INT_MAX, V|D, "aa"},

6
libavcodec/version.h
View file

@ -77,5 +77,11 @@
#ifndef FF_API_RATE_EMU #ifndef FF_API_RATE_EMU
#define FF_API_RATE_EMU (LIBAVCODEC_VERSION_MAJOR < 53) #define FF_API_RATE_EMU (LIBAVCODEC_VERSION_MAJOR < 53)
#endif #endif
#ifndef FF_API_MB_Q
#define FF_API_MB_Q (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_ANTIALIAS_ALGO
#define FF_API_ANTIALIAS_ALGO (LIBAVCODEC_VERSION_MAJOR < 54)
#endif
#endif /* AVCODEC_VERSION_H */ #endif /* AVCODEC_VERSION_H */

2
libavfilter/avfilter.h
View file

@ -26,7 +26,7 @@
#include "libavutil/samplefmt.h" #include "libavutil/samplefmt.h"
#define LIBAVFILTER_VERSION_MAJOR 1 #define LIBAVFILTER_VERSION_MAJOR 1
#define LIBAVFILTER_VERSION_MINOR 76 #define LIBAVFILTER_VERSION_MINOR 77
#define LIBAVFILTER_VERSION_MICRO 0 #define LIBAVFILTER_VERSION_MICRO 0
#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \

2
libavformat/aiffdec.c
View file

@ -238,7 +238,7 @@ static int aiff_read_header(AVFormatContext *s,
offset += avio_tell(pb); /* Compute absolute data offset */ offset += avio_tell(pb); /* Compute absolute data offset */
if (st->codec->block_align) /* Assume COMM already parsed */ if (st->codec->block_align) /* Assume COMM already parsed */
goto got_sound; goto got_sound;
if (url_is_streamed(pb)) { if (!pb->seekable) {
av_log(s, AV_LOG_ERROR, "file is not seekable\n"); av_log(s, AV_LOG_ERROR, "file is not seekable\n");
return -1; return -1;
} }

2
libavformat/aiffenc.c
View file

@ -124,7 +124,7 @@ static int aiff_write_trailer(AVFormatContext *s)
end_size++; end_size++;
} }
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
/* File length */ /* File length */
avio_seek(pb, aiff->form, SEEK_SET); avio_seek(pb, aiff->form, SEEK_SET);
avio_wb32(pb, file_size - aiff->form - 4); avio_wb32(pb, file_size - aiff->form - 4);

2
libavformat/ape.c
View file

@ -296,7 +296,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap)
ape_dumpinfo(s, ape); ape_dumpinfo(s, ape);
/* try to read APE tags */ /* try to read APE tags */
if (!url_is_streamed(pb)) { if (pb->seekable) {
ff_ape_parse_tag(s); ff_ape_parse_tag(s);
avio_seek(pb, 0, SEEK_SET); avio_seek(pb, 0, SEEK_SET);
} }

16
libavformat/asfenc.c
View file

@ -234,11 +234,11 @@ static void put_str16(AVIOContext *s, const char *tag)
int len; int len;
uint8_t *pb; uint8_t *pb;
AVIOContext *dyn_buf; AVIOContext *dyn_buf;
if (url_open_dyn_buf(&dyn_buf) < 0) if (avio_open_dyn_buf(&dyn_buf) < 0)
return; return;
avio_put_str16le(dyn_buf, tag); avio_put_str16le(dyn_buf, tag);
len = url_close_dyn_buf(dyn_buf, &pb); len = avio_close_dyn_buf(dyn_buf, &pb);
avio_wl16(s, len); avio_wl16(s, len);
avio_write(s, pb, len); avio_write(s, pb, len);
av_freep(&pb); av_freep(&pb);
@ -347,7 +347,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
avio_wl64(pb, duration); /* end time stamp (in 100ns units) */ avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
avio_wl64(pb, asf->duration); /* duration (in 100ns units) */ avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
avio_wl64(pb, PREROLL_TIME); /* start time stamp */ avio_wl64(pb, PREROLL_TIME); /* start time stamp */
avio_wl32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */ avio_wl32(pb, (asf->is_streamed || !pb->seekable ) ? 3 : 2); /* ??? */
avio_wl32(pb, s->packet_size); /* packet size */ avio_wl32(pb, s->packet_size); /* packet size */
avio_wl32(pb, s->packet_size); /* packet size */ avio_wl32(pb, s->packet_size); /* packet size */
avio_wl32(pb, bit_rate); /* Nominal data rate in bps */ 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
uint8_t *buf; uint8_t *buf;
AVIOContext *dyn_buf; AVIOContext *dyn_buf;
if (url_open_dyn_buf(&dyn_buf) < 0) if (avio_open_dyn_buf(&dyn_buf) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
hpos = put_header(pb, &ff_asf_comment_header); 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
len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0; len = tags[n] ? avio_put_str16le(dyn_buf, tags[n]->value) : 0;
avio_wl16(pb, len); avio_wl16(pb, len);
} }
len = url_close_dyn_buf(dyn_buf, &buf); len = avio_close_dyn_buf(dyn_buf, &buf);
avio_write(pb, buf, len); avio_write(pb, buf, len);
av_freep(&buf); av_freep(&buf);
end_header(pb, hpos); end_header(pb, hpos);
@ -497,11 +497,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
else else
desc = p ? p->name : enc->codec_name; desc = p ? p->name : enc->codec_name;
if ( url_open_dyn_buf(&dyn_buf) < 0) if ( avio_open_dyn_buf(&dyn_buf) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_put_str16le(dyn_buf, desc); avio_put_str16le(dyn_buf, desc);
len = url_close_dyn_buf(dyn_buf, &buf); len = avio_close_dyn_buf(dyn_buf, &buf);
avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2 avio_wl16(pb, len / 2); // "number of characters" = length in bytes / 2
avio_write(pb, buf, len); avio_write(pb, buf, len);
@ -866,7 +866,7 @@ static int asf_write_trailer(AVFormatContext *s)
} }
avio_flush(s->pb); avio_flush(s->pb);
if (asf->is_streamed || url_is_streamed(s->pb)) { if (asf->is_streamed || !s->pb->seekable) {
put_chunk(s, 0x4524, 0, 0); /* end of stream */ put_chunk(s, 0x4524, 0, 0); /* end of stream */
} else { } else {
/* rewrite an updated header */ /* rewrite an updated header */

2
libavformat/au.c
View file

@ -91,7 +91,7 @@ static int au_write_trailer(AVFormatContext *s)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int64_t file_size; int64_t file_size;
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
/* update file size */ /* update file size */
file_size = avio_tell(pb); file_size = avio_tell(pb);

4
libavformat/avc.c
View file

@ -89,14 +89,14 @@ int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size) int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
{ {
AVIOContext *pb; AVIOContext *pb;
int ret = url_open_dyn_buf(&pb); int ret = avio_open_dyn_buf(&pb);
if(ret < 0) if(ret < 0)
return ret; return ret;
ff_avc_parse_nal_units(pb, buf_in, *size); ff_avc_parse_nal_units(pb, buf_in, *size);
av_freep(buf); av_freep(buf);
*size = url_close_dyn_buf(pb, buf); *size = avio_close_dyn_buf(pb, buf);
return 0; return 0;
} }

4
libavformat/avidec.c
View file

@ -665,7 +665,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
break; break;
case MKTAG('i', 'n', 'd', 'x'): case MKTAG('i', 'n', 'd', 'x'):
i= avio_tell(pb); i= avio_tell(pb);
if(!url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX)){ if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX)){
read_braindead_odml_indx(s, 0); read_braindead_odml_indx(s, 0);
} }
avio_seek(pb, i+size, SEEK_SET); avio_seek(pb, i+size, SEEK_SET);
@ -721,7 +721,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
return -1; return -1;
} }
if(!avi->index_loaded && !url_is_streamed(pb)) if(!avi->index_loaded && pb->seekable)
avi_load_index(s); avi_load_index(s);
avi->index_loaded = 1; avi->index_loaded = 1;
avi->non_interleaved |= guess_ni_flag(s); avi->non_interleaved |= guess_ni_flag(s);

18
libavformat/avienc.c
View file

@ -197,7 +197,7 @@ static int avi_write_header(AVFormatContext *s)
} }
avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */ avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
avio_wl32(pb, 0); /* padding */ avio_wl32(pb, 0); /* padding */
if (url_is_streamed(pb)) if (!pb->seekable)
avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */ avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */
else else
avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */ avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
@ -259,7 +259,7 @@ static int avi_write_header(AVFormatContext *s)
avio_wl32(pb, 0); /* start */ avio_wl32(pb, 0); /* start */
avist->frames_hdr_strm = avio_tell(pb); /* remember this offset to fill later */ avist->frames_hdr_strm = avio_tell(pb); /* remember this offset to fill later */
if (url_is_streamed(pb)) if (!pb->seekable)
avio_wl32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */ avio_wl32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */
else else
avio_wl32(pb, 0); /* length, XXX: filled later */ avio_wl32(pb, 0); /* length, XXX: filled later */
@ -303,7 +303,7 @@ static int avi_write_header(AVFormatContext *s)
} }
} }
if (!url_is_streamed(pb)) { if (pb->seekable) {
unsigned char tag[5]; unsigned char tag[5];
int j; int j;
@ -362,7 +362,7 @@ static int avi_write_header(AVFormatContext *s)
ff_end_tag(pb, list2); ff_end_tag(pb, list2);
} }
if (!url_is_streamed(pb)) { if (pb->seekable) {
/* AVI could become an OpenDML one, if it grows beyond 2Gb range */ /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
avi->odml_list = ff_start_tag(pb, "JUNK"); avi->odml_list = ff_start_tag(pb, "JUNK");
ffio_wfourcc(pb, "odml"); ffio_wfourcc(pb, "odml");
@ -406,7 +406,7 @@ static int avi_write_ix(AVFormatContext *s)
char ix_tag[] = "ix00"; char ix_tag[] = "ix00";
int i, j; int i, j;
assert(!url_is_streamed(pb)); assert(pb->seekable);
if (avi->riff_id > AVI_MASTER_INDEX_SIZE) if (avi->riff_id > AVI_MASTER_INDEX_SIZE)
return -1; return -1;
@ -464,7 +464,7 @@ static int avi_write_idx1(AVFormatContext *s)
int i; int i;
char tag[5]; char tag[5];
if (!url_is_streamed(pb)) { if (pb->seekable) {
AVIStream *avist; AVIStream *avist;
AVIIentry* ie = 0, *tie; AVIIentry* ie = 0, *tie;
int empty, stream_id = -1; int empty, stream_id = -1;
@ -532,7 +532,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
avist->packet_count++; avist->packet_count++;
// Make sure to put an OpenDML chunk when the file size exceeds the limits // Make sure to put an OpenDML chunk when the file size exceeds the limits
if (!url_is_streamed(pb) && if (pb->seekable &&
(avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) { (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
avi_write_ix(s); avi_write_ix(s);
@ -552,7 +552,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
avist->audio_strm_length += size; avist->audio_strm_length += size;
} }
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
AVIIndex* idx = &avist->indexes; AVIIndex* idx = &avist->indexes;
int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE; int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE;
int id = idx->entry % AVI_INDEX_CLUSTER_SIZE; int id = idx->entry % AVI_INDEX_CLUSTER_SIZE;
@ -590,7 +590,7 @@ static int avi_write_trailer(AVFormatContext *s)
int i, j, n, nb_frames; int i, j, n, nb_frames;
int64_t file_size; int64_t file_size;
if (!url_is_streamed(pb)){ if (pb->seekable){
if (avi->riff_id == 1) { if (avi->riff_id == 1) {
ff_end_tag(pb, avi->movi_list); ff_end_tag(pb, avi->movi_list);
res = avi_write_idx1(s); res = avi_write_idx1(s);

56
libavformat/avio.h
View file

@ -332,6 +332,8 @@ attribute_deprecated int av_register_protocol(URLProtocol *protocol);
*/ */
int av_register_protocol2(URLProtocol *protocol, int size); int av_register_protocol2(URLProtocol *protocol, int size);
#define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */
/** /**
* Bytestream IO Context. * Bytestream IO Context.
* New fields can be added to the end with minor version bumps. * New fields can be added to the end with minor version bumps.
@ -351,7 +353,9 @@ typedef struct {
int must_flush; /**< true if the next seek should flush */ int must_flush; /**< true if the next seek should flush */
int eof_reached; /**< true if eof reached */ int eof_reached; /**< true if eof reached */
int write_flag; /**< true if open for writing */ int write_flag; /**< true if open for writing */
int is_streamed; #if FF_API_OLD_AVIO
attribute_deprecated int is_streamed;
#endif
int max_packet_size; int max_packet_size;
unsigned long checksum; unsigned long checksum;
unsigned char *checksum_ptr; unsigned char *checksum_ptr;
@ -360,6 +364,10 @@ typedef struct {
int (*read_pause)(void *opaque, int pause); int (*read_pause)(void *opaque, int pause);
int64_t (*read_seek)(void *opaque, int stream_index, int64_t (*read_seek)(void *opaque, int stream_index,
int64_t timestamp, int flags); int64_t timestamp, int flags);
/**
* A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
*/
int seekable;
} AVIOContext; } AVIOContext;
#if FF_API_OLD_AVIO #if FF_API_OLD_AVIO
@ -439,6 +447,10 @@ attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...) __att
attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...); attribute_deprecated int url_fprintf(AVIOContext *s, const char *fmt, ...);
#endif #endif
attribute_deprecated void put_flush_packet(AVIOContext *s); attribute_deprecated void put_flush_packet(AVIOContext *s);
attribute_deprecated int url_open_dyn_buf(AVIOContext **s);
attribute_deprecated int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
attribute_deprecated int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
attribute_deprecated int url_fdopen(AVIOContext **s, URLContext *h);
/** /**
* @} * @}
*/ */
@ -603,23 +615,15 @@ unsigned int avio_rb24(AVIOContext *s);
unsigned int avio_rb32(AVIOContext *s); unsigned int avio_rb32(AVIOContext *s);
uint64_t avio_rb64(AVIOContext *s); uint64_t avio_rb64(AVIOContext *s);
static inline int url_is_streamed(AVIOContext *s) #if FF_API_OLD_AVIO
{
return s->is_streamed;
}
/** /**
* Create and initialize a AVIOContext for accessing the * @deprecated Use AVIOContext.seekable field directly.
* resource referenced by the URLContext h.
* @note When the URLContext h has been opened in read+write mode, the
* AVIOContext can be used only for writing.
*
* @param s Used to return the pointer to the created AVIOContext.
* In case of failure the pointed to value is set to NULL.
* @return 0 in case of success, a negative value corresponding to an
* AVERROR code in case of failure
*/ */
int url_fdopen(AVIOContext **s, URLContext *h); attribute_deprecated static inline int url_is_streamed(AVIOContext *s)
{
return !s->seekable;
}
#endif
#if FF_API_URL_RESETBUF #if FF_API_URL_RESETBUF
/** Reset the buffer for reading or writing. /** Reset the buffer for reading or writing.
@ -666,30 +670,18 @@ attribute_deprecated int url_close_buf(AVIOContext *s);
* @param s new IO context * @param s new IO context
* @return zero if no error. * @return zero if no error.
*/ */
int url_open_dyn_buf(AVIOContext **s); int avio_open_dyn_buf(AVIOContext **s);
/**
* Open a write only packetized memory stream with a maximum packet
* size of 'max_packet_size'. The stream is stored in a memory buffer
* with a big endian 4 byte header giving the packet size in bytes.
*
* @param s new IO context
* @param max_packet_size maximum packet size (must be > 0)
* @return zero if no error.
*/
int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
/** /**
* Return the written size and a pointer to the buffer. The buffer * Return the written size and a pointer to the buffer. The buffer
* must be freed with av_free(). If the buffer is opened with * must be freed with av_free().
* url_open_dyn_buf, then padding of FF_INPUT_BUFFER_PADDING_SIZE is * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
* added; if opened with url_open_dyn_packet_buf, no padding is added.
* *
* @param s IO context * @param s IO context
* @param pbuffer pointer to a byte buffer * @param pbuffer pointer to a byte buffer
* @return the length of the byte buffer * @return the length of the byte buffer
*/ */
int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer); int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
#if FF_API_UDP_GET_FILE #if FF_API_UDP_GET_FILE
int udp_get_file_handle(URLContext *h); int udp_get_file_handle(URLContext *h);

24
libavformat/avio_internal.h
View file

@ -81,4 +81,28 @@ unsigned long ffio_get_checksum(AVIOContext *s);
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
unsigned int len); unsigned int len);
/**
* Open a write only packetized memory stream with a maximum packet
* size of 'max_packet_size'. The stream is stored in a memory buffer
* with a big endian 4 byte header giving the packet size in bytes.
*
* @param s new IO context
* @param max_packet_size maximum packet size (must be > 0)
* @return zero if no error.
*/
int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
/**
* Create and initialize a AVIOContext for accessing the
* resource referenced by the URLContext h.
* @note When the URLContext h has been opened in read+write mode, the
* AVIOContext can be used only for writing.
*
* @param s Used to return the pointer to the created AVIOContext.
* In case of failure the pointed to value is set to NULL.
* @return 0 in case of success, a negative value corresponding to an
* AVERROR code in case of failure
*/
int ffio_fdopen(AVIOContext **s, URLContext *h);
#endif // AVFORMAT_AVIO_INTERNAL_H #endif // AVFORMAT_AVIO_INTERNAL_H

54
libavformat/aviobuf.c
View file

@ -62,7 +62,10 @@ int ffio_init_context(AVIOContext *s,
s->must_flush = 0; s->must_flush = 0;
s->eof_reached = 0; s->eof_reached = 0;
s->error = 0; s->error = 0;
#if FF_API_OLD_AVIO
s->is_streamed = 0; s->is_streamed = 0;
#endif
s->seekable = AVIO_SEEKABLE_NORMAL;
s->max_packet_size = 0; s->max_packet_size = 0;
s->update_checksum= NULL; s->update_checksum= NULL;
if(!read_packet && !write_flag){ if(!read_packet && !write_flag){
@ -202,7 +205,7 @@ int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) { offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
/* can do the seek inside the buffer */ /* can do the seek inside the buffer */
s->buf_ptr = s->buffer + offset1; s->buf_ptr = s->buffer + offset1;
} else if ((s->is_streamed || } else if ((!s->seekable ||
offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) && offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
!s->write_flag && offset1 >= 0 && !s->write_flag && offset1 >= 0 &&
(whence != SEEK_END || force)) { (whence != SEEK_END || force)) {
@ -425,6 +428,22 @@ unsigned long get_checksum(AVIOContext *s)
{ {
return ffio_get_checksum(s); return ffio_get_checksum(s);
} }
int url_open_dyn_buf(AVIOContext **s)
{
return avio_open_dyn_buf(s);
}
int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
{
return ffio_open_dyn_packet_buf(s, max_packet_size);
}
int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
{
return avio_close_dyn_buf(s, pbuffer);
}
int url_fdopen(AVIOContext **s, URLContext *h)
{
return ffio_fdopen(s, h);
}
#endif #endif
int avio_put_str(AVIOContext *s, const char *str) int avio_put_str(AVIOContext *s, const char *str)
@ -812,7 +831,7 @@ uint64_t ffio_read_varlen(AVIOContext *bc){
return val; return val;
} }
int url_fdopen(AVIOContext **s, URLContext *h) int ffio_fdopen(AVIOContext **s, URLContext *h)
{ {
uint8_t *buffer; uint8_t *buffer;
int buffer_size, max_packet_size; int buffer_size, max_packet_size;
@ -840,7 +859,10 @@ int url_fdopen(AVIOContext **s, URLContext *h)
av_freep(s); av_freep(s);
return AVERROR(EIO); return AVERROR(EIO);
} }
#if FF_API_OLD_AVIO
(*s)->is_streamed = h->is_streamed; (*s)->is_streamed = h->is_streamed;
#endif
(*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
(*s)->max_packet_size = max_packet_size; (*s)->max_packet_size = max_packet_size;
if(h->prot) { if(h->prot) {
(*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause; (*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)
err = url_open(&h, filename, flags); err = url_open(&h, filename, flags);
if (err < 0) if (err < 0)
return err; return err;
err = url_fdopen(s, h); err = ffio_fdopen(s, h);
if (err < 0) { if (err < 0) {
url_close(h); url_close(h);
return err; return err;
@ -1026,7 +1048,7 @@ int64_t ffio_read_seek(AVIOContext *s, int stream_index,
return ret; return ret;
} }
/* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response /* avio_open_dyn_buf and avio_close_dyn_buf are used in rtp.c to send a response
* back to the server even if CONFIG_MUXERS is false. */ * back to the server even if CONFIG_MUXERS is false. */
#if CONFIG_MUXERS || CONFIG_NETWORK #if CONFIG_MUXERS || CONFIG_NETWORK
/* buffer handling */ /* buffer handling */
@ -1123,7 +1145,6 @@ static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size) static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
{ {
DynBuffer *d; DynBuffer *d;
int ret;
unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024; unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size) 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)
d = av_mallocz(sizeof(DynBuffer) + io_buffer_size); d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
if (!d) if (!d)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
*s = av_mallocz(sizeof(AVIOContext)); d->io_buffer_size = io_buffer_size;
*s = avio_alloc_context(d->io_buffer, d->io_buffer_size, 1, d, NULL,
max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
max_packet_size ? NULL : dyn_buf_seek);
if(!*s) { if(!*s) {
av_free(d); av_free(d);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
d->io_buffer_size = io_buffer_size;
ret = ffio_init_context(*s, d->io_buffer, io_buffer_size,
1, d, NULL,
max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
max_packet_size ? NULL : dyn_buf_seek);
if (ret == 0) {
(*s)->max_packet_size = max_packet_size; (*s)->max_packet_size = max_packet_size;
} else { return 0;
av_free(d);
av_freep(s);
}
return ret;
} }
int url_open_dyn_buf(AVIOContext **s) int avio_open_dyn_buf(AVIOContext **s)
{ {
return url_open_dyn_buf_internal(s, 0); return url_open_dyn_buf_internal(s, 0);
} }
int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size) int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
{ {
if (max_packet_size <= 0) if (max_packet_size <= 0)
return -1; return -1;
return url_open_dyn_buf_internal(s, max_packet_size); return url_open_dyn_buf_internal(s, max_packet_size);
} }
int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer) int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
{ {
DynBuffer *d = s->opaque; DynBuffer *d = s->opaque;
int size; int size;

2
libavformat/bink.c
View file

@ -247,7 +247,7 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
BinkDemuxContext *bink = s->priv_data; BinkDemuxContext *bink = s->priv_data;
AVStream *vst = s->streams[0]; AVStream *vst = s->streams[0];
if (url_is_streamed(s->pb)) if (!s->pb->seekable)
return -1; return -1;
/* seek to the first frame */ /* seek to the first frame */

4
libavformat/cafdec.c
View file

@ -223,7 +223,7 @@ static int read_header(AVFormatContext *s,
/* stop at data chunk if seeking is not supported or /* stop at data chunk if seeking is not supported or
data chunk size is unknown */ data chunk size is unknown */
if (found_data && (caf->data_size < 0 || url_is_streamed(pb))) if (found_data && (caf->data_size < 0 || !pb->seekable))
break; break;
tag = avio_rb32(pb); tag = avio_rb32(pb);
@ -236,7 +236,7 @@ static int read_header(AVFormatContext *s,
avio_skip(pb, 4); /* edit count */ avio_skip(pb, 4); /* edit count */
caf->data_start = avio_tell(pb); caf->data_start = avio_tell(pb);
caf->data_size = size < 0 ? -1 : size - 4; caf->data_size = size < 0 ? -1 : size - 4;
if (caf->data_size > 0 && !url_is_streamed(pb)) if (caf->data_size > 0 && pb->seekable)
avio_skip(pb, caf->data_size); avio_skip(pb, caf->data_size);
found_data = 1; found_data = 1;
break; break;

2
libavformat/ffmdec.c
View file

@ -281,7 +281,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
goto fail; goto fail;
ffm->write_index = avio_rb64(pb); ffm->write_index = avio_rb64(pb);
/* get also filesize */ /* get also filesize */
if (!url_is_streamed(pb)) { if (pb->seekable) {
ffm->file_size = avio_size(pb); ffm->file_size = avio_size(pb);
if (ffm->write_index) if (ffm->write_index)
adjust_write_index(s); adjust_write_index(s);

2
libavformat/filmstripdec.c
View file

@ -40,7 +40,7 @@ static int read_header(AVFormatContext *s,
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st; AVStream *st;
if (url_is_streamed(s->pb)) if (!s->pb->seekable)
return AVERROR(EIO); return AVERROR(EIO);
avio_seek(pb, avio_size(pb) - 36, SEEK_SET); avio_seek(pb, avio_size(pb) - 36, SEEK_SET);

2
libavformat/flacenc.c
View file

@ -98,7 +98,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
if (!ff_flac_is_extradata_valid(s->streams[0]->codec, &format, &streaminfo)) if (!ff_flac_is_extradata_valid(s->streams[0]->codec, &format, &streaminfo))
return -1; return -1;
if (!url_is_streamed(pb)) { if (pb->seekable) {
/* rewrite the STREAMINFO header block data */ /* rewrite the STREAMINFO header block data */
file_size = avio_tell(pb); file_size = avio_tell(pb);
avio_seek(pb, 8, SEEK_SET); avio_seek(pb, 8, SEEK_SET);

4
libavformat/flvdec.c
View file

@ -428,7 +428,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
// if not streamed and no duration from metadata then seek to end to find the duration from the timestamps // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
if(!url_is_streamed(s->pb) && (!s->duration || s->duration==AV_NOPTS_VALUE)){ if(s->pb->seekable && (!s->duration || s->duration==AV_NOPTS_VALUE)){
int size; int size;
const int64_t pos= avio_tell(s->pb); const int64_t pos= avio_tell(s->pb);
const int64_t fsize= avio_size(s->pb); const int64_t fsize= avio_size(s->pb);
@ -530,7 +530,7 @@ static int flv_read_seek2(AVFormatContext *s, int stream_index,
if (ts - min_ts > (uint64_t)(max_ts - ts)) flags |= AVSEEK_FLAG_BACKWARD; if (ts - min_ts > (uint64_t)(max_ts - ts)) flags |= AVSEEK_FLAG_BACKWARD;
if (url_is_streamed(s->pb)) { if (!s->pb->seekable) {
if (stream_index < 0) { if (stream_index < 0) {
stream_index = av_find_default_stream_index(s); stream_index = av_find_default_stream_index(s);
if (stream_index < 0) if (stream_index < 0)

2
libavformat/gxfenc.c
View file

@ -634,7 +634,7 @@ static int gxf_write_header(AVFormatContext *s)
uint8_t tracks[255] = {0}; uint8_t tracks[255] = {0};
int i, media_info = 0; int i, media_info = 0;
if (url_is_streamed(pb)) { if (!pb->seekable) {
av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, patch welcome"); av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, patch welcome");
return -1; return -1;
} }

2
libavformat/id3v1.c
View file

@ -229,7 +229,7 @@ void ff_id3v1_read(AVFormatContext *s)
uint8_t buf[ID3v1_TAG_SIZE]; uint8_t buf[ID3v1_TAG_SIZE];
int64_t filesize, position = avio_tell(s->pb); int64_t filesize, position = avio_tell(s->pb);
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
/* XXX: change that */ /* XXX: change that */
filesize = avio_size(s->pb); filesize = avio_size(s->pb);
if (filesize > 128) { if (filesize > 128) {

2
libavformat/matroskadec.c
View file

@ -1120,7 +1120,7 @@ static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
int i; int i;
// we should not do any seeking in the streaming case // we should not do any seeking in the streaming case
if (url_is_streamed(matroska->ctx->pb) || if (!matroska->ctx->pb->seekable ||
(matroska->ctx->flags & AVFMT_FLAG_IGNIDX)) (matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
return; return;

20
libavformat/matroskaenc.c
View file

@ -455,7 +455,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecCo
uint8_t *codecpriv; uint8_t *codecpriv;
int ret, codecpriv_size; int ret, codecpriv_size;
ret = url_open_dyn_buf(&dyn_cp); ret = avio_open_dyn_buf(&dyn_cp);
if(ret < 0) if(ret < 0)
return ret; return ret;
@ -498,7 +498,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecCo
ff_put_wav_header(dyn_cp, codec); ff_put_wav_header(dyn_cp, codec);
} }
codecpriv_size = url_close_dyn_buf(dyn_cp, &codecpriv); codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
if (codecpriv_size) if (codecpriv_size)
put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size); put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size);
av_free(codecpriv); av_free(codecpriv);
@ -852,7 +852,7 @@ static int mkv_write_header(AVFormatContext *s)
if (ret < 0) return ret; if (ret < 0) return ret;
} }
if (url_is_streamed(s->pb)) if (!s->pb->seekable)
mkv_write_seekhead(pb, mkv->main_seekhead); mkv_write_seekhead(pb, mkv->main_seekhead);
mkv->cues = mkv_start_cues(mkv->segment_offset); mkv->cues = mkv_start_cues(mkv->segment_offset);
@ -1007,7 +1007,7 @@ static void mkv_flush_dynbuf(AVFormatContext *s)
if (!mkv->dyn_bc) if (!mkv->dyn_bc)
return; return;
bufsize = url_close_dyn_buf(mkv->dyn_bc, &dyn_buf); bufsize = avio_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
avio_write(s->pb, dyn_buf, bufsize); avio_write(s->pb, dyn_buf, bufsize);
av_free(dyn_buf); av_free(dyn_buf);
mkv->dyn_bc = NULL; mkv->dyn_bc = NULL;
@ -1028,9 +1028,9 @@ static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (url_is_streamed(s->pb)) { if (!s->pb->seekable) {
if (!mkv->dyn_bc) if (!mkv->dyn_bc)
url_open_dyn_buf(&mkv->dyn_bc); avio_open_dyn_buf(&mkv->dyn_bc);
pb = mkv->dyn_bc; pb = mkv->dyn_bc;
} }
@ -1080,16 +1080,16 @@ static int mkv_copy_packet(MatroskaMuxContext *mkv, const AVPacket *pkt)
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt) static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
MatroskaMuxContext *mkv = s->priv_data; MatroskaMuxContext *mkv = s->priv_data;
AVIOContext *pb = url_is_streamed(s->pb) ? mkv->dyn_bc : s->pb; AVIOContext *pb = s->pb->seekable ? s->pb : mkv->dyn_bc;
AVCodecContext *codec = s->streams[pkt->stream_index]->codec; AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
int ret, keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY); int ret, keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts; int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
int cluster_size = avio_tell(pb) - (url_is_streamed(s->pb) ? 0 : mkv->cluster_pos); int cluster_size = avio_tell(pb) - (s->pb->seekable ? mkv->cluster_pos : 0);
// start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
// after 4k and on a keyframe // after 4k and on a keyframe
if (mkv->cluster_pos && if (mkv->cluster_pos &&
((url_is_streamed(s->pb) && (cluster_size > 32*1024 || ts > mkv->cluster_pts + 1000)) ((!s->pb->seekable && (cluster_size > 32*1024 || ts > mkv->cluster_pts + 1000))
|| cluster_size > 5*1024*1024 || ts > mkv->cluster_pts + 5000 || cluster_size > 5*1024*1024 || ts > mkv->cluster_pts + 5000
|| (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe && cluster_size > 4*1024))) { || (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe && cluster_size > 4*1024))) {
av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64 av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
@ -1143,7 +1143,7 @@ static int mkv_write_trailer(AVFormatContext *s)
end_ebml_master(pb, mkv->cluster); end_ebml_master(pb, mkv->cluster);
} }
if (!url_is_streamed(pb)) { if (pb->seekable) {
cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams); cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams);
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos); ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos);

2
libavformat/mmf.c
View file

@ -133,7 +133,7 @@ static int mmf_write_trailer(AVFormatContext *s)
int64_t pos, size; int64_t pos, size;
int gatetime; int gatetime;
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
/* Fill in length fields */ /* Fill in length fields */
end_tag_be(pb, mmf->awapos); end_tag_be(pb, mmf->awapos);
end_tag_be(pb, mmf->atrpos); end_tag_be(pb, mmf->atrpos);

12
libavformat/mov.c
View file

@ -304,7 +304,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
if (err < 0) if (err < 0)
return err; return err;
if (c->found_moov && c->found_mdat && if (c->found_moov && c->found_mdat &&
(url_is_streamed(pb) || start_pos + a.size == avio_size(pb))) (!pb->seekable || start_pos + a.size == avio_size(pb)))
return 0; return 0;
left = a.size - avio_tell(pb) + start_pos; left = a.size - avio_tell(pb) + start_pos;
if (left > 0) /* skip garbage at atom end */ if (left > 0) /* skip garbage at atom end */
@ -2354,7 +2354,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
mov->fc = s; mov->fc = s;
/* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */ /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
if(!url_is_streamed(pb)) if(pb->seekable)
atom.size = avio_size(pb); atom.size = avio_size(pb);
else else
atom.size = INT64_MAX; atom.size = INT64_MAX;
@ -2370,7 +2370,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }
av_dlog(mov->fc, "on_parse_exit_offset=%lld\n", avio_tell(pb)); av_dlog(mov->fc, "on_parse_exit_offset=%lld\n", avio_tell(pb));
if (!url_is_streamed(pb) && mov->chapter_track > 0) if (pb->seekable && mov->chapter_track > 0)
mov_read_chapters(s); mov_read_chapters(s);
return 0; return 0;
@ -2388,8 +2388,8 @@ static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample]; AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale); int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts); av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
if (!sample || (url_is_streamed(s->pb) && current_sample->pos < sample->pos) || if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) ||
(!url_is_streamed(s->pb) && (s->pb->seekable &&
((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) || ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
(FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) { (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
@ -2413,7 +2413,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
sample = mov_find_next_sample(s, &st); sample = mov_find_next_sample(s, &st);
if (!sample) { if (!sample) {
mov->found_mdat = 0; mov->found_mdat = 0;
if (!url_is_streamed(s->pb) || if (s->pb->seekable||
mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 || mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
url_feof(s->pb)) url_feof(s->pb))
return AVERROR_EOF; return AVERROR_EOF;

8
libavformat/movenc.c
View file

@ -1653,7 +1653,7 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
return 0; return 0;
} }
ret = url_open_dyn_buf(&pb_buf); ret = avio_open_dyn_buf(&pb_buf);
if(ret < 0) if(ret < 0)
return ret; return ret;
@ -1684,7 +1684,7 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
if (s->nb_chapters) if (s->nb_chapters)
mov_write_chpl_tag(pb_buf, s); mov_write_chpl_tag(pb_buf, s);
if ((size = url_close_dyn_buf(pb_buf, &buf)) > 0) { if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) {
avio_wb32(pb, size+8); avio_wb32(pb, size+8);
ffio_wfourcc(pb, "udta"); ffio_wfourcc(pb, "udta");
avio_write(pb, buf, size); avio_write(pb, buf, size);
@ -1948,7 +1948,7 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
unsigned int samplesInChunk = 0; unsigned int samplesInChunk = 0;
int size= pkt->size; int size= pkt->size;
if (url_is_streamed(s->pb)) return 0; /* Can't handle that */ if (!s->pb->seekable) return 0; /* Can't handle that */
if (!size) return 0; /* Discard 0 sized packets */ if (!size) return 0; /* Discard 0 sized packets */
if (enc->codec_id == CODEC_ID_AMR_NB) { if (enc->codec_id == CODEC_ID_AMR_NB) {
@ -2083,7 +2083,7 @@ static int mov_write_header(AVFormatContext *s)
MOVMuxContext *mov = s->priv_data; MOVMuxContext *mov = s->priv_data;
int i, hint_track = 0; int i, hint_track = 0;
if (url_is_streamed(s->pb)) { if (!s->pb->seekable) {
av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n"); av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
return -1; return -1;
} }

11
libavformat/movenchint.c
View file

@ -23,6 +23,7 @@
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "internal.h" #include "internal.h"
#include "rtpenc_chain.h" #include "rtpenc_chain.h"
#include "avio_internal.h"
int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index) int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
{ {
@ -408,8 +409,8 @@ int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt,
/* Fetch the output from the RTP muxer, open a new output buffer /* Fetch the output from the RTP muxer, open a new output buffer
* for next time. */ * for next time. */
size = url_close_dyn_buf(rtp_ctx->pb, &buf); size = avio_close_dyn_buf(rtp_ctx->pb, &buf);
if ((ret = url_open_dyn_packet_buf(&rtp_ctx->pb, if ((ret = ffio_open_dyn_packet_buf(&rtp_ctx->pb,
RTP_MAX_PACKET_SIZE)) < 0) RTP_MAX_PACKET_SIZE)) < 0)
goto done; goto done;
@ -417,14 +418,14 @@ int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt,
goto done; goto done;
/* Open a buffer for writing the hint */ /* Open a buffer for writing the hint */
if ((ret = url_open_dyn_buf(&hintbuf)) < 0) if ((ret = avio_open_dyn_buf(&hintbuf)) < 0)
goto done; goto done;
av_init_packet(&hint_pkt); av_init_packet(&hint_pkt);
count = write_hint_packets(hintbuf, buf, size, trk, &hint_pkt.dts); count = write_hint_packets(hintbuf, buf, size, trk, &hint_pkt.dts);
av_freep(&buf); av_freep(&buf);
/* Write the hint data into the hint track */ /* Write the hint data into the hint track */
hint_pkt.size = size = url_close_dyn_buf(hintbuf, &buf); hint_pkt.size = size = avio_close_dyn_buf(hintbuf, &buf);
hint_pkt.data = buf; hint_pkt.data = buf;
hint_pkt.pts = hint_pkt.dts; hint_pkt.pts = hint_pkt.dts;
hint_pkt.stream_index = track_index; hint_pkt.stream_index = track_index;
@ -448,7 +449,7 @@ void ff_mov_close_hinting(MOVTrack *track) {
return; return;
if (rtp_ctx->pb) { if (rtp_ctx->pb) {
av_write_trailer(rtp_ctx); av_write_trailer(rtp_ctx);
url_close_dyn_buf(rtp_ctx->pb, &ptr); avio_close_dyn_buf(rtp_ctx->pb, &ptr);
av_free(ptr); av_free(ptr);
} }
avformat_free_context(rtp_ctx); avformat_free_context(rtp_ctx);

4
libavformat/mp3enc.c
View file

@ -96,7 +96,7 @@ static int id3v2_put_ttag(AVFormatContext *s, const char *str1, const char *str2
uint8_t *pb; uint8_t *pb;
int (*put)(AVIOContext*, const char*); int (*put)(AVIOContext*, const char*);
AVIOContext *dyn_buf; AVIOContext *dyn_buf;
if (url_open_dyn_buf(&dyn_buf) < 0) if (avio_open_dyn_buf(&dyn_buf) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
/* check if the strings are ASCII-only and use UTF16 only if /* 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
put(dyn_buf, str1); put(dyn_buf, str1);
if (str2) if (str2)
put(dyn_buf, str2); put(dyn_buf, str2);
len = url_close_dyn_buf(dyn_buf, &pb); len = avio_close_dyn_buf(dyn_buf, &pb);
avio_wb32(s->pb, tag); avio_wb32(s->pb, tag);
id3v2_put_size(s, len); id3v2_put_size(s, len);

2
libavformat/mpc.c
View file

@ -93,7 +93,7 @@ static int mpc_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->duration = c->fcount; st->duration = c->fcount;
/* try to read APE tags */ /* try to read APE tags */
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
int64_t pos = avio_tell(s->pb); int64_t pos = avio_tell(s->pb);
ff_ape_parse_tag(s); ff_ape_parse_tag(s);
if (!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX)) if (!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))

2
libavformat/mpeg.c
View file

@ -403,7 +403,7 @@ static int mpegps_read_pes_header(AVFormatContext *s,
int i; int i;
for(i=0; i<s->nb_streams; i++){ for(i=0; i<s->nb_streams; i++){
if(startcode == s->streams[i]->id && if(startcode == s->streams[i]->id &&
!url_is_streamed(s->pb) /* index useless on streams anyway */) { s->pb->seekable /* index useless on streams anyway */) {
ff_reduce_index(s, i); ff_reduce_index(s, i);
av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */); av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
} }

2
libavformat/mxfenc.c
View file

@ -1784,7 +1784,7 @@ static int mxf_write_footer(AVFormatContext *s)
mxf_write_klv_fill(s); mxf_write_klv_fill(s);
mxf_write_random_index_pack(s); mxf_write_random_index_pack(s);
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
avio_seek(pb, 0, SEEK_SET); avio_seek(pb, 0, SEEK_SET);
if (mxf->edit_unit_byte_count) { if (mxf->edit_unit_byte_count) {
mxf_write_partition(s, 1, 2, header_closed_partition_key, 1); mxf_write_partition(s, 1, 2, header_closed_partition_key, 1);

2
libavformat/nutdec.c
View file

@ -653,7 +653,7 @@ static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
s->data_offset= pos-8; s->data_offset= pos-8;
if(!url_is_streamed(bc)){ if(bc->seekable){
int64_t orig_pos= avio_tell(bc); int64_t orig_pos= avio_tell(bc);
find_and_decode_index(nut); find_and_decode_index(nut);
avio_seek(bc, orig_pos, SEEK_SET); avio_seek(bc, orig_pos, SEEK_SET);

30
libavformat/nutenc.c
View file

@ -281,7 +281,7 @@ static inline void put_s_trace(AVIOContext *bc, int64_t v, char *file, char *fun
//FIXME remove calculate_checksum //FIXME remove calculate_checksum
static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, int calculate_checksum, uint64_t startcode){ static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc, int calculate_checksum, uint64_t startcode){
uint8_t *dyn_buf=NULL; uint8_t *dyn_buf=NULL;
int dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf); int dyn_size= avio_close_dyn_buf(dyn_bc, &dyn_buf);
int forw_ptr= dyn_size + 4*calculate_checksum; int forw_ptr= dyn_size + 4*calculate_checksum;
if(forw_ptr > 4096) if(forw_ptr > 4096)
@ -436,7 +436,7 @@ static int write_globalinfo(NUTContext *nut, AVIOContext *bc){
AVIOContext *dyn_bc; AVIOContext *dyn_bc;
uint8_t *dyn_buf=NULL; uint8_t *dyn_buf=NULL;
int count=0, dyn_size; int count=0, dyn_size;
int ret = url_open_dyn_buf(&dyn_bc); int ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
@ -450,7 +450,7 @@ static int write_globalinfo(NUTContext *nut, AVIOContext *bc){
ff_put_v(bc, count); ff_put_v(bc, count);
dyn_size= url_close_dyn_buf(dyn_bc, &dyn_buf); dyn_size= avio_close_dyn_buf(dyn_bc, &dyn_buf);
avio_write(bc, dyn_buf, dyn_size); avio_write(bc, dyn_buf, dyn_size);
av_free(dyn_buf); av_free(dyn_buf);
return 0; return 0;
@ -462,7 +462,7 @@ static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
AVIOContext *dyn_bc; AVIOContext *dyn_bc;
uint8_t *dyn_buf=NULL; uint8_t *dyn_buf=NULL;
int count=0, dyn_size, i; int count=0, dyn_size, i;
int ret = url_open_dyn_buf(&dyn_bc); int ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
@ -470,7 +470,7 @@ static int write_streaminfo(NUTContext *nut, AVIOContext *bc, int stream_id){
if (st->disposition & ff_nut_dispositions[i].flag) if (st->disposition & ff_nut_dispositions[i].flag)
count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str); count += add_info(dyn_bc, "Disposition", ff_nut_dispositions[i].str);
} }
dyn_size = url_close_dyn_buf(dyn_bc, &dyn_buf); dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
if (count) { if (count) {
ff_put_v(bc, stream_id + 1); //stream_id_plus1 ff_put_v(bc, stream_id + 1); //stream_id_plus1
@ -495,7 +495,7 @@ static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
AVChapter *ch = nut->avf->chapters[id]; AVChapter *ch = nut->avf->chapters[id];
int ret, dyn_size, count = 0; int ret, dyn_size, count = 0;
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -509,7 +509,7 @@ static int write_chapter(NUTContext *nut, AVIOContext *bc, int id)
ff_put_v(bc, count); ff_put_v(bc, count);
dyn_size = url_close_dyn_buf(dyn_bc, &dyn_buf); dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
avio_write(bc, dyn_buf, dyn_size); avio_write(bc, dyn_buf, dyn_size);
av_freep(&dyn_buf); av_freep(&dyn_buf);
return 0; return 0;
@ -522,14 +522,14 @@ static int write_headers(AVFormatContext *avctx, AVIOContext *bc){
ff_metadata_conv_ctx(avctx, ff_nut_metadata_conv, NULL); ff_metadata_conv_ctx(avctx, ff_nut_metadata_conv, NULL);
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
write_mainheader(nut, dyn_bc); write_mainheader(nut, dyn_bc);
put_packet(nut, bc, dyn_bc, 1, MAIN_STARTCODE); put_packet(nut, bc, dyn_bc, 1, MAIN_STARTCODE);
for (i=0; i < nut->avf->nb_streams; i++){ for (i=0; i < nut->avf->nb_streams; i++){
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
if ((ret = write_streamheader(avctx, dyn_bc, nut->avf->streams[i], i)) < 0) 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){
put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE); put_packet(nut, bc, dyn_bc, 1, STREAM_STARTCODE);
} }
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
write_globalinfo(nut, dyn_bc); write_globalinfo(nut, dyn_bc);
put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE); put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
for (i = 0; i < nut->avf->nb_streams; i++) { for (i = 0; i < nut->avf->nb_streams; i++) {
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
ret = write_streaminfo(nut, dyn_bc, i); ret = write_streaminfo(nut, dyn_bc, i);
@ -554,19 +554,19 @@ static int write_headers(AVFormatContext *avctx, AVIOContext *bc){
put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE); put_packet(nut, bc, dyn_bc, 1, INFO_STARTCODE);
else { else {
uint8_t* buf; uint8_t* buf;
url_close_dyn_buf(dyn_bc, &buf); avio_close_dyn_buf(dyn_bc, &buf);
av_free(buf); av_free(buf);
} }
} }
for (i = 0; i < nut->avf->nb_chapters; i++) { for (i = 0; i < nut->avf->nb_chapters; i++) {
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = write_chapter(nut, dyn_bc, i); ret = write_chapter(nut, dyn_bc, i);
if (ret < 0) { if (ret < 0) {
uint8_t *buf; uint8_t *buf;
url_close_dyn_buf(dyn_bc, &buf); avio_close_dyn_buf(dyn_bc, &buf);
av_freep(&buf); av_freep(&buf);
return ret; return ret;
} }
@ -728,7 +728,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt){
NULL); NULL);
nut->last_syncpoint_pos= avio_tell(bc); nut->last_syncpoint_pos= avio_tell(bc);
ret = url_open_dyn_buf(&dyn_bc); ret = avio_open_dyn_buf(&dyn_bc);
if(ret < 0) if(ret < 0)
return ret; return ret;
put_tt(nut, nus->time_base, dyn_bc, pkt->dts); put_tt(nut, nus->time_base, dyn_bc, pkt->dts);

2
libavformat/oggdec.c
View file

@ -455,7 +455,7 @@ ogg_get_length (AVFormatContext * s)
int i; int i;
int64_t size, end; int64_t size, end;
if(url_is_streamed(s->pb)) if(!s->pb->seekable)
return 0; return 0;
// already set // already set

4
libavformat/oggenc.c
View file

@ -82,7 +82,7 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
int ret, size; int ret, size;
uint8_t *buf; uint8_t *buf;
ret = url_open_dyn_buf(&pb); ret = avio_open_dyn_buf(&pb);
if (ret < 0) if (ret < 0)
return ret; return ret;
ffio_init_checksum(pb, ff_crc04C11DB7_update, 0); ffio_init_checksum(pb, ff_crc04C11DB7_update, 0);
@ -101,7 +101,7 @@ static int ogg_write_page(AVFormatContext *s, OGGPage *page, int extra_flags)
ogg_update_checksum(s, pb, crc_offset); ogg_update_checksum(s, pb, crc_offset);
avio_flush(pb); avio_flush(pb);
size = url_close_dyn_buf(pb, &buf); size = avio_close_dyn_buf(pb, &buf);
if (size < 0) if (size < 0)
return size; return size;

2
libavformat/r3d.c
View file

@ -177,7 +177,7 @@ static int r3d_read_header(AVFormatContext *s, AVFormatParameters *ap)
s->data_offset = avio_tell(s->pb); s->data_offset = avio_tell(s->pb);
av_dlog(s, "data offset %#llx\n", s->data_offset); av_dlog(s, "data offset %#llx\n", s->data_offset);
if (url_is_streamed(s->pb)) if (!s->pb->seekable)
return 0; return 0;
// find REOB/REOF/REOS to load index // find REOB/REOF/REOS to load index
avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET); avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET);

2
libavformat/rmdec.c
View file

@ -481,7 +481,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (!data_off) if (!data_off)
data_off = avio_tell(pb) - 18; data_off = avio_tell(pb) - 18;
if (indx_off && !url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX) && if (indx_off && pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
avio_seek(pb, indx_off, SEEK_SET) >= 0) { avio_seek(pb, indx_off, SEEK_SET) >= 0) {
rm_read_index(s); rm_read_index(s);
avio_seek(pb, data_off + 18, SEEK_SET); avio_seek(pb, data_off + 18, SEEK_SET);

6
libavformat/rmenc.c
View file

@ -118,7 +118,7 @@ static int rv10_write_header(AVFormatContext *ctx,
avio_wb32(s, 0); /* data offset : will be patched after */ avio_wb32(s, 0); /* data offset : will be patched after */
avio_wb16(s, ctx->nb_streams); /* num streams */ avio_wb16(s, ctx->nb_streams); /* num streams */
flags = 1 | 2; /* save allowed & perfect play */ flags = 1 | 2; /* save allowed & perfect play */
if (url_is_streamed(s)) if (!s->seekable)
flags |= 4; /* live broadcast */ flags |= 4; /* live broadcast */
avio_wb16(s, flags); avio_wb16(s, flags);
@ -170,7 +170,7 @@ static int rv10_write_header(AVFormatContext *ctx,
avio_wb32(s, 0); /* start time */ avio_wb32(s, 0); /* start time */
avio_wb32(s, BUFFER_DURATION); /* preroll */ avio_wb32(s, BUFFER_DURATION); /* preroll */
/* duration */ /* duration */
if (url_is_streamed(s) || !stream->total_frames) if (!s->seekable || !stream->total_frames)
avio_wb32(s, (int)(3600 * 1000)); avio_wb32(s, (int)(3600 * 1000));
else else
avio_wb32(s, (int)(stream->total_frames * 1000 / stream->frame_rate)); avio_wb32(s, (int)(stream->total_frames * 1000 / stream->frame_rate));
@ -434,7 +434,7 @@ static int rm_write_trailer(AVFormatContext *s)
int data_size, index_pos, i; int data_size, index_pos, i;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
/* end of file: finish to write header */ /* end of file: finish to write header */
index_pos = avio_tell(pb); index_pos = avio_tell(pb);
data_size = index_pos - rm->data_pos; data_size = index_pos - rm->data_pos;

2
libavformat/rsoenc.c
View file

@ -38,7 +38,7 @@ static int rso_write_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (url_is_streamed(s->pb)) { if (!s->pb->seekable) {
av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n"); av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }

14
libavformat/rtpdec.c
View file

@ -41,7 +41,7 @@
buffer to 'rtp_write_packet' contains all the packets for ONE buffer to 'rtp_write_packet' contains all the packets for ONE
frame. Each packet should have a four byte header containing frame. Each packet should have a four byte header containing
the length in big endian format (same trick as the length in big endian format (same trick as
'url_open_dyn_packet_buf') 'ffio_open_dyn_packet_buf')
*/ */
static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = { static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {
@ -264,7 +264,7 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
return -1; return -1;
s->last_octet_count = s->octet_count; s->last_octet_count = s->octet_count;
if (url_open_dyn_buf(&pb) < 0) if (avio_open_dyn_buf(&pb) < 0)
return -1; return -1;
// Receiver Report // Receiver Report
@ -321,7 +321,7 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
} }
avio_flush(pb); avio_flush(pb);
len = url_close_dyn_buf(pb, &buf); len = avio_close_dyn_buf(pb, &buf);
if ((len > 0) && buf) { if ((len > 0) && buf) {
int result; int result;
av_dlog(s->ic, "sending %d bytes of RR\n", len); av_dlog(s->ic, "sending %d bytes of RR\n", len);
@ -339,7 +339,7 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
int len; int len;
/* Send a small RTP packet */ /* Send a small RTP packet */
if (url_open_dyn_buf(&pb) < 0) if (avio_open_dyn_buf(&pb) < 0)
return; return;
avio_w8(pb, (RTP_VERSION << 6)); avio_w8(pb, (RTP_VERSION << 6));
@ -349,13 +349,13 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
avio_wb32(pb, 0); /* SSRC */ avio_wb32(pb, 0); /* SSRC */
avio_flush(pb); avio_flush(pb);
len = url_close_dyn_buf(pb, &buf); len = avio_close_dyn_buf(pb, &buf);
if ((len > 0) && buf) if ((len > 0) && buf)
url_write(rtp_handle, buf, len); url_write(rtp_handle, buf, len);
av_free(buf); av_free(buf);
/* Send a minimal RTCP RR */ /* Send a minimal RTCP RR */
if (url_open_dyn_buf(&pb) < 0) if (avio_open_dyn_buf(&pb) < 0)
return; return;
avio_w8(pb, (RTP_VERSION << 6)); avio_w8(pb, (RTP_VERSION << 6));
@ -364,7 +364,7 @@ void rtp_send_punch_packets(URLContext* rtp_handle)
avio_wb32(pb, 0); /* our own SSRC */ avio_wb32(pb, 0); /* our own SSRC */
avio_flush(pb); avio_flush(pb);
len = url_close_dyn_buf(pb, &buf); len = avio_close_dyn_buf(pb, &buf);
if ((len > 0) && buf) if ((len > 0) && buf)
url_write(rtp_handle, buf, len); url_write(rtp_handle, buf, len);
av_free(buf); av_free(buf);

8
libavformat/rtpdec_asf.c
View file

@ -203,12 +203,12 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
*/ */
if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) { if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) {
uint8_t *p; uint8_t *p;
url_close_dyn_buf(asf->pktbuf, &p); avio_close_dyn_buf(asf->pktbuf, &p);
asf->pktbuf = NULL; asf->pktbuf = NULL;
av_free(p); av_free(p);
} }
if (!len_off && !asf->pktbuf && if (!len_off && !asf->pktbuf &&
(res = url_open_dyn_buf(&asf->pktbuf)) < 0) (res = avio_open_dyn_buf(&asf->pktbuf)) < 0)
return res; return res;
if (!asf->pktbuf) if (!asf->pktbuf)
return AVERROR(EIO); return AVERROR(EIO);
@ -217,7 +217,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
avio_skip(pb, len - off); avio_skip(pb, len - off);
if (!(flags & RTP_FLAG_MARKER)) if (!(flags & RTP_FLAG_MARKER))
return -1; return -1;
out_len = url_close_dyn_buf(asf->pktbuf, &asf->buf); out_len = avio_close_dyn_buf(asf->pktbuf, &asf->buf);
asf->pktbuf = NULL; asf->pktbuf = NULL;
} else { } else {
/** /**
@ -272,7 +272,7 @@ static void asfrtp_free_context(PayloadContext *asf)
{ {
if (asf->pktbuf) { if (asf->pktbuf) {
uint8_t *p = NULL; uint8_t *p = NULL;
url_close_dyn_buf(asf->pktbuf, &p); avio_close_dyn_buf(asf->pktbuf, &p);
asf->pktbuf = NULL; asf->pktbuf = NULL;
av_free(p); av_free(p);
} }

8
libavformat/rtpdec_latm.c
View file

@ -43,7 +43,7 @@ static void latm_free_context(PayloadContext *data)
return; return;
if (data->dyn_buf) { if (data->dyn_buf) {
uint8_t *p; uint8_t *p;
url_close_dyn_buf(data->dyn_buf, &p); avio_close_dyn_buf(data->dyn_buf, &p);
av_free(p); av_free(p);
} }
av_free(data->buf); av_free(data->buf);
@ -60,12 +60,12 @@ static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
if (!data->dyn_buf || data->timestamp != *timestamp) { if (!data->dyn_buf || data->timestamp != *timestamp) {
av_freep(&data->buf); av_freep(&data->buf);
if (data->dyn_buf) if (data->dyn_buf)
url_close_dyn_buf(data->dyn_buf, &data->buf); avio_close_dyn_buf(data->dyn_buf, &data->buf);
data->dyn_buf = NULL; data->dyn_buf = NULL;
av_freep(&data->buf); av_freep(&data->buf);
data->timestamp = *timestamp; data->timestamp = *timestamp;
if ((ret = url_open_dyn_buf(&data->dyn_buf)) < 0) if ((ret = avio_open_dyn_buf(&data->dyn_buf)) < 0)
return ret; return ret;
} }
avio_write(data->dyn_buf, buf, len); avio_write(data->dyn_buf, buf, len);
@ -73,7 +73,7 @@ static int latm_parse_packet(AVFormatContext *ctx, PayloadContext *data,
if (!(flags & RTP_FLAG_MARKER)) if (!(flags & RTP_FLAG_MARKER))
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
av_free(data->buf); av_free(data->buf);
data->len = url_close_dyn_buf(data->dyn_buf, &data->buf); data->len = avio_close_dyn_buf(data->dyn_buf, &data->buf);
data->dyn_buf = NULL; data->dyn_buf = NULL;
data->pos = 0; data->pos = 0;
} }

8
libavformat/rtpdec_svq3.c
View file

@ -83,10 +83,10 @@ static int svq3_parse_packet (AVFormatContext *s, PayloadContext *sv,
if (sv->pktbuf) { if (sv->pktbuf) {
uint8_t *tmp; uint8_t *tmp;
url_close_dyn_buf(sv->pktbuf, &tmp); avio_close_dyn_buf(sv->pktbuf, &tmp);
av_free(tmp); av_free(tmp);
} }
if ((res = url_open_dyn_buf(&sv->pktbuf)) < 0) if ((res = avio_open_dyn_buf(&sv->pktbuf)) < 0)
return res; return res;
sv->timestamp = *timestamp; sv->timestamp = *timestamp;
} }
@ -100,7 +100,7 @@ static int svq3_parse_packet (AVFormatContext *s, PayloadContext *sv,
av_init_packet(pkt); av_init_packet(pkt);
pkt->stream_index = st->index; pkt->stream_index = st->index;
*timestamp = sv->timestamp; *timestamp = sv->timestamp;
pkt->size = url_close_dyn_buf(sv->pktbuf, &pkt->data); pkt->size = avio_close_dyn_buf(sv->pktbuf, &pkt->data);
pkt->destruct = av_destruct_packet; pkt->destruct = av_destruct_packet;
sv->pktbuf = NULL; sv->pktbuf = NULL;
return 0; return 0;
@ -118,7 +118,7 @@ static void svq3_extradata_free(PayloadContext *sv)
{ {
if (sv->pktbuf) { if (sv->pktbuf) {
uint8_t *buf; uint8_t *buf;
url_close_dyn_buf(sv->pktbuf, &buf); avio_close_dyn_buf(sv->pktbuf, &buf);
av_free(buf); av_free(buf);
} }
av_free(sv); av_free(sv);

6
libavformat/rtpdec_vp8.c
View file

@ -41,7 +41,7 @@ static void prepare_packet(AVPacket *pkt, PayloadContext *vp8, int stream)
av_init_packet(pkt); av_init_packet(pkt);
pkt->stream_index = stream; pkt->stream_index = stream;
pkt->flags = vp8->is_keyframe ? AV_PKT_FLAG_KEY : 0; pkt->flags = vp8->is_keyframe ? AV_PKT_FLAG_KEY : 0;
pkt->size = url_close_dyn_buf(vp8->data, &pkt->data); pkt->size = avio_close_dyn_buf(vp8->data, &pkt->data);
pkt->destruct = av_destruct_packet; pkt->destruct = av_destruct_packet;
vp8->data = NULL; vp8->data = NULL;
} }
@ -85,7 +85,7 @@ static int vp8_handle_packet(AVFormatContext *ctx,
// that for the next av_get_packet call // that for the next av_get_packet call
ret = end_packet ? 1 : 0; ret = end_packet ? 1 : 0;
} }
if ((res = url_open_dyn_buf(&vp8->data)) < 0) if ((res = avio_open_dyn_buf(&vp8->data)) < 0)
return res; return res;
vp8->is_keyframe = *buf & 1; vp8->is_keyframe = *buf & 1;
vp8->timestamp = ts; vp8->timestamp = ts;
@ -138,7 +138,7 @@ static void vp8_free_context(PayloadContext *vp8)
{ {
if (vp8->data) { if (vp8->data) {
uint8_t *tmp; uint8_t *tmp;
url_close_dyn_buf(vp8->data, &tmp); avio_close_dyn_buf(vp8->data, &tmp);
av_free(tmp); av_free(tmp);
} }
av_free(vp8); av_free(vp8);

6
libavformat/rtpdec_xiph.c
View file

@ -57,7 +57,7 @@ static inline void free_fragment_if_needed(PayloadContext * data)
{ {
if (data->fragment) { if (data->fragment) {
uint8_t* p; uint8_t* p;
url_close_dyn_buf(data->fragment, &p); avio_close_dyn_buf(data->fragment, &p);
av_free(p); av_free(p);
data->fragment = NULL; data->fragment = NULL;
} }
@ -176,7 +176,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
// end packet has been lost somewhere, so drop buffered data // end packet has been lost somewhere, so drop buffered data
free_fragment_if_needed(data); free_fragment_if_needed(data);
if((res = url_open_dyn_buf(&data->fragment)) < 0) if((res = avio_open_dyn_buf(&data->fragment)) < 0)
return res; return res;
avio_write(data->fragment, buf, pkt_len); avio_write(data->fragment, buf, pkt_len);
@ -203,7 +203,7 @@ static int xiph_handle_packet(AVFormatContext * ctx,
if (fragmented == 3) { if (fragmented == 3) {
// end of xiph data packet // end of xiph data packet
av_init_packet(pkt); av_init_packet(pkt);
pkt->size = url_close_dyn_buf(data->fragment, &pkt->data); pkt->size = avio_close_dyn_buf(data->fragment, &pkt->data);
if (pkt->size < 0) { if (pkt->size < 0) {
av_log(ctx, AV_LOG_ERROR, av_log(ctx, AV_LOG_ERROR,

8
libavformat/rtpenc_chain.c
View file

@ -20,7 +20,9 @@
*/ */
#include "avformat.h" #include "avformat.h"
#include "avio_internal.h"
#include "rtpenc_chain.h" #include "rtpenc_chain.h"
#include "avio_internal.h"
AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st, AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
URLContext *handle, int packet_size) URLContext *handle, int packet_size)
@ -53,9 +55,9 @@ AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
avcodec_copy_context(rtpctx->streams[0]->codec, st->codec); avcodec_copy_context(rtpctx->streams[0]->codec, st->codec);
if (handle) { if (handle) {
url_fdopen(&rtpctx->pb, handle); ffio_fdopen(&rtpctx->pb, handle);
} else } else
url_open_dyn_packet_buf(&rtpctx->pb, packet_size); ffio_open_dyn_packet_buf(&rtpctx->pb, packet_size);
ret = av_write_header(rtpctx); ret = av_write_header(rtpctx);
if (ret) { if (ret) {
@ -63,7 +65,7 @@ AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
avio_close(rtpctx->pb); avio_close(rtpctx->pb);
} else { } else {
uint8_t *ptr; uint8_t *ptr;
url_close_dyn_buf(rtpctx->pb, &ptr); avio_close_dyn_buf(rtpctx->pb, &ptr);
av_free(ptr); av_free(ptr);
} }
avformat_free_context(rtpctx); avformat_free_context(rtpctx);

2
libavformat/rtsp.c
View file

@ -495,7 +495,7 @@ void ff_rtsp_undo_setup(AVFormatContext *s)
av_write_trailer(rtpctx); av_write_trailer(rtpctx);
if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) { if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
uint8_t *ptr; uint8_t *ptr;
url_close_dyn_buf(rtpctx->pb, &ptr); avio_close_dyn_buf(rtpctx->pb, &ptr);
av_free(ptr); av_free(ptr);
} else { } else {
avio_close(rtpctx->pb); avio_close(rtpctx->pb);

7
libavformat/rtspenc.c
View file

@ -29,6 +29,7 @@
#include "os_support.h" #include "os_support.h"
#include "rtsp.h" #include "rtsp.h"
#include "internal.h" #include "internal.h"
#include "avio_internal.h"
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "libavutil/avstring.h" #include "libavutil/avstring.h"
@ -135,14 +136,14 @@ static int tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
int size; int size;
uint8_t *interleave_header, *interleaved_packet; uint8_t *interleave_header, *interleaved_packet;
size = url_close_dyn_buf(rtpctx->pb, &buf); size = avio_close_dyn_buf(rtpctx->pb, &buf);
ptr = buf; ptr = buf;
while (size > 4) { while (size > 4) {
uint32_t packet_len = AV_RB32(ptr); uint32_t packet_len = AV_RB32(ptr);
int id; int id;
/* The interleaving header is exactly 4 bytes, which happens to be /* The interleaving header is exactly 4 bytes, which happens to be
* the same size as the packet length header from * the same size as the packet length header from
* url_open_dyn_packet_buf. So by writing the interleaving header * ffio_open_dyn_packet_buf. So by writing the interleaving header
* over these bytes, we get a consecutive interleaved packet * over these bytes, we get a consecutive interleaved packet
* that can be written in one call. */ * that can be written in one call. */
interleaved_packet = interleave_header = ptr; interleaved_packet = interleave_header = ptr;
@ -162,7 +163,7 @@ static int tcp_write_packet(AVFormatContext *s, RTSPStream *rtsp_st)
size -= packet_len; size -= packet_len;
} }
av_free(buf); av_free(buf);
url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE); ffio_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
return 0; return 0;
} }

2
libavformat/soxenc.c
View file

@ -96,7 +96,7 @@ static int sox_write_trailer(AVFormatContext *s)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[0]->codec; AVCodecContext *enc = s->streams[0]->codec;
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
/* update number of samples */ /* update number of samples */
int64_t file_size = avio_tell(pb); int64_t file_size = avio_tell(pb);
int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL; int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;

2
libavformat/swfenc.c
View file

@ -492,7 +492,7 @@ static int swf_write_trailer(AVFormatContext *s)
avio_flush(s->pb); avio_flush(s->pb);
/* patch file size and number of frames if not streamed */ /* patch file size and number of frames if not streamed */
if (!url_is_streamed(s->pb) && video_enc) { if (s->pb->seekable && video_enc) {
file_size = avio_tell(pb); file_size = avio_tell(pb);
avio_seek(pb, 4, SEEK_SET); avio_seek(pb, 4, SEEK_SET);
avio_wl32(pb, file_size); avio_wl32(pb, file_size);

2
libavformat/tty.c
View file

@ -88,7 +88,7 @@ static int read_header(AVFormatContext *avctx,
/* simulate tty display speed */ /* simulate tty display speed */
s->chars_per_frame = FFMAX(av_q2d(st->time_base) * (ap->sample_rate ? ap->sample_rate : LINE_RATE), 1); s->chars_per_frame = FFMAX(av_q2d(st->time_base) * (ap->sample_rate ? ap->sample_rate : LINE_RATE), 1);
if (!url_is_streamed(avctx->pb)) { if (avctx->pb->seekable) {
s->fsize = avio_size(avctx->pb); s->fsize = avio_size(avctx->pb);
st->duration = (s->fsize + s->chars_per_frame - 1) / s->chars_per_frame; st->duration = (s->fsize + s->chars_per_frame - 1) / s->chars_per_frame;

2
libavformat/utils.c
View file

@ -2037,7 +2037,7 @@ static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
if ((!strcmp(ic->iformat->name, "mpeg") || if ((!strcmp(ic->iformat->name, "mpeg") ||
!strcmp(ic->iformat->name, "mpegts")) && !strcmp(ic->iformat->name, "mpegts")) &&
file_size && !url_is_streamed(ic->pb)) { file_size && ic->pb->seekable) {
/* get accurate estimate from the PTSes */ /* get accurate estimate from the PTSes */
av_estimate_timings_from_pts(ic, old_offset); av_estimate_timings_from_pts(ic, old_offset);
} else if (av_has_duration(ic)) { } else if (av_has_duration(ic)) {

2
libavformat/vc1testenc.c
View file

@ -73,7 +73,7 @@ static int vc1test_write_trailer(AVFormatContext *s)
RCVContext *ctx = s->priv_data; RCVContext *ctx = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
avio_seek(pb, 0, SEEK_SET); avio_seek(pb, 0, SEEK_SET);
avio_wl24(pb, ctx->frames); avio_wl24(pb, ctx->frames);
avio_flush(pb); avio_flush(pb);

2
libavformat/vocdec.c
View file

@ -78,7 +78,7 @@ voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
return AVERROR(EIO); return AVERROR(EIO);
voc->remaining_size = avio_rl24(pb); voc->remaining_size = avio_rl24(pb);
if (!voc->remaining_size) { if (!voc->remaining_size) {
if (url_is_streamed(s->pb)) if (!s->pb->seekable)
return AVERROR(EIO); return AVERROR(EIO);
voc->remaining_size = avio_size(pb) - avio_tell(pb); voc->remaining_size = avio_size(pb) - avio_tell(pb);
} }

4
libavformat/wav.c
View file

@ -57,7 +57,7 @@ static int wav_write_header(AVFormatContext *s)
ff_end_tag(pb, fmt); ff_end_tag(pb, fmt);
if (s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */ if (s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */
&& !url_is_streamed(s->pb)) { && s->pb->seekable) {
fact = ff_start_tag(pb, "fact"); fact = ff_start_tag(pb, "fact");
avio_wl32(pb, 0); avio_wl32(pb, 0);
ff_end_tag(pb, fact); ff_end_tag(pb, fact);
@ -97,7 +97,7 @@ static int wav_write_trailer(AVFormatContext *s)
avio_flush(pb); avio_flush(pb);
if (!url_is_streamed(s->pb)) { if (s->pb->seekable) {
ff_end_tag(pb, wav->data); ff_end_tag(pb, wav->data);
/* update file size */ /* update file size */

4
libavformat/wv.c
View file

@ -121,7 +121,7 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb, int appen
} }
if((rate == -1 || !chan) && !wc->block_parsed){ if((rate == -1 || !chan) && !wc->block_parsed){
int64_t block_end = avio_tell(pb) + wc->blksize - 24; int64_t block_end = avio_tell(pb) + wc->blksize - 24;
if(url_is_streamed(pb)){ if(!pb->seekable){
av_log(ctx, AV_LOG_ERROR, "Cannot determine additional parameters\n"); av_log(ctx, AV_LOG_ERROR, "Cannot determine additional parameters\n");
return -1; return -1;
} }
@ -223,7 +223,7 @@ static int wv_read_header(AVFormatContext *s,
st->start_time = 0; st->start_time = 0;
st->duration = wc->samples; st->duration = wc->samples;
if(!url_is_streamed(s->pb)) { if(s->pb->seekable) {
int64_t cur = avio_tell(s->pb); int64_t cur = avio_tell(s->pb);
ff_ape_parse_tag(s); ff_ape_parse_tag(s);
if(!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX)) if(!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))

2
tests/ref/acodec/ac3_fixed
View file

@ -1,2 +1,2 @@
346073c97eada69330f61e103a170ca1 *./tests/data/acodec/ac3.rm 408f47ee5a60866fc751f7bc2314cbd6 *./tests/data/acodec/ac3.rm
98751 ./tests/data/acodec/ac3.rm 98751 ./tests/data/acodec/ac3.rm

2
tests/ref/lavf/rm
View file

@ -1,2 +1,2 @@
7b7ede9548a09346675edad36acfbf19 *./tests/data/lavf/lavf.rm da74fe749c2eb21bbead7de81d2f3078 *./tests/data/lavf/lavf.rm
346706 ./tests/data/lavf/lavf.rm 346706 ./tests/data/lavf/lavf.rm