virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master: (28 commits)
  Replace usages of av_get_bits_per_sample_fmt() with av_get_bytes_per_sample().
  x86: cabac: fix register constraints for 32-bit mode
  cabac: move x86 asm to libavcodec/x86/cabac.h
  x86: h264: cast pointers to intptr_t rather than int
  x86: h264: remove hardcoded edi in decode_significance_8x8_x86()
  x86: h264: remove hardcoded esi in decode_significance[_8x8]_x86()
  x86: h264: remove hardcoded edx in decode_significance[_8x8]_x86()
  x86: h264: remove hardcoded eax in decode_significance[_8x8]_x86()
  x86: cabac: change 'a' constraint to 'r' in get_cabac_inline()
  x86: cabac: remove hardcoded esi in get_cabac_inline()
  x86: cabac: remove hardcoded edx in get_cabac_inline()
  x86: cabac: remove unused macro parameter
  x86: cabac: remove hardcoded ebx in inline asm
  x86: cabac: remove hardcoded struct offsets from inline asm
  cabac: remove inline asm under #if 0
  cabac: remove BRANCHLESS_CABAC_DECODER switch
  cabac: remove #if 0 cascade under never-set #ifdef ARCH_X86_DISABLED
  document libswscale bump
  error_resilience: skip last-MV predictor step if MVs are not available.
  error_resilience: actually add counter when adding a MV predictor.
  ...

Conflicts:
	Changelog
	libavcodec/error_resilience.c
	libavfilter/defaults.c
	libavfilter/vf_drawtext.c
	libswscale/swscale.h
	tests/ref/vsynth1/error
	tests/ref/vsynth2/error

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-06-21 03:38:25 +02:00
commit 6cbe81999b
21 changed files with 287 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog
View File

@ -18,6 +18,7 @@ version 0.7:
- 10-bit H.264 optimizations for x86 - 10-bit H.264 optimizations for x86
- lut, lutrgb, and lutyuv filters added - lut, lutrgb, and lutyuv filters added
- buffersink libavfilter sink added - buffersink libavfilter sink added
- Bump libswscale for recently reported ABI break
version 0.7_beta2: version 0.7_beta2:

2
doc/APIchanges
View File

@ -7,7 +7,7 @@ libavdevice: 2011-04-18
libavfilter: 2011-04-18 libavfilter: 2011-04-18
libavformat: 2011-04-18 libavformat: 2011-04-18
libpostproc: 2011-04-18 libpostproc: 2011-04-18
libswscale: 2011-04-18 libswscale: 2011-06-20
libavutil: 2011-04-18 libavutil: 2011-04-18

6
ffmpeg.c
View File

@ -810,8 +810,8 @@ static void do_audio_out(AVFormatContext *s,
int size_out, frame_bytes, ret, resample_changed; int size_out, frame_bytes, ret, resample_changed;
AVCodecContext *enc= ost->st->codec; AVCodecContext *enc= ost->st->codec;
AVCodecContext *dec= ist->st->codec; AVCodecContext *dec= ist->st->codec;
int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8; int osize = av_get_bytes_per_sample(enc->sample_fmt);
int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8; int isize = av_get_bytes_per_sample(dec->sample_fmt);
const int coded_bps = av_get_bits_per_sample(enc->codec->id); const int coded_bps = av_get_bits_per_sample(enc->codec->id);
need_realloc: need_realloc:
@ -1531,7 +1531,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
#endif #endif
AVPacket avpkt; AVPacket avpkt;
int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3; int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
if(ist->next_pts == AV_NOPTS_VALUE) if(ist->next_pts == AV_NOPTS_VALUE)
ist->next_pts= ist->pts; ist->next_pts= ist->pts;

2
ffplay.c
View File

@ -2010,7 +2010,7 @@ static int audio_decode_frame(VideoState *is, double *pts_ptr)
if (is->reformat_ctx) { if (is->reformat_ctx) {
const void *ibuf[6]= {is->audio_buf1}; const void *ibuf[6]= {is->audio_buf1};
void *obuf[6]= {is->audio_buf2}; void *obuf[6]= {is->audio_buf2};
int istride[6]= {av_get_bits_per_sample_fmt(dec->sample_fmt)/8}; int istride[6]= {av_get_bytes_per_sample(dec->sample_fmt)};
int ostride[6]= {2}; int ostride[6]= {2};
int len= data_size/istride[0]; int len= data_size/istride[0];
if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) { if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

2
libavcodec/aacdec.c
View File

@ -2179,7 +2179,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
} }
data_size_tmp = samples * avctx->channels * data_size_tmp = samples * avctx->channels *
(av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8); av_get_bytes_per_sample(avctx->sample_fmt);
if (*data_size < data_size_tmp) { if (*data_size < data_size_tmp) {
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n", "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",

2
libavcodec/ac3dec.c
View File

@ -1422,7 +1422,7 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
} }
} }
*data_size = s->num_blocks * 256 * avctx->channels * *data_size = s->num_blocks * 256 * avctx->channels *
(av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8); av_get_bytes_per_sample(avctx->sample_fmt);
return FFMIN(buf_size, s->frame_size); return FFMIN(buf_size, s->frame_size);
} }

4
libavcodec/alsdec.c
View File

