generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  vble: remove vble_error_close
  VBLE Decoder
  tta: use an integer instead of a pointer to iterate output samples
  shorten: do not modify samples pointer when interleaving
  mpc7: only support stereo input.
  dpcm: do not try to decode empty packets
  dpcm: remove unneeded buf_size==0 check.
  twinvq: add SSE/AVX optimized sum/difference stereo interleaving
  vqf/twinvq: pass vqf COMM chunk info in extradata
  vqf: do not set bits_per_coded_sample for TwinVQ.
  twinvq: check for allocation failure in init_mdct_win()
  swscale: add padding to conversion buffer.
  rtpdec: Simplify finalize_packet
  http: Handle proxy authentication
  http: Print an error message for Authorization Required, too
  AVOptions: don't return an invalid option when option list is empty
  AIFF: add 'twos' FourCC for the mux/demuxer (big endian PCM audio)

Conflicts:
	libavcodec/avcodec.h
	libavcodec/tta.c
	libavcodec/vble.c
	libavcodec/version.h
	libavutil/opt.c
	libswscale/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-11-12 02:50:25 +01:00
commit 29582df797
15 changed files with 270 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libavcodec/dpcm.c
View File

@ -179,9 +179,6 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
int stereo = s->channels - 1; int stereo = s->channels - 1;
int16_t *output_samples = data; int16_t *output_samples = data;
if (!buf_size)
return 0;
/* calculate output size */ /* calculate output size */
switch(avctx->codec->id) { switch(avctx->codec->id) {
case CODEC_ID_ROQ_DPCM: case CODEC_ID_ROQ_DPCM:
@ -201,7 +198,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
break; break;
} }
out *= av_get_bytes_per_sample(avctx->sample_fmt); out *= av_get_bytes_per_sample(avctx->sample_fmt);
if (out < 0) { if (out <= 0) {
av_log(avctx, AV_LOG_ERROR, "packet is too small\n"); av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }

13
libavcodec/dsputil.c
View File

@ -2543,6 +2543,18 @@ static void butterflies_float_c(float *restrict v1, float *restrict v2,
} }
} }
static void butterflies_float_interleave_c(float *dst, const float *src0,
const float *src1, int len)
{
int i;
for (i = 0; i < len; i++) {
float f1 = src0[i];
float f2 = src1[i];
dst[2*i ] = f1 + f2;
dst[2*i + 1] = f1 - f2;
}
}
static float scalarproduct_float_c(const float *v1, const float *v2, int len) static float scalarproduct_float_c(const float *v1, const float *v2, int len)
{ {
float p = 0.0; float p = 0.0;
@ -3066,6 +3078,7 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
c->vector_clip_int32 = vector_clip_int32_c; c->vector_clip_int32 = vector_clip_int32_c;
c->scalarproduct_float = scalarproduct_float_c; c->scalarproduct_float = scalarproduct_float_c;
c->butterflies_float = butterflies_float_c; c->butterflies_float = butterflies_float_c;
c->butterflies_float_interleave = butterflies_float_interleave_c;
c->vector_fmul_scalar = vector_fmul_scalar_c; c->vector_fmul_scalar = vector_fmul_scalar_c;
c->vector_fmac_scalar = vector_fmac_scalar_c; c->vector_fmac_scalar = vector_fmac_scalar_c;

17
libavcodec/dsputil.h
View File

@ -451,6 +451,23 @@ typedef struct DSPContext {
*/ */
void (*butterflies_float)(float *restrict v1, float *restrict v2, int len); void (*butterflies_float)(float *restrict v1, float *restrict v2, int len);
/**
* Calculate the sum and difference of two vectors of floats and interleave
* results into a separate output vector of floats, with each sum
* positioned before the corresponding difference.
*
* @param dst output vector
* constraints: 16-byte aligned
* @param src0 first input vector
* constraints: 32-byte aligned
* @param src1 second input vector
* constraints: 32-byte aligned
* @param len number of elements in the input
* constraints: multiple of 8
*/
void (*butterflies_float_interleave)(float *dst, const float *src0,
const float *src1, int len);
/* (I)DCT */ /* (I)DCT */
void (*fdct)(DCTELEM *block/* align 16*/); void (*fdct)(DCTELEM *block/* align 16*/);
void (*fdct248)(DCTELEM *block/* align 16*/); void (*fdct248)(DCTELEM *block/* align 16*/);

9
libavcodec/mpc7.c
View File

@ -61,6 +61,13 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)
static VLC_TYPE hdr_table[1 << MPC7_HDR_BITS][2]; static VLC_TYPE hdr_table[1 << MPC7_HDR_BITS][2];
static VLC_TYPE quant_tables[7224][2]; static VLC_TYPE quant_tables[7224][2];
/* Musepack SV7 is always stereo */
if (avctx->channels != 2) {
av_log_ask_for_sample(avctx, "Unsupported number of channels: %d\n",
avctx->channels);
return AVERROR_PATCHWELCOME;
}
if(avctx->extradata_size < 16){ if(avctx->extradata_size < 16){
av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size); av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
return -1; return -1;
@ -88,7 +95,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)
c->frames_to_skip = 0; c->frames_to_skip = 0;
avctx->sample_fmt = AV_SAMPLE_FMT_S16; avctx->sample_fmt = AV_SAMPLE_FMT_S16;
avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO; avctx->channel_layout = AV_CH_LAYOUT_STEREO;
if(vlc_initialized) return 0; if(vlc_initialized) return 0;
av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n"); av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");

7
libavcodec/shorten.c
View File

@ -252,12 +252,13 @@ static int decode_wave_header(AVCodecContext *avctx, const uint8_t *header,
return 0; return 0;
} }
static int16_t * interleave_buffer(int16_t *samples, int nchan, int blocksize, int32_t **buffer) { static void interleave_buffer(int16_t *samples, int nchan, int blocksize,
int32_t **buffer)
{
int i, chan; int i, chan;
for (i=0; i<blocksize; i++) for (i=0; i<blocksize; i++)
for (chan=0; chan < nchan; chan++) for (chan=0; chan < nchan; chan++)
*samples++ = av_clip_int16(buffer[chan][i]); *samples++ = av_clip_int16(buffer[chan][i]);
return samples;
} }
static const int fixed_coeffs[3][3] = { static const int fixed_coeffs[3][3] = {
@ -576,7 +577,7 @@ static int shorten_decode_frame(AVCodecContext *avctx,
av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n"); av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
samples = interleave_buffer(samples, s->channels, s->blocksize, s->decoded); interleave_buffer(samples, s->channels, s->blocksize, s->decoded);
*data_size = out_size; *data_size = out_size;
} }
} }