@ -1450,7 +1450,7 @@ static int decode_frame(AVCodecContext *avctx,
// check for size of decoded data // check for size of decoded data
size = ctx->cur_frame_length * avctx->channels * size = ctx->cur_frame_length * avctx->channels *
(av_get_bits_per_sample_fmt(avctx->sample_fmt) >> 3); av_get_bytes_per_sample(avctx->sample_fmt);
if (size > *data_size) { if (size > *data_size) {
av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n"); av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n");
@ -1714,7 +1714,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) * ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) *
ctx->cur_frame_length * ctx->cur_frame_length *
avctx->channels * avctx->channels *
(av_get_bits_per_sample_fmt(avctx->sample_fmt) >> 3)); av_get_bytes_per_sample(avctx->sample_fmt));
if (!ctx->crc_buffer) { if (!ctx->crc_buffer) {
av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
decode_end(avctx); decode_end(avctx);

8
libavcodec/cabac.c
View File

@ -161,19 +161,11 @@ void ff_init_cabac_states(CABACContext *c){
ff_h264_mps_state[2*i+1]= 2*mps_state[i]+1; ff_h264_mps_state[2*i+1]= 2*mps_state[i]+1;
if( i ){ if( i ){
#ifdef BRANCHLESS_CABAC_DECODER
ff_h264_mlps_state[128-2*i-1]= 2*lps_state[i]+0; ff_h264_mlps_state[128-2*i-1]= 2*lps_state[i]+0;
ff_h264_mlps_state[128-2*i-2]= 2*lps_state[i]+1; ff_h264_mlps_state[128-2*i-2]= 2*lps_state[i]+1;
}else{ }else{
ff_h264_mlps_state[128-2*i-1]= 1; ff_h264_mlps_state[128-2*i-1]= 1;
ff_h264_mlps_state[128-2*i-2]= 0; ff_h264_mlps_state[128-2*i-2]= 0;
#else
ff_h264_lps_state[2*i+0]= 2*lps_state[i]+0;
ff_h264_lps_state[2*i+1]= 2*lps_state[i]+1;
}else{
ff_h264_lps_state[2*i+0]= 1;
ff_h264_lps_state[2*i+1]= 0;
#endif
} }
} }
} }

363
libavcodec/cabac.h
View File

@ -27,16 +27,15 @@
#ifndef AVCODEC_CABAC_H #ifndef AVCODEC_CABAC_H
#define AVCODEC_CABAC_H #define AVCODEC_CABAC_H
#include <stddef.h>
#include "put_bits.h" #include "put_bits.h"
//#undef NDEBUG //#undef NDEBUG
#include <assert.h> #include <assert.h>
#include "libavutil/x86_cpu.h"
#define CABAC_BITS 16 #define CABAC_BITS 16
#define CABAC_MASK ((1<<CABAC_BITS)-1) #define CABAC_MASK ((1<<CABAC_BITS)-1)
#define BRANCHLESS_CABAC_DECODER 1
//#define ARCH_X86_DISABLED 1
typedef struct CABACContext{ typedef struct CABACContext{
int low; int low;
@ -57,6 +56,9 @@ extern uint8_t ff_h264_mps_state[2*64]; ///< transIdxMPS
extern uint8_t ff_h264_lps_state[2*64]; ///< transIdxLPS extern uint8_t ff_h264_lps_state[2*64]; ///< transIdxLPS
extern const uint8_t ff_h264_norm_shift[512]; extern const uint8_t ff_h264_norm_shift[512];
#if ARCH_X86
# include "x86/cabac.h"
#endif
void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size); void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size); void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
@ -270,7 +272,24 @@ static void refill(CABACContext *c){
c->bytestream+= CABAC_BITS/8; c->bytestream+= CABAC_BITS/8;
} }
#if ! ( ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) ) static inline void renorm_cabac_decoder(CABACContext *c){
while(c->range < 0x100){
c->range+= c->range;
c->low+= c->low;
if(!(c->low & CABAC_MASK))
refill(c);
}
}
static inline void renorm_cabac_decoder_once(CABACContext *c){
int shift= (uint32_t)(c->range - 0x100)>>31;
c->range<<= shift;
c->low <<= shift;
if(!(c->low & CABAC_MASK))
refill(c);
}
#ifndef get_cabac_inline
static void refill2(CABACContext *c){ static void refill2(CABACContext *c){
int i, x; int i, x;
@ -288,279 +307,13 @@ static void refill2(CABACContext *c){
c->low += x<<i; c->low += x<<i;
c->bytestream+= CABAC_BITS/8; c->bytestream+= CABAC_BITS/8;
} }
#endif
static inline void renorm_cabac_decoder(CABACContext *c){
while(c->range < 0x100){
c->range+= c->range;
c->low+= c->low;
if(!(c->low & CABAC_MASK))
refill(c);
}
}
static inline void renorm_cabac_decoder_once(CABACContext *c){
#ifdef ARCH_X86_DISABLED
int temp;
#if 0
//P3:683 athlon:475
__asm__(
"lea -0x100(%0), %2 \n\t"
"shr $31, %2 \n\t" //FIXME 31->63 for x86-64
"shl %%cl, %0 \n\t"
"shl %%cl, %1 \n\t"
: "+r"(c->range), "+r"(c->low), "+c"(temp)
);
#elif 0
//P3:680 athlon:474
__asm__(
"cmp $0x100, %0 \n\t"
"setb %%cl \n\t" //FIXME 31->63 for x86-64
"shl %%cl, %0 \n\t"
"shl %%cl, %1 \n\t"
: "+r"(c->range), "+r"(c->low), "+c"(temp)
);
#elif 1
int temp2;
//P3:665 athlon:517
__asm__(
"lea -0x100(%0), %%eax \n\t"
"cltd \n\t"
"mov %0, %%eax \n\t"
"and %%edx, %0 \n\t"
"and %1, %%edx \n\t"
"add %%eax, %0 \n\t"
"add %%edx, %1 \n\t"
: "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
);
#elif 0
int temp2;
//P3:673 athlon:509
__asm__(
"cmp $0x100, %0 \n\t"
"sbb %%edx, %%edx \n\t"
"mov %0, %%eax \n\t"
"and %%edx, %0 \n\t"
"and %1, %%edx \n\t"
"add %%eax, %0 \n\t"
"add %%edx, %1 \n\t"
: "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
);
#else
int temp2;
//P3:677 athlon:511
__asm__(
"cmp $0x100, %0 \n\t"
"lea (%0, %0), %%eax \n\t"
"lea (%1, %1), %%edx \n\t"
"cmovb %%eax, %0 \n\t"
"cmovb %%edx, %1 \n\t"
: "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
);
#endif
#else
//P3:675 athlon:476
int shift= (uint32_t)(c->range - 0x100)>>31;
c->range<<= shift;
c->low <<= shift;
#endif
if(!(c->low & CABAC_MASK))
refill(c);
}
static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){ static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){
//FIXME gcc generates duplicate load/stores for c->low and c->range
#define LOW "0"
#define RANGE "4"
#if ARCH_X86_64
#define BYTESTART "16"
#define BYTE "24"
#define BYTEEND "32"
#else
#define BYTESTART "12"
#define BYTE "16"
#define BYTEEND "20"
#endif
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
int bit;
#ifndef BRANCHLESS_CABAC_DECODER
__asm__ volatile(
"movzbl (%1), %0 \n\t"
"movl "RANGE "(%2), %%ebx \n\t"
"movl "RANGE "(%2), %%edx \n\t"
"andl $0xC0, %%ebx \n\t"
"movzbl "MANGLE(ff_h264_lps_range)"(%0, %%ebx, 2), %%esi\n\t"
"movl "LOW "(%2), %%ebx \n\t"
//eax:state ebx:low, edx:range, esi:RangeLPS
"subl %%esi, %%edx \n\t"
"movl %%edx, %%ecx \n\t"
"shll $17, %%ecx \n\t"
"cmpl %%ecx, %%ebx \n\t"
" ja 1f \n\t"
#if 1
//athlon:4067 P3:4110
"lea -0x100(%%edx), %%ecx \n\t"
"shr $31, %%ecx \n\t"
"shl %%cl, %%edx \n\t"
"shl %%cl, %%ebx \n\t"
#else
//athlon:4057 P3:4130
"cmp $0x100, %%edx \n\t" //FIXME avoidable
"setb %%cl \n\t"
"shl %%cl, %%edx \n\t"
"shl %%cl, %%ebx \n\t"
#endif
"movzbl "MANGLE(ff_h264_mps_state)"(%0), %%ecx \n\t"
"movb %%cl, (%1) \n\t"
//eax:state ebx:low, edx:range, esi:RangeLPS
"test %%bx, %%bx \n\t"
" jnz 2f \n\t"
"mov "BYTE "(%2), %%"REG_S" \n\t"
"subl $0xFFFF, %%ebx \n\t"
"movzwl (%%"REG_S"), %%ecx \n\t"
"bswap %%ecx \n\t"
"shrl $15, %%ecx \n\t"
"add $2, %%"REG_S" \n\t"
"addl %%ecx, %%ebx \n\t"
"mov %%"REG_S", "BYTE "(%2) \n\t"
"jmp 2f \n\t"
"1: \n\t"
//eax:state ebx:low, edx:range, esi:RangeLPS
"subl %%ecx, %%ebx \n\t"
"movl %%esi, %%edx \n\t"
"movzbl " MANGLE(ff_h264_norm_shift) "(%%esi), %%ecx \n\t"
"shll %%cl, %%ebx \n\t"
"shll %%cl, %%edx \n\t"
"movzbl "MANGLE(ff_h264_lps_state)"(%0), %%ecx \n\t"
"movb %%cl, (%1) \n\t"
"add $1, %0 \n\t"
"test %%bx, %%bx \n\t"
" jnz 2f \n\t"
"mov "BYTE "(%2), %%"REG_c" \n\t"
"movzwl (%%"REG_c"), %%esi \n\t"
"bswap %%esi \n\t"
"shrl $15, %%esi \n\t"
"subl $0xFFFF, %%esi \n\t"
"add $2, %%"REG_c" \n\t"
"mov %%"REG_c", "BYTE "(%2) \n\t"
"leal -1(%%ebx), %%ecx \n\t"
"xorl %%ebx, %%ecx \n\t"
"shrl $15, %%ecx \n\t"
"movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx \n\t"
"neg %%ecx \n\t"
"add $7, %%ecx \n\t"
"shll %%cl , %%esi \n\t"
"addl %%esi, %%ebx \n\t"
"2: \n\t"
"movl %%edx, "RANGE "(%2) \n\t"
"movl %%ebx, "LOW "(%2) \n\t"
:"=&a"(bit) //FIXME this is fragile gcc either runs out of registers or miscompiles it (for example if "+a"(bit) or "+m"(*state) is used
:"r"(state), "r"(c)
: "%"REG_c, "%ebx", "%edx", "%"REG_S, "memory"
);
bit&=1;
#else /* BRANCHLESS_CABAC_DECODER */
#if HAVE_FAST_CMOV
#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
"mov "tmp" , %%ecx \n\t"\
"shl $17 , "tmp" \n\t"\
"cmp "low" , "tmp" \n\t"\
"cmova %%ecx , "range" \n\t"\
"sbb %%ecx , %%ecx \n\t"\
"and %%ecx , "tmp" \n\t"\
"sub "tmp" , "low" \n\t"\
"xor %%ecx , "ret" \n\t"
#else /* HAVE_FAST_CMOV */
#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
"mov "tmp" , %%ecx \n\t"\
"shl $17 , "tmp" \n\t"\
"sub "low" , "tmp" \n\t"\
"sar $31 , "tmp" \n\t" /*lps_mask*/\
"sub %%ecx , "range" \n\t" /*RangeLPS - range*/\
"and "tmp" , "range" \n\t" /*(RangeLPS - range)&lps_mask*/\
"add %%ecx , "range" \n\t" /*new range*/\
"shl $17 , %%ecx \n\t"\
"and "tmp" , %%ecx \n\t"\
"sub %%ecx , "low" \n\t"\
"xor "tmp" , "ret" \n\t"
#endif /* HAVE_FAST_CMOV */
#define BRANCHLESS_GET_CABAC(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
"movzbl "statep" , "ret" \n\t"\
"mov "range" , "tmp" \n\t"\
"and $0xC0 , "range" \n\t"\
"movzbl "MANGLE(ff_h264_lps_range)"("ret", "range", 2), "range" \n\t"\
"sub "range" , "tmp" \n\t"\
BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
"movzbl " MANGLE(ff_h264_norm_shift) "("range"), %%ecx \n\t"\
"shl %%cl , "range" \n\t"\
"movzbl "MANGLE(ff_h264_mlps_state)"+128("ret"), "tmp" \n\t"\
"mov "tmpbyte" , "statep" \n\t"\
"shl %%cl , "low" \n\t"\
"test "lowword" , "lowword" \n\t"\
" jnz 1f \n\t"\
"mov "BYTE"("cabac"), %%"REG_c" \n\t"\
"movzwl (%%"REG_c") , "tmp" \n\t"\
"bswap "tmp" \n\t"\
"shr $15 , "tmp" \n\t"\
"sub $0xFFFF , "tmp" \n\t"\
"add $2 , %%"REG_c" \n\t"\
"mov %%"REG_c" , "BYTE "("cabac") \n\t"\
"lea -1("low") , %%ecx \n\t"\
"xor "low" , %%ecx \n\t"\
"shr $15 , %%ecx \n\t"\
"movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx \n\t"\
"neg %%ecx \n\t"\
"add $7 , %%ecx \n\t"\
"shl %%cl , "tmp" \n\t"\
"add "tmp" , "low" \n\t"\
"1: \n\t"
__asm__ volatile(
"movl "RANGE "(%2), %%esi \n\t"
"movl "LOW "(%2), %%ebx \n\t"
BRANCHLESS_GET_CABAC("%0", "%2", "(%1)", "%%ebx", "%%bx", "%%esi", "%%edx", "%%dl")
"movl %%esi, "RANGE "(%2) \n\t"
"movl %%ebx, "LOW "(%2) \n\t"
:"=&a"(bit)
:"r"(state), "r"(c)
: "%"REG_c, "%ebx", "%edx", "%esi", "memory"
);
bit&=1;
#endif /* BRANCHLESS_CABAC_DECODER */
#else /* ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) */
int s = *state; int s = *state;
int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s]; int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
int bit, lps_mask av_unused; int bit, lps_mask;
c->range -= RangeLPS; c->range -= RangeLPS;
#ifndef BRANCHLESS_CABAC_DECODER
if(c->low < (c->range<<(CABAC_BITS+1))){
bit= s&1;
*state= ff_h264_mps_state[s];
renorm_cabac_decoder_once(c);
}else{
bit= ff_h264_norm_shift[RangeLPS];
c->low -= (c->range<<(CABAC_BITS+1));
*state= ff_h264_lps_state[s];
c->range = RangeLPS<<bit;
c->low <<= bit;
bit= (s&1)^1;
if(!(c->low & CABAC_MASK)){
refill2(c);
}
}
#else /* BRANCHLESS_CABAC_DECODER */
lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31; lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;
c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask; c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
@ -575,10 +328,9 @@ static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const st
c->low <<= lps_mask; c->low <<= lps_mask;
if(!(c->low & CABAC_MASK)) if(!(c->low & CABAC_MASK))
refill2(c); refill2(c);
#endif /* BRANCHLESS_CABAC_DECODER */
#endif /* ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) */
return bit; return bit;
} }
#endif
static int av_noinline av_unused get_cabac_noinline(CABACContext *c, uint8_t * const state){ static int av_noinline av_unused get_cabac_noinline(CABACContext *c, uint8_t * const state){
return get_cabac_inline(c,state); return get_cabac_inline(c,state);
@ -589,36 +341,6 @@ static int av_unused get_cabac(CABACContext *c, uint8_t * const state){
} }
static int av_unused get_cabac_bypass(CABACContext *c){ static int av_unused get_cabac_bypass(CABACContext *c){
#if 0 //not faster
int bit;
__asm__ volatile(
"movl "RANGE "(%1), %%ebx \n\t"
"movl "LOW "(%1), %%eax \n\t"
"shl $17, %%ebx \n\t"
"add %%eax, %%eax \n\t"
"sub %%ebx, %%eax \n\t"
"cltd \n\t"
"and %%edx, %%ebx \n\t"
"add %%ebx, %%eax \n\t"
"test %%ax, %%ax \n\t"
" jnz 1f \n\t"
"movl "BYTE "(%1), %%"REG_b" \n\t"
"subl $0xFFFF, %%eax \n\t"
"movzwl (%%"REG_b"), %%ecx \n\t"
"bswap %%ecx \n\t"
"shrl $15, %%ecx \n\t"
"addl $2, %%"REG_b" \n\t"
"addl %%ecx, %%eax \n\t"
"movl %%"REG_b", "BYTE "(%1) \n\t"
"1: \n\t"
"movl %%eax, "LOW "(%1) \n\t"
:"=&d"(bit)
:"r"(c)
: "%eax", "%"REG_b, "%ecx", "memory"
);
return bit+1;
#else
int range; int range;
c->low += c->low; c->low += c->low;
@ -632,42 +354,11 @@ static int av_unused get_cabac_bypass(CABACContext *c){
c->low -= range; c->low -= range;
return 1; return 1;
} }
#endif
} }
#ifndef get_cabac_bypass_sign
static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){ static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
#if ARCH_X86 && HAVE_EBX_AVAILABLE
__asm__ volatile(
"movl "RANGE "(%1), %%ebx \n\t"
"movl "LOW "(%1), %%eax \n\t"
"shl $17, %%ebx \n\t"
"add %%eax, %%eax \n\t"
"sub %%ebx, %%eax \n\t"
"cltd \n\t"
"and %%edx, %%ebx \n\t"
"add %%ebx, %%eax \n\t"
"xor %%edx, %%ecx \n\t"
"sub %%edx, %%ecx \n\t"
"test %%ax, %%ax \n\t"
" jnz 1f \n\t"
"mov "BYTE "(%1), %%"REG_b" \n\t"
"subl $0xFFFF, %%eax \n\t"
"movzwl (%%"REG_b"), %%edx \n\t"
"bswap %%edx \n\t"
"shrl $15, %%edx \n\t"
"add $2, %%"REG_b" \n\t"
"addl %%edx, %%eax \n\t"
"mov %%"REG_b", "BYTE "(%1) \n\t"
"1: \n\t"
"movl %%eax, "LOW "(%1) \n\t"
:"+c"(val)
:"r"(c)
: "%eax", "%"REG_b, "%edx", "memory"
);
return val;
#else
int range, mask; int range, mask;
c->low += c->low; c->low += c->low;
@ -680,8 +371,8 @@ static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
range &= mask; range &= mask;
c->low += range; c->low += range;
return (val^mask)-mask; return (val^mask)-mask;
#endif
} }
#endif
/** /**
* *

2
libavcodec/dca.c
View File

@ -1817,7 +1817,7 @@ static int dca_decode_frame(AVCodecContext * avctx,
} }
out_size = 256 / 8 * s->sample_blocks * channels * out_size = 256 / 8 * s->sample_blocks * channels *
(av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8); av_get_bytes_per_sample(avctx->sample_fmt);
if (*data_size < out_size) if (*data_size < out_size)
return -1; return -1;
*data_size = out_size; *data_size = out_size;

4
libavcodec/error_resilience.c
View File

@ -542,6 +542,9 @@ skip_mean_and_median:
ff_thread_await_progress((AVFrame *) s->last_picture_ptr, ff_thread_await_progress((AVFrame *) s->last_picture_ptr,
mb_y, 0); mb_y, 0);
} }
if (!s->last_picture.motion_val[0] ||
!s->last_picture.ref_index[0])
goto skip_last_mv;
prev_x = s->last_picture.motion_val[0][mot_index][0]; prev_x = s->last_picture.motion_val[0][mot_index][0];
prev_y = s->last_picture.motion_val[0][mot_index][1]; prev_y = s->last_picture.motion_val[0][mot_index][1];
prev_ref = s->last_picture.ref_index[0][4*mb_xy]; prev_ref = s->last_picture.ref_index[0][4*mb_xy];
@ -556,6 +559,7 @@ skip_mean_and_median:
mv_predictor[pred_count][1]= prev_y; mv_predictor[pred_count][1]= prev_y;
ref [pred_count] = prev_ref; ref [pred_count] = prev_ref;
pred_count++; pred_count++;
skip_last_mv:
s->mv_dir = MV_DIR_FORWARD; s->mv_dir = MV_DIR_FORWARD;
s->mb_intra=0; s->mb_intra=0;

2
libavcodec/h264.c
View File

@ -3690,6 +3690,8 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
switch (hx->nal_unit_type) { switch (hx->nal_unit_type) {
case NAL_SPS: case NAL_SPS:
case NAL_PPS: case NAL_PPS:
case NAL_IDR_SLICE:
case NAL_SLICE:
nals_needed = nal_index; nals_needed = nal_index;
} }
continue; continue;

4
libavcodec/resample.c
View File

@ -239,8 +239,8 @@ ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
s->sample_fmt[0] = sample_fmt_in; s->sample_fmt[0] = sample_fmt_in;
s->sample_fmt[1] = sample_fmt_out; s->sample_fmt[1] = sample_fmt_out;
s->sample_size[0] = av_get_bits_per_sample_fmt(s->sample_fmt[0]) >> 3; s->sample_size[0] = av_get_bytes_per_sample(s->sample_fmt[0]);
s->sample_size[1] = av_get_bits_per_sample_fmt(s->sample_fmt[1]) >> 3; s->sample_size[1] = av_get_bytes_per_sample(s->sample_fmt[1]);
if (s->sample_fmt[0] != AV_SAMPLE_FMT_S16) { if (s->sample_fmt[0] != AV_SAMPLE_FMT_S16) {
if (!(s->convert_ctx[0] = av_audio_convert_alloc(AV_SAMPLE_FMT_S16, 1, if (!(s->convert_ctx[0] = av_audio_convert_alloc(AV_SAMPLE_FMT_S16, 1,

2
libavcodec/utils.c
View File

@ -1210,7 +1210,7 @@ int av_get_bits_per_sample(enum CodecID codec_id){
#if FF_API_OLD_SAMPLE_FMT #if FF_API_OLD_SAMPLE_FMT
int av_get_bits_per_sample_format(enum AVSampleFormat sample_fmt) { int av_get_bits_per_sample_format(enum AVSampleFormat sample_fmt) {
return av_get_bits_per_sample_fmt(sample_fmt); return av_get_bytes_per_sample(sample_fmt) << 3;
} }
#endif #endif

2
libavcodec/vmdav.c
View File

@ -450,7 +450,7 @@ static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
avctx->sample_fmt = AV_SAMPLE_FMT_S16; avctx->sample_fmt = AV_SAMPLE_FMT_S16;
else else
avctx->sample_fmt = AV_SAMPLE_FMT_U8; avctx->sample_fmt = AV_SAMPLE_FMT_U8;
s->out_bps = av_get_bits_per_sample_fmt(avctx->sample_fmt) >> 3; s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, " av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
"block align = %d, sample rate = %d\n", "block align = %d, sample rate = %d\n",

2
libavcodec/vorbisdec.c
View File

@ -1646,7 +1646,7 @@ static int vorbis_decode_frame(AVCodecContext *avccontext,
vc->audio_channels); vc->audio_channels);
*data_size = len * vc->audio_channels * *data_size = len * vc->audio_channels *
(av_get_bits_per_sample_fmt(avccontext->sample_fmt) / 8); av_get_bytes_per_sample(avccontext->sample_fmt);
return buf_size ; return buf_size ;
} }

148
libavcodec/x86/cabac.h Normal file
View File

@ -0,0 +1,148 @@
/*
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
* 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
*/
#ifndef AVCODEC_X86_CABAC_H
#define AVCODEC_X86_CABAC_H
#include "libavcodec/cabac.h"
#include "libavutil/attributes.h"
#include "libavutil/x86_cpu.h"
#include "config.h"
#if HAVE_FAST_CMOV
#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp)\
"mov "tmp" , %%ecx \n\t"\
"shl $17 , "tmp" \n\t"\
"cmp "low" , "tmp" \n\t"\
"cmova %%ecx , "range" \n\t"\
"sbb %%ecx , %%ecx \n\t"\
"and %%ecx , "tmp" \n\t"\
"sub "tmp" , "low" \n\t"\
"xor %%ecx , "ret" \n\t"
#else /* HAVE_FAST_CMOV */
#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp)\
"mov "tmp" , %%ecx \n\t"\
"shl $17 , "tmp" \n\t"\
"sub "low" , "tmp" \n\t"\
"sar $31 , "tmp" \n\t" /*lps_mask*/\
"sub %%ecx , "range" \n\t" /*RangeLPS - range*/\
"and "tmp" , "range" \n\t" /*(RangeLPS - range)&lps_mask*/\
"add %%ecx , "range" \n\t" /*new range*/\
"shl $17 , %%ecx \n\t"\
"and "tmp" , %%ecx \n\t"\
"sub %%ecx , "low" \n\t"\
"xor "tmp" , "ret" \n\t"
#endif /* HAVE_FAST_CMOV */
#define BRANCHLESS_GET_CABAC(ret, cabac, statep, low, lowword, range, tmp, tmpbyte, byte) \
"movzbl "statep" , "ret" \n\t"\
"mov "range" , "tmp" \n\t"\
"and $0xC0 , "range" \n\t"\
"movzbl "MANGLE(ff_h264_lps_range)"("ret", "range", 2), "range" \n\t"\
"sub "range" , "tmp" \n\t"\
BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, \
range, tmp) \
"movzbl " MANGLE(ff_h264_norm_shift) "("range"), %%ecx \n\t"\
"shl %%cl , "range" \n\t"\
"movzbl "MANGLE(ff_h264_mlps_state)"+128("ret"), "tmp" \n\t"\
"mov "tmpbyte" , "statep" \n\t"\
"shl %%cl , "low" \n\t"\
"test "lowword" , "lowword" \n\t"\
" jnz 1f \n\t"\
"mov "byte"("cabac"), %%"REG_c" \n\t"\
"movzwl (%%"REG_c") , "tmp" \n\t"\
"bswap "tmp" \n\t"\
"shr $15 , "tmp" \n\t"\
"sub $0xFFFF , "tmp" \n\t"\
"add $2 , %%"REG_c" \n\t"\
"mov %%"REG_c" , "byte "("cabac") \n\t"\
"lea -1("low") , %%ecx \n\t"\
"xor "low" , %%ecx \n\t"\
"shr $15 , %%ecx \n\t"\
"movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx \n\t"\
"neg %%ecx \n\t"\
"add $7 , %%ecx \n\t"\
"shl %%cl , "tmp" \n\t"\
"add "tmp" , "low" \n\t"\
"1: \n\t"
#if ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS)
#define get_cabac_inline get_cabac_inline_x86
static av_always_inline int get_cabac_inline_x86(CABACContext *c,
uint8_t *const state)
{
int bit, low, range, tmp;
__asm__ volatile(
"movl %a6(%5), %2 \n\t"
"movl %a7(%5), %1 \n\t"
BRANCHLESS_GET_CABAC("%0", "%5", "(%4)", "%1", "%w1", "%2",
"%3", "%b3", "%a8")
"movl %2, %a6(%5) \n\t"
"movl %1, %a7(%5) \n\t"
:"=&r"(bit), "=&r"(low), "=&r"(range), "=&q"(tmp)
:"r"(state), "r"(c),
"i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
"i"(offsetof(CABACContext, bytestream))
: "%"REG_c, "memory"
);
return bit & 1;
}
#endif /* ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS) */
#define get_cabac_bypass_sign get_cabac_bypass_sign_x86
static av_always_inline int get_cabac_bypass_sign_x86(CABACContext *c, int val)
{
x86_reg tmp;
__asm__ volatile(
"movl %a3(%2), %k1 \n\t"
"movl %a4(%2), %%eax \n\t"
"shl $17, %k1 \n\t"
"add %%eax, %%eax \n\t"
"sub %k1, %%eax \n\t"
"cltd \n\t"
"and %%edx, %k1 \n\t"
"add %k1, %%eax \n\t"
"xor %%edx, %%ecx \n\t"
"sub %%edx, %%ecx \n\t"
"test %%ax, %%ax \n\t"
" jnz 1f \n\t"
"mov %a5(%2), %1 \n\t"
"subl $0xFFFF, %%eax \n\t"
"movzwl (%1), %%edx \n\t"
"bswap %%edx \n\t"
"shrl $15, %%edx \n\t"
"add $2, %1 \n\t"
"addl %%edx, %%eax \n\t"
"mov %1, %a5(%2) \n\t"
"1: \n\t"
"movl %%eax, %a4(%2) \n\t"
:"+c"(val), "=&r"(tmp)
:"r"(c),
"i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
"i"(offsetof(CABACContext, bytestream))
: "%eax", "%edx", "memory"
);
return val;
}
#endif /* AVCODEC_X86_CABAC_H */