162
libavcodec/twinvq.c
View File

@ -665,8 +665,9 @@ static void imdct_output(TwinContext *tctx, enum FrameType ftype, int wtype,
float *out) float *out)
{ {
const ModeTab *mtab = tctx->mtab; const ModeTab *mtab = tctx->mtab;
int size1, size2;
float *prev_buf = tctx->prev_frame + tctx->last_block_pos[0]; float *prev_buf = tctx->prev_frame + tctx->last_block_pos[0];
int i, j; int i;
for (i = 0; i < tctx->avctx->channels; i++) { for (i = 0; i < tctx->avctx->channels; i++) {
imdct_and_window(tctx, ftype, wtype, imdct_and_window(tctx, ftype, wtype,
@ -675,27 +676,24 @@ static void imdct_output(TwinContext *tctx, enum FrameType ftype, int wtype,
i); i);
} }
size2 = tctx->last_block_pos[0];
size1 = mtab->size - size2;
if (tctx->avctx->channels == 2) { if (tctx->avctx->channels == 2) {
for (i = 0; i < mtab->size - tctx->last_block_pos[0]; i++) { tctx->dsp.butterflies_float_interleave(out, prev_buf,
float f1 = prev_buf[ i]; &prev_buf[2*mtab->size],
float f2 = prev_buf[2*mtab->size + i]; size1);
out[2*i ] = f1 + f2;
out[2*i + 1] = f1 - f2; out += 2 * size1;
}
for (j = 0; i < mtab->size; j++,i++) { tctx->dsp.butterflies_float_interleave(out, tctx->curr_frame,
float f1 = tctx->curr_frame[ j]; &tctx->curr_frame[2*mtab->size],
float f2 = tctx->curr_frame[2*mtab->size + j]; size2);
out[2*i ] = f1 + f2;
out[2*i + 1] = f1 - f2;
}
} else { } else {
memcpy(out, prev_buf, memcpy(out, prev_buf, size1 * sizeof(*out));
(mtab->size - tctx->last_block_pos[0]) * sizeof(*out));
out += mtab->size - tctx->last_block_pos[0]; out += size1;
memcpy(out, tctx->curr_frame, memcpy(out, tctx->curr_frame, size2 * sizeof(*out));
(tctx->last_block_pos[0]) * sizeof(*out));
} }
} }
@ -871,9 +869,9 @@ static int twin_decode_frame(AVCodecContext * avctx, void *data,
/** /**
* Init IMDCT and windowing tables * Init IMDCT and windowing tables
*/ */
static av_cold void init_mdct_win(TwinContext *tctx) static av_cold int init_mdct_win(TwinContext *tctx)
{ {
int i,j; int i, j, ret;
const ModeTab *mtab = tctx->mtab; const ModeTab *mtab = tctx->mtab;
int size_s = mtab->size / mtab->fmode[FT_SHORT].sub; int size_s = mtab->size / mtab->fmode[FT_SHORT].sub;
int size_m = mtab->size / mtab->fmode[FT_MEDIUM].sub; int size_m = mtab->size / mtab->fmode[FT_MEDIUM].sub;
@ -882,20 +880,29 @@ static av_cold void init_mdct_win(TwinContext *tctx)
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
int bsize = tctx->mtab->size/tctx->mtab->fmode[i].sub; int bsize = tctx->mtab->size/tctx->mtab->fmode[i].sub;
ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1, if ((ret = ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1,
-sqrt(norm/bsize) / (1<<15)); -sqrt(norm/bsize) / (1<<15))))
return ret;
} }
tctx->tmp_buf = av_malloc(mtab->size * sizeof(*tctx->tmp_buf)); FF_ALLOC_OR_GOTO(tctx->avctx, tctx->tmp_buf,
mtab->size * sizeof(*tctx->tmp_buf), alloc_fail);
tctx->spectrum = av_malloc(2*mtab->size*channels*sizeof(float)); FF_ALLOC_OR_GOTO(tctx->avctx, tctx->spectrum,
tctx->curr_frame = av_malloc(2*mtab->size*channels*sizeof(float)); 2 * mtab->size * channels * sizeof(*tctx->spectrum),
tctx->prev_frame = av_malloc(2*mtab->size*channels*sizeof(float)); alloc_fail);
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->curr_frame,
2 * mtab->size * channels * sizeof(*tctx->curr_frame),
alloc_fail);
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->prev_frame,
2 * mtab->size * channels * sizeof(*tctx->prev_frame),
alloc_fail);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
int m = 4*mtab->size/mtab->fmode[i].sub; int m = 4*mtab->size/mtab->fmode[i].sub;
double freq = 2*M_PI/m; double freq = 2*M_PI/m;
tctx->cos_tabs[i] = av_malloc((m/4)*sizeof(*tctx->cos_tabs)); FF_ALLOC_OR_GOTO(tctx->avctx, tctx->cos_tabs[i],
(m / 4) * sizeof(*tctx->cos_tabs[i]), alloc_fail);
for (j = 0; j <= m/8; j++) for (j = 0; j <= m/8; j++)
tctx->cos_tabs[i][j] = cos((2*j + 1)*freq); tctx->cos_tabs[i][j] = cos((2*j + 1)*freq);
@ -907,6 +914,10 @@ static av_cold void init_mdct_win(TwinContext *tctx)
ff_init_ff_sine_windows(av_log2(size_m)); ff_init_ff_sine_windows(av_log2(size_m));
ff_init_ff_sine_windows(av_log2(size_s/2)); ff_init_ff_sine_windows(av_log2(size_s/2));
ff_init_ff_sine_windows(av_log2(mtab->size)); ff_init_ff_sine_windows(av_log2(mtab->size));
return 0;
alloc_fail:
return AVERROR(ENOMEM);
} }
/** /**
@ -1068,45 +1079,6 @@ static av_cold void init_bitstream_params(TwinContext *tctx)
construct_perm_table(tctx, frametype); construct_perm_table(tctx, frametype);
} }
static av_cold int twin_decode_init(AVCodecContext *avctx)
{
TwinContext *tctx = avctx->priv_data;
int isampf = avctx->sample_rate/1000;
int ibps = avctx->bit_rate/(1000 * avctx->channels);
tctx->avctx = avctx;
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
if (avctx->channels > CHANNELS_MAX) {
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %i\n",
avctx->channels);
return -1;
}
switch ((isampf << 8) + ibps) {
case (8 <<8) + 8: tctx->mtab = &mode_08_08; break;
case (11<<8) + 8: tctx->mtab = &mode_11_08; break;
case (11<<8) + 10: tctx->mtab = &mode_11_10; break;
case (16<<8) + 16: tctx->mtab = &mode_16_16; break;
case (22<<8) + 20: tctx->mtab = &mode_22_20; break;
case (22<<8) + 24: tctx->mtab = &mode_22_24; break;
case (22<<8) + 32: tctx->mtab = &mode_22_32; break;
case (44<<8) + 40: tctx->mtab = &mode_44_40; break;
case (44<<8) + 48: tctx->mtab = &mode_44_48; break;
default:
av_log(avctx, AV_LOG_ERROR, "This version does not support %d kHz - %d kbit/s/ch mode.\n", isampf, isampf);
return -1;
}
dsputil_init(&tctx->dsp, avctx);
init_mdct_win(tctx);
init_bitstream_params(tctx);
memset_float(tctx->bark_hist[0][0], 0.1, FF_ARRAY_ELEMS(tctx->bark_hist));
return 0;
}
static av_cold int twin_decode_close(AVCodecContext *avctx) static av_cold int twin_decode_close(AVCodecContext *avctx)
{ {
TwinContext *tctx = avctx->priv_data; TwinContext *tctx = avctx->priv_data;
@ -1126,6 +1098,64 @@ static av_cold int twin_decode_close(AVCodecContext *avctx)
return 0; return 0;
} }
static av_cold int twin_decode_init(AVCodecContext *avctx)
{
int ret;
TwinContext *tctx = avctx->priv_data;
int isampf, ibps;
tctx->avctx = avctx;
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
if (!avctx->extradata || avctx->extradata_size < 12) {
av_log(avctx, AV_LOG_ERROR, "Missing or incomplete extradata\n");
return AVERROR_INVALIDDATA;
}
avctx->channels = AV_RB32(avctx->extradata ) + 1;
avctx->bit_rate = AV_RB32(avctx->extradata + 4) * 1000;
isampf = AV_RB32(avctx->extradata + 8);
switch (isampf) {
case 44: avctx->sample_rate = 44100; break;
case 22: avctx->sample_rate = 22050; break;
case 11: avctx->sample_rate = 11025; break;
default: avctx->sample_rate = isampf * 1000; break;
}
if (avctx->channels > CHANNELS_MAX) {
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %i\n",
avctx->channels);
return -1;
}
ibps = avctx->bit_rate / (1000 * avctx->channels);
switch ((isampf << 8) + ibps) {
case (8 <<8) + 8: tctx->mtab = &mode_08_08; break;
case (11<<8) + 8: tctx->mtab = &mode_11_08; break;
case (11<<8) + 10: tctx->mtab = &mode_11_10; break;
case (16<<8) + 16: tctx->mtab = &mode_16_16; break;
case (22<<8) + 20: tctx->mtab = &mode_22_20; break;
case (22<<8) + 24: tctx->mtab = &mode_22_24; break;
case (22<<8) + 32: tctx->mtab = &mode_22_32; break;
case (44<<8) + 40: tctx->mtab = &mode_44_40; break;
case (44<<8) + 48: tctx->mtab = &mode_44_48; break;
default:
av_log(avctx, AV_LOG_ERROR, "This version does not support %d kHz - %d kbit/s/ch mode.\n", isampf, isampf);
return -1;
}
dsputil_init(&tctx->dsp, avctx);
if ((ret = init_mdct_win(tctx))) {
av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
twin_decode_close(avctx);
return ret;
}
init_bitstream_params(tctx);
memset_float(tctx->bark_hist[0][0], 0.1, FF_ARRAY_ELEMS(tctx->bark_hist));
return 0;
}
AVCodec ff_twinvq_decoder = { AVCodec ff_twinvq_decoder = {
.name = "twinvq", .name = "twinvq",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,

2
libavcodec/version.h
View File

@ -21,7 +21,7 @@
#define AVCODEC_VERSION_H #define AVCODEC_VERSION_H
#define LIBAVCODEC_VERSION_MAJOR 53 #define LIBAVCODEC_VERSION_MAJOR 53
#define LIBAVCODEC_VERSION_MINOR 32 #define LIBAVCODEC_VERSION_MINOR 33
#define LIBAVCODEC_VERSION_MICRO 0 #define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

7
libavcodec/x86/dsputil_mmx.c
View File

@ -2407,6 +2407,11 @@ void ff_vector_clip_int32_int_sse2(int32_t *dst, const int32_t *src, int32_t min
void ff_vector_clip_int32_sse4 (int32_t *dst, const int32_t *src, int32_t min, void ff_vector_clip_int32_sse4 (int32_t *dst, const int32_t *src, int32_t min,
int32_t max, unsigned int len); int32_t max, unsigned int len);
extern void ff_butterflies_float_interleave_sse(float *dst, const float *src0,
const float *src1, int len);
extern void ff_butterflies_float_interleave_avx(float *dst, const float *src0,
const float *src1, int len);
void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx) void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
{ {
int mm_flags = av_get_cpu_flags(); int mm_flags = av_get_cpu_flags();
@ -2849,6 +2854,7 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
c->vector_clipf = vector_clipf_sse; c->vector_clipf = vector_clipf_sse;
#if HAVE_YASM #if HAVE_YASM
c->scalarproduct_float = ff_scalarproduct_float_sse; c->scalarproduct_float = ff_scalarproduct_float_sse;
c->butterflies_float_interleave = ff_butterflies_float_interleave_sse;
#endif #endif
} }
if (HAVE_AMD3DNOW && (mm_flags & AV_CPU_FLAG_3DNOW)) if (HAVE_AMD3DNOW && (mm_flags & AV_CPU_FLAG_3DNOW))
@ -2906,6 +2912,7 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
c->put_h264_chroma_pixels_tab[0]= ff_put_h264_chroma_mc8_10_avx; c->put_h264_chroma_pixels_tab[0]= ff_put_h264_chroma_mc8_10_avx;
c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_10_avx; c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_10_avx;
} }
c->butterflies_float_interleave = ff_butterflies_float_interleave_avx;
} }
#endif #endif
} }

48
libavcodec/x86/dsputil_yasm.asm
View File

@ -1129,3 +1129,51 @@ VECTOR_CLIP_INT32 11, 1, 1, 0
%else %else
VECTOR_CLIP_INT32 6, 1, 0, 0 VECTOR_CLIP_INT32 6, 1, 0, 0
%endif %endif
;-----------------------------------------------------------------------------
; void ff_butterflies_float_interleave(float *dst, const float *src0,
; const float *src1, int len);
;-----------------------------------------------------------------------------
%macro BUTTERFLIES_FLOAT_INTERLEAVE 0
cglobal butterflies_float_interleave, 4,4,3, dst, src0, src1, len
%ifdef ARCH_X86_64
movsxd lenq, lend
%endif
test lenq, lenq
jz .end
shl lenq, 2
lea src0q, [src0q + lenq]
lea src1q, [src1q + lenq]
lea dstq, [ dstq + 2*lenq]
neg lenq
.loop:
mova m0, [src0q + lenq]
mova m1, [src1q + lenq]
subps m2, m0, m1
addps m0, m0, m1
unpcklps m1, m0, m2
unpckhps m0, m0, m2
%if cpuflag(avx)
vextractf128 [dstq + 2*lenq ], m1, 0
vextractf128 [dstq + 2*lenq + 16], m0, 0
vextractf128 [dstq + 2*lenq + 32], m1, 1
vextractf128 [dstq + 2*lenq + 48], m0, 1
%else
mova [dstq + 2*lenq ], m1
mova [dstq + 2*lenq + mmsize], m0
%endif
add lenq, mmsize
jl .loop
%if mmsize == 32
vzeroupper
RET
%endif
.end:
REP_RET
%endmacro
INIT_XMM sse
BUTTERFLIES_FLOAT_INTERLEAVE
INIT_YMM avx
BUTTERFLIES_FLOAT_INTERLEAVE

1
libavformat/aiff.h
View File

@ -43,6 +43,7 @@ static const AVCodecTag ff_codec_aiff_tags[] = {
{ CODEC_ID_MACE6, MKTAG('M','A','C','6') }, { CODEC_ID_MACE6, MKTAG('M','A','C','6') },
{ CODEC_ID_GSM, MKTAG('G','S','M',' ') }, { CODEC_ID_GSM, MKTAG('G','S','M',' ') },
{ CODEC_ID_ADPCM_G726, MKTAG('G','7','2','6') }, { CODEC_ID_ADPCM_G726, MKTAG('G','7','2','6') },
{ CODEC_ID_PCM_S16BE, MKTAG('t','w','o','s') },
{ CODEC_ID_PCM_S16LE, MKTAG('s','o','w','t') }, { CODEC_ID_PCM_S16LE, MKTAG('s','o','w','t') },
{ CODEC_ID_ADPCM_IMA_QT, MKTAG('i','m','a','4') }, { CODEC_ID_ADPCM_IMA_QT, MKTAG('i','m','a','4') },
{ CODEC_ID_QDM2, MKTAG('Q','D','M','2') }, { CODEC_ID_QDM2, MKTAG('Q','D','M','2') },

70
libavformat/http.c
View File

@ -47,6 +47,7 @@ typedef struct {
int64_t off, filesize; int64_t off, filesize;
char location[MAX_URL_SIZE]; char location[MAX_URL_SIZE];
HTTPAuthState auth_state; HTTPAuthState auth_state;
HTTPAuthState proxy_auth_state;
char *headers; char *headers;
int willclose; /**< Set if the server correctly handles Connection: close and will close the connection after feeding us the content. */ int willclose; /**< Set if the server correctly handles Connection: close and will close the connection after feeding us the content. */
int chunked_post; int chunked_post;
@ -71,25 +72,29 @@ static const AVClass flavor ## _context_class = {\
HTTP_CLASS(http); HTTP_CLASS(http);
HTTP_CLASS(https); HTTP_CLASS(https);
static int http_connect(URLContext *h, const char *path, const char *hoststr, static int http_connect(URLContext *h, const char *path, const char *local_path,
const char *auth, int *new_location); const char *hoststr, const char *auth,
const char *proxyauth, int *new_location);
void ff_http_init_auth_state(URLContext *dest, const URLContext *src) void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
{ {
memcpy(&((HTTPContext*)dest->priv_data)->auth_state, memcpy(&((HTTPContext*)dest->priv_data)->auth_state,
&((HTTPContext*)src->priv_data)->auth_state, sizeof(HTTPAuthState)); &((HTTPContext*)src->priv_data)->auth_state, sizeof(HTTPAuthState));
memcpy(&((HTTPContext*)dest->priv_data)->proxy_auth_state,
&((HTTPContext*)src->priv_data)->proxy_auth_state,
sizeof(HTTPAuthState));
} }
/* return non zero if error */ /* return non zero if error */
static int http_open_cnx(URLContext *h) static int http_open_cnx(URLContext *h)
{ {
const char *path, *proxy_path, *lower_proto = "tcp"; const char *path, *proxy_path, *lower_proto = "tcp", *local_path;
char hostname[1024], hoststr[1024], proto[10]; char hostname[1024], hoststr[1024], proto[10];
char auth[1024]; char auth[1024], proxyauth[1024];
char path1[1024]; char path1[1024];
char buf[1024]; char buf[1024], urlbuf[1024];
int port, use_proxy, err, location_changed = 0, redirects = 0; int port, use_proxy, err, location_changed = 0, redirects = 0;
HTTPAuthType cur_auth_type; HTTPAuthType cur_auth_type, cur_proxy_auth_type;
HTTPContext *s = h->priv_data; HTTPContext *s = h->priv_data;
URLContext *hd = NULL; URLContext *hd = NULL;
@ -105,15 +110,19 @@ static int http_open_cnx(URLContext *h)
path1, sizeof(path1), s->location); path1, sizeof(path1), s->location);
ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL); ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL);
if (use_proxy) {
av_url_split(NULL, 0, auth, sizeof(auth), hostname, sizeof(hostname), &port,
NULL, 0, proxy_path);
path = s->location;
} else {
if (path1[0] == '\0') if (path1[0] == '\0')
path = "/"; path = "/";
else else
path = path1; path = path1;
local_path = path;
if (use_proxy) {
/* Reassemble the request URL without auth string - we don't
* want to leak the auth to the proxy. */
ff_url_join(urlbuf, sizeof(urlbuf), proto, NULL, hostname, port, "%s",
path1);
path = urlbuf;
av_url_split(NULL, 0, proxyauth, sizeof(proxyauth),
hostname, sizeof(hostname), &port, NULL, 0, proxy_path);
} }
if (!strcmp(proto, "https")) { if (!strcmp(proto, "https")) {
lower_proto = "tls"; lower_proto = "tls";
@ -130,7 +139,8 @@ static int http_open_cnx(URLContext *h)
s->hd = hd; s->hd = hd;
cur_auth_type = s->auth_state.auth_type; cur_auth_type = s->auth_state.auth_type;
if (http_connect(h, path, hoststr, auth, &location_changed) < 0) cur_proxy_auth_type = s->auth_state.auth_type;
if (http_connect(h, path, local_path, hoststr, auth, proxyauth, &location_changed) < 0)
goto fail; goto fail;
if (s->http_code == 401) { if (s->http_code == 401) {
if (cur_auth_type == HTTP_AUTH_NONE && s->auth_state.auth_type != HTTP_AUTH_NONE) { if (cur_auth_type == HTTP_AUTH_NONE && s->auth_state.auth_type != HTTP_AUTH_NONE) {
@ -139,6 +149,14 @@ static int http_open_cnx(URLContext *h)
} else } else
goto fail; goto fail;
} }
if (s->http_code == 407) {
if (cur_proxy_auth_type == HTTP_AUTH_NONE &&
s->proxy_auth_state.auth_type != HTTP_AUTH_NONE) {
ffurl_close(hd);
goto redo;
} else
goto fail;
}
if ((s->http_code == 301 || s->http_code == 302 || s->http_code == 303 || s->http_code == 307) if ((s->http_code == 301 || s->http_code == 302 || s->http_code == 303 || s->http_code == 307)
&& location_changed == 1) { && location_changed == 1) {
/* url moved, get next */ /* url moved, get next */
@ -236,7 +254,9 @@ static int process_line(URLContext *h, char *line, int line_count,
/* error codes are 4xx and 5xx, but regard 401 as a success, so we /* error codes are 4xx and 5xx, but regard 401 as a success, so we
* don't abort until all headers have been parsed. */ * don't abort until all headers have been parsed. */
if (s->http_code >= 400 && s->http_code < 600 && s->http_code != 401) { if (s->http_code >= 400 && s->http_code < 600 && (s->http_code != 401
|| s->auth_state.auth_type != HTTP_AUTH_NONE) &&
(s->http_code != 407 || s->proxy_auth_state.auth_type != HTTP_AUTH_NONE)) {
end += strspn(end, SPACE_CHARS); end += strspn(end, SPACE_CHARS);
av_log(h, AV_LOG_WARNING, "HTTP error %d %s\n", av_log(h, AV_LOG_WARNING, "HTTP error %d %s\n",
s->http_code, end); s->http_code, end);
@ -277,6 +297,8 @@ static int process_line(URLContext *h, char *line, int line_count,
ff_http_auth_handle_header(&s->auth_state, tag, p); ff_http_auth_handle_header(&s->auth_state, tag, p);
} else if (!av_strcasecmp (tag, "Authentication-Info")) { } else if (!av_strcasecmp (tag, "Authentication-Info")) {
ff_http_auth_handle_header(&s->auth_state, tag, p); ff_http_auth_handle_header(&s->auth_state, tag, p);
} else if (!av_strcasecmp (tag, "Proxy-Authenticate")) {
ff_http_auth_handle_header(&s->proxy_auth_state, tag, p);
} else if (!av_strcasecmp (tag, "Connection")) { } else if (!av_strcasecmp (tag, "Connection")) {
if (!strcmp(p, "close")) if (!strcmp(p, "close"))
s->willclose = 1; s->willclose = 1;
@ -293,22 +315,27 @@ static inline int has_header(const char *str, const char *header)
return av_stristart(str, header + 2, NULL) || av_stristr(str, header); return av_stristart(str, header + 2, NULL) || av_stristr(str, header);
} }
static int http_connect(URLContext *h, const char *path, const char *hoststr, static int http_connect(URLContext *h, const char *path, const char *local_path,
const char *auth, int *new_location) const char *hoststr, const char *auth,
const char *proxyauth, int *new_location)
{ {
HTTPContext *s = h->priv_data; HTTPContext *s = h->priv_data;
int post, err; int post, err;
char line[1024]; char line[1024];
char headers[1024] = ""; char headers[1024] = "";
char *authstr = NULL; char *authstr = NULL, *proxyauthstr = NULL;
int64_t off = s->off; int64_t off = s->off;
int len = 0; int len = 0;
const char *method;
/* send http header */ /* send http header */
post = h->flags & AVIO_FLAG_WRITE; post = h->flags & AVIO_FLAG_WRITE;
authstr = ff_http_auth_create_response(&s->auth_state, auth, path, method = post ? "POST" : "GET";
post ? "POST" : "GET"); authstr = ff_http_auth_create_response(&s->auth_state, auth, local_path,
method);
proxyauthstr = ff_http_auth_create_response(&s->proxy_auth_state, proxyauth,
local_path, method);
/* set default headers if needed */ /* set default headers if needed */
if (!has_header(s->headers, "\r\nUser-Agent: ")) if (!has_header(s->headers, "\r\nUser-Agent: "))
@ -336,14 +363,17 @@ static int http_connect(URLContext *h, const char *path, const char *hoststr,
"%s" "%s"
"%s" "%s"
"%s" "%s"
"%s%s"
"\r\n", "\r\n",
post ? "POST" : "GET", method,
path, path,
post && s->chunked_post ? "Transfer-Encoding: chunked\r\n" : "", post && s->chunked_post ? "Transfer-Encoding: chunked\r\n" : "",
headers, headers,
authstr ? authstr : ""); authstr ? authstr : "",
proxyauthstr ? "Proxy-" : "", proxyauthstr ? proxyauthstr : "");
av_freep(&authstr); av_freep(&authstr);
av_freep(&proxyauthstr);
if (ffurl_write(s->hd, s->buffer, strlen(s->buffer)) < 0) if (ffurl_write(s->hd, s->buffer, strlen(s->buffer)) < 0)
return AVERROR(EIO); return AVERROR(EIO);

2
libavformat/httpauth.c
View File

@ -87,7 +87,7 @@ static void choose_qop(char *qop, int size)
void ff_http_auth_handle_header(HTTPAuthState *state, const char *key, void ff_http_auth_handle_header(HTTPAuthState *state, const char *key,
const char *value) const char *value)
{ {
if (!strcmp(key, "WWW-Authenticate")) { if (!strcmp(key, "WWW-Authenticate") || !strcmp(key, "Proxy-Authenticate")) {
const char *p; const char *p;
if (av_stristart(value, "Basic ", &p) && if (av_stristart(value, "Basic ", &p) &&
state->auth_type <= HTTP_AUTH_BASIC) { state->auth_type <= HTTP_AUTH_BASIC) {

8
libavformat/rtpdec.c
View File

@ -426,7 +426,10 @@ static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestam
{ {
if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE) if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
return; /* Timestamp already set by depacketizer */ return; /* Timestamp already set by depacketizer */
if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE && timestamp != RTP_NOTS_VALUE) { if (timestamp == RTP_NOTS_VALUE)
return;
if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
int64_t addend; int64_t addend;
int delta_timestamp; int delta_timestamp;
@ -438,8 +441,7 @@ static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestam
delta_timestamp; delta_timestamp;
return; return;
} }
if (timestamp == RTP_NOTS_VALUE)
return;
if (!s->base_timestamp) if (!s->base_timestamp)
s->base_timestamp = timestamp; s->base_timestamp = timestamp;
pkt->pts = s->range_start_offset + timestamp - s->base_timestamp; pkt->pts = s->range_start_offset + timestamp - s->base_timestamp;

15
libavformat/vqf.c
View File

@ -70,6 +70,7 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
int header_size; int header_size;
int read_bitrate = 0; int read_bitrate = 0;
int size; int size;
uint8_t comm_chunk[12];
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -100,13 +101,13 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
switch(chunk_tag){ switch(chunk_tag){
case MKTAG('C','O','M','M'): case MKTAG('C','O','M','M'):
st->codec->channels = avio_rb32(s->pb) + 1; avio_read(s->pb, comm_chunk, 12);
read_bitrate = avio_rb32(s->pb); st->codec->channels = AV_RB32(comm_chunk ) + 1;
rate_flag = avio_rb32(s->pb); read_bitrate = AV_RB32(comm_chunk + 4);
rate_flag = AV_RB32(comm_chunk + 8);
avio_skip(s->pb, len-12); avio_skip(s->pb, len-12);
st->codec->bit_rate = read_bitrate*1000; st->codec->bit_rate = read_bitrate*1000;
st->codec->bits_per_coded_sample = 16;
break; break;
case MKTAG('N','A','M','E'): case MKTAG('N','A','M','E'):
add_metadata(s, "title" , len, header_size); add_metadata(s, "title" , len, header_size);
@ -193,6 +194,12 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)
c->frame_bit_len = st->codec->bit_rate*size/st->codec->sample_rate; c->frame_bit_len = st->codec->bit_rate*size/st->codec->sample_rate;
av_set_pts_info(st, 64, 1, st->codec->sample_rate); av_set_pts_info(st, 64, 1, st->codec->sample_rate);
/* put first 12 bytes of COMM chunk in extradata */
if (!(st->codec->extradata = av_malloc(12 + FF_INPUT_BUFFER_PADDING_SIZE)))
return AVERROR(ENOMEM);
st->codec->extradata_size = 12;
memcpy(st->codec->extradata, comm_chunk, 12);
return 0; return 0;
} }

5
libavutil/opt.c
View File

@ -55,9 +55,10 @@ const AVOption *av_next_option(void *obj, const AVOption *last)
const AVOption *av_opt_next(void *obj, const AVOption *last) const AVOption *av_opt_next(void *obj, const AVOption *last)
{ {
AVClass *class = *(AVClass**)obj;
if (!last && class->option[0].name) return class->option;
if (last && last[1].name) return ++last; if (last && last[1].name) return ++last;
else if (last || !(*(AVClass**)obj)->option->name) return NULL; return NULL;
else return (*(AVClass**)obj)->option;
} }
static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum) static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)