149
libavcodec/x86/h264_i386.h
View File

@ -29,63 +29,72 @@
#ifndef AVCODEC_X86_H264_I386_H #ifndef AVCODEC_X86_H264_I386_H
#define AVCODEC_X86_H264_I386_H #define AVCODEC_X86_H264_I386_H
#include <stddef.h>
#include "libavcodec/cabac.h" #include "libavcodec/cabac.h"
#include "cabac.h"
//FIXME use some macros to avoid duplicating get_cabac (cannot be done yet //FIXME use some macros to avoid duplicating get_cabac (cannot be done yet
//as that would make optimization work hard) //as that would make optimization work hard)
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) #if ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS)
static int decode_significance_x86(CABACContext *c, int max_coeff, static int decode_significance_x86(CABACContext *c, int max_coeff,
uint8_t *significant_coeff_ctx_base, uint8_t *significant_coeff_ctx_base,
int *index, x86_reg last_off){ int *index, x86_reg last_off){
void *end= significant_coeff_ctx_base + max_coeff - 1; void *end= significant_coeff_ctx_base + max_coeff - 1;
int minusstart= -(int)significant_coeff_ctx_base; int minusstart= -(intptr_t)significant_coeff_ctx_base;
int minusindex= 4-(int)index; int minusindex= 4-(intptr_t)index;
int coeff_count; int bit;
x86_reg coeff_count;
int low;
int range;
__asm__ volatile( __asm__ volatile(
"movl "RANGE "(%3), %%esi \n\t" "movl %a11(%6), %5 \n\t"
"movl "LOW "(%3), %%ebx \n\t" "movl %a12(%6), %3 \n\t"
"2: \n\t" "2: \n\t"
BRANCHLESS_GET_CABAC("%%edx", "%3", "(%1)", "%%ebx", BRANCHLESS_GET_CABAC("%4", "%6", "(%1)", "%3",
"%%bx", "%%esi", "%%eax", "%%al") "%w3", "%5", "%k0", "%b0", "%a13")
"test $1, %%edx \n\t" "test $1, %4 \n\t"
" jz 3f \n\t" " jz 3f \n\t"
"add %7, %1 \n\t" "add %10, %1 \n\t"
BRANCHLESS_GET_CABAC("%%edx", "%3", "(%1)", "%%ebx", BRANCHLESS_GET_CABAC("%4", "%6", "(%1)", "%3",
"%%bx", "%%esi", "%%eax", "%%al") "%w3", "%5", "%k0", "%b0", "%a13")
"sub %7, %1 \n\t" "sub %10, %1 \n\t"
"mov %2, %%"REG_a" \n\t" "mov %2, %0 \n\t"
"movl %4, %%ecx \n\t" "movl %7, %%ecx \n\t"
"add %1, %%"REG_c" \n\t" "add %1, %%"REG_c" \n\t"
"movl %%ecx, (%%"REG_a") \n\t" "movl %%ecx, (%0) \n\t"
"test $1, %%edx \n\t" "test $1, %4 \n\t"
" jnz 4f \n\t" " jnz 4f \n\t"
"add $4, %%"REG_a" \n\t" "add $4, %0 \n\t"
"mov %%"REG_a", %2 \n\t" "mov %0, %2 \n\t"
"3: \n\t" "3: \n\t"
"add $1, %1 \n\t" "add $1, %1 \n\t"
"cmp %5, %1 \n\t" "cmp %8, %1 \n\t"
" jb 2b \n\t" " jb 2b \n\t"
"mov %2, %%"REG_a" \n\t" "mov %2, %0 \n\t"
"movl %4, %%ecx \n\t" "movl %7, %%ecx \n\t"
"add %1, %%"REG_c" \n\t" "add %1, %%"REG_c" \n\t"
"movl %%ecx, (%%"REG_a") \n\t" "movl %%ecx, (%0) \n\t"
"4: \n\t" "4: \n\t"
"add %6, %%eax \n\t" "add %9, %k0 \n\t"
"shr $2, %%eax \n\t" "shr $2, %k0 \n\t"
"movl %%esi, "RANGE "(%3) \n\t" "movl %5, %a11(%6) \n\t"
"movl %%ebx, "LOW "(%3) \n\t" "movl %3, %a12(%6) \n\t"
:"=&a"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index) :"=&q"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index),
:"r"(c), "m"(minusstart), "m"(end), "m"(minusindex), "m"(last_off) "=&r"(low), "=&r"(bit), "=&r"(range)
: "%"REG_c, "%ebx", "%edx", "%esi", "memory" :"r"(c), "m"(minusstart), "m"(end), "m"(minusindex), "m"(last_off),
"i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
"i"(offsetof(CABACContext, bytestream))
: "%"REG_c, "memory"
); );
return coeff_count; return coeff_count;
} }
@ -93,64 +102,70 @@ static int decode_significance_x86(CABACContext *c, int max_coeff,
static int decode_significance_8x8_x86(CABACContext *c, static int decode_significance_8x8_x86(CABACContext *c,
uint8_t *significant_coeff_ctx_base, uint8_t *significant_coeff_ctx_base,
int *index, x86_reg last_off, const uint8_t *sig_off){ int *index, x86_reg last_off, const uint8_t *sig_off){
int minusindex= 4-(int)index; int minusindex= 4-(intptr_t)index;
int coeff_count; int bit;
x86_reg coeff_count;
int low;
int range;
x86_reg last=0; x86_reg last=0;
x86_reg state;
__asm__ volatile( __asm__ volatile(
"movl "RANGE "(%3), %%esi \n\t" "movl %a12(%7), %5 \n\t"
"movl "LOW "(%3), %%ebx \n\t" "movl %a13(%7), %3 \n\t"
"mov %1, %%"REG_D" \n\t" "mov %1, %6 \n\t"
"2: \n\t" "2: \n\t"
"mov %6, %%"REG_a" \n\t" "mov %10, %0 \n\t"
"movzbl (%%"REG_a", %%"REG_D"), %%edi \n\t" "movzbl (%0, %6), %k6 \n\t"
"add %5, %%"REG_D" \n\t" "add %9, %6 \n\t"
BRANCHLESS_GET_CABAC("%%edx", "%3", "(%%"REG_D")", "%%ebx", BRANCHLESS_GET_CABAC("%4", "%7", "(%6)", "%3",
"%%bx", "%%esi", "%%eax", "%%al") "%w3", "%5", "%k0", "%b0", "%a14")
"mov %1, %%edi \n\t" "mov %1, %k6 \n\t"
"test $1, %%edx \n\t" "test $1, %4 \n\t"
" jz 3f \n\t" " jz 3f \n\t"
"movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%%edi), %%edi\n\t" "movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%k6), %k6\n\t"
"add %5, %%"REG_D" \n\t" "add %9, %6 \n\t"
"add %7, %%"REG_D" \n\t" "add %11, %6 \n\t"
BRANCHLESS_GET_CABAC("%%edx", "%3", "(%%"REG_D")", "%%ebx", BRANCHLESS_GET_CABAC("%4", "%7", "(%6)", "%3",
"%%bx", "%%esi", "%%eax", "%%al") "%w3", "%5", "%k0", "%b0", "%a14")
"mov %2, %%"REG_a" \n\t" "mov %2, %0 \n\t"
"mov %1, %%edi \n\t" "mov %1, %k6 \n\t"
"movl %%edi, (%%"REG_a") \n\t" "movl %k6, (%0) \n\t"
"test $1, %%edx \n\t" "test $1, %4 \n\t"
" jnz 4f \n\t" " jnz 4f \n\t"
"add $4, %%"REG_a" \n\t" "add $4, %0 \n\t"
"mov %%"REG_a", %2 \n\t" "mov %0, %2 \n\t"
"3: \n\t" "3: \n\t"
"addl $1, %%edi \n\t" "addl $1, %k6 \n\t"
"mov %%edi, %1 \n\t" "mov %k6, %1 \n\t"
"cmpl $63, %%edi \n\t" "cmpl $63, %k6 \n\t"
" jb 2b \n\t" " jb 2b \n\t"
"mov %2, %%"REG_a" \n\t" "mov %2, %0 \n\t"
"movl %%edi, (%%"REG_a") \n\t" "movl %k6, (%0) \n\t"
"4: \n\t" "4: \n\t"
"addl %4, %%eax \n\t" "addl %8, %k0 \n\t"
"shr $2, %%eax \n\t" "shr $2, %k0 \n\t"
"movl %%esi, "RANGE "(%3) \n\t" "movl %5, %a12(%7) \n\t"
"movl %%ebx, "LOW "(%3) \n\t" "movl %3, %a13(%7) \n\t"
:"=&a"(coeff_count),"+m"(last), "+m"(index) :"=&q"(coeff_count),"+m"(last), "+m"(index), "=&r"(low), "=&r"(bit),
:"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off), "m"(last_off) "=&r"(range), "=&r"(state)
: "%"REG_c, "%ebx", "%edx", "%esi", "%"REG_D, "memory" :"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off), "m"(last_off),
"i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
"i"(offsetof(CABACContext, bytestream))
: "%"REG_c, "memory"
); );
return coeff_count; return coeff_count;
} }
#endif /* ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE */ #endif /* ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS) */
/* !defined(BROKEN_RELOCATIONS) */
#endif /* AVCODEC_X86_H264_I386_H */ #endif /* AVCODEC_X86_H264_I386_H */

2
libavformat/matroskaenc.c
View File

@ -527,7 +527,7 @@ static int mkv_write_tracks(AVFormatContext *s)
AVDictionaryEntry *tag; AVDictionaryEntry *tag;
if (!bit_depth) if (!bit_depth)
bit_depth = av_get_bits_per_sample_fmt(codec->sample_fmt); bit_depth = av_get_bytes_per_sample(codec->sample_fmt) << 3;
if (codec->codec_id == CODEC_ID_AAC) if (codec->codec_id == CODEC_ID_AAC)
get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate); get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate);

2
libavformat/mov.c
View File

@ -2202,7 +2202,7 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
time = avio_rb64(pb); time = avio_rb64(pb);
} else { } else {
duration = avio_rb32(pb); /* segment duration */ duration = avio_rb32(pb); /* segment duration */
time = avio_rb32(pb); /* media time */ time = (int32_t)avio_rb32(pb); /* media time */
} }
avio_rb32(pb); /* Media rate */ avio_rb32(pb); /* Media rate */
if (i == 0 && time >= -1) { if (i == 0 && time >= -1) {

12
libswscale/swscale.h
View File

@ -29,9 +29,9 @@
#include "libavutil/avutil.h" #include "libavutil/avutil.h"
#define LIBSWSCALE_VERSION_MAJOR 0 #define LIBSWSCALE_VERSION_MAJOR 2
#define LIBSWSCALE_VERSION_MINOR 14 #define LIBSWSCALE_VERSION_MINOR 0
#define LIBSWSCALE_VERSION_MICRO 1 #define LIBSWSCALE_VERSION_MICRO 0
#define LIBSWSCALE_VERSION_INT AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \ #define LIBSWSCALE_VERSION_INT AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \
LIBSWSCALE_VERSION_MINOR, \ LIBSWSCALE_VERSION_MINOR, \
@ -48,13 +48,13 @@
* They may change, break or disappear at any time. * They may change, break or disappear at any time.
*/ */
#ifndef FF_API_SWS_GETCONTEXT #ifndef FF_API_SWS_GETCONTEXT
#define FF_API_SWS_GETCONTEXT (LIBSWSCALE_VERSION_MAJOR < 2) #define FF_API_SWS_GETCONTEXT (LIBSWSCALE_VERSION_MAJOR < 3)
#endif #endif
#ifndef FF_API_SWS_CPU_CAPS #ifndef FF_API_SWS_CPU_CAPS
#define FF_API_SWS_CPU_CAPS (LIBSWSCALE_VERSION_MAJOR < 2) #define FF_API_SWS_CPU_CAPS (LIBSWSCALE_VERSION_MAJOR < 3)
#endif #endif
#ifndef FF_API_SWS_FORMAT_NAME #ifndef FF_API_SWS_FORMAT_NAME
#define FF_API_SWS_FORMAT_NAME (LIBSWSCALE_VERSION_MAJOR < 2) #define FF_API_SWS_FORMAT_NAME (LIBSWSCALE_VERSION_MAJOR < 3)
#endif #endif
/** /**