* qatar/master: libx264: fix indentation. vorbis: fix overflows in floor1[] vector and inverse db table index. win64: add a XMM clobber test configure option. movdec: Parse the dvc1 atom ARM: ac3: fix ac3_bit_alloc_calc_bap_armv6 swscale: K&R formatting cosmetics for Blackfin code frwu: lowercase the FRWU codec name movdec: fix dts generation in fragmented files fate: make acodec-ac3_fixed test output raw AC3 APIchanges: add missing commit hashes swscale: implement MMX, SSE2 and AVX functions for RGB32 input. ra144enc: drop pointless "encoder" from .long_name bethsoftvideo: fix palette reading. mpc7: use av_fast_padded_malloc() mpc7: simplify handling of packet sizes that are not a multiple of 4 bytes doc: decoding Forward Uncompressed is supported Fix a typo in the x86 asm version of ff_vector_clip_int32() pcmenc: Do not set avpkt->size. ff_alloc_packet: modify the size of the packet to match the requested size Conflicts: doc/APIchanges libavcodec/libx264.c libavcodec/mpc7.c libavformat/isom.h libswscale/Makefile libswscale/bfin/yuv2rgb_bfin.c tests/ref/fate/bethsoft-vid tests/ref/seek/ac3_ac3 Merged-by: Michael Niedermayer <michaelni@gmx.at>tags/n0.11
@@ -276,6 +276,8 @@ Developer options (useful when working on FFmpeg itself): | |||
Cannot be combined with --target-exec | |||
--samples=PATH location of test samples for FATE, if not set use | |||
\$FATE_SAMPLES at make invocation time. | |||
--enable-xmm-clobber-test check XMM registers for clobbering (Win64-only; | |||
should be used only for debugging purposes) | |||
NOTE: Object files are built at the place where configure is launched. | |||
EOF | |||
@@ -1085,6 +1087,7 @@ CONFIG_LIST=" | |||
vda | |||
vdpau | |||
version3 | |||
xmm_clobber_test | |||
x11grab | |||
zlib | |||
" | |||
@@ -1779,7 +1782,7 @@ test_deps _muxer _demuxer \ | |||
wav \ | |||
yuv4mpegpipe=yuv4mpeg \ | |||
ac3_fixed_test_deps="ac3_fixed_encoder ac3_decoder rm_muxer rm_demuxer" | |||
ac3_fixed_test_deps="ac3_fixed_encoder ac3_decoder" | |||
mpg_test_deps="mpeg1system_muxer mpegps_demuxer" | |||
# default parameters | |||
@@ -3304,6 +3307,17 @@ check_ldflags -Wl,--warn-common | |||
check_ldflags -Wl,-rpath-link=libpostproc:libswresample:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil | |||
test_ldflags -Wl,-Bsymbolic && append SHFLAGS -Wl,-Bsymbolic | |||
enabled xmm_clobber_test && \ | |||
check_ldflags -Wl,--wrap,avcodec_open2 \ | |||
-Wl,--wrap,avcodec_decode_audio4 \ | |||
-Wl,--wrap,avcodec_decode_video2 \ | |||
-Wl,--wrap,avcodec_decode_subtitle2 \ | |||
-Wl,--wrap,avcodec_encode_audio2 \ | |||
-Wl,--wrap,avcodec_encode_video \ | |||
-Wl,--wrap,avcodec_encode_subtitle \ | |||
-Wl,--wrap,sws_scale || \ | |||
disable xmm_clobber_test | |||
echo "X{};" > $TMPV | |||
if test_ldflags -Wl,--version-script,$TMPV; then | |||
append SHFLAGS '-Wl,--version-script,\$(SUBDIR)lib\$(NAME).ver' | |||
@@ -19,18 +19,18 @@ API changes, most recent first: | |||
2012-01-24 - xxxxxxx - lavfi 2.60.100 | |||
Add avfilter_graph_dump. | |||
2012-02-01 - xxxxxxx - lavc 54.01.0 | |||
2012-02-01 - 316fc74 - lavc 54.01.0 | |||
Add av_fast_padded_malloc() as alternative for av_realloc() when aligned | |||
memory is required. The buffer will always have FF_INPUT_BUFFER_PADDING_SIZE | |||
zero-padded bytes at the end. | |||
2012-01-31 - xxxxxxx - lavf 54.01.0 | |||
2012-01-31 - dd6d3b0 - lavf 54.01.0 | |||
Add avformat_get_riff_video_tags() and avformat_get_riff_audio_tags(). | |||
2012-01-31 - xxxxxxx - lavc 54.01.0 | |||
2012-01-31 - af08d9a - lavc 54.01.0 | |||
Add avcodec_is_open() function. | |||
2012-01-30 - xxxxxxx - lavu 51.22.0 - intfloat.h | |||
2012-01-30 - 8b93312 - lavu 51.22.0 - intfloat.h | |||
Add a new installed header libavutil/intfloat.h with int/float punning | |||
functions. | |||
@@ -497,6 +497,7 @@ following image formats are supported: | |||
@item Flash Screen Video v2 @tab X @tab X | |||
@item Flash Video (FLV) @tab X @tab X | |||
@tab Sorenson H.263 used in Flash | |||
@item Forward Uncompressed @tab @tab X | |||
@item Fraps @tab @tab X | |||
@item H.261 @tab X @tab X | |||
@item H.263 / H.263-1996 @tab X @tab X | |||
@@ -34,24 +34,23 @@ function ff_ac3_bit_alloc_calc_bap_armv6, export=1 | |||
add r0, r0, r4, lsl #1 @ mask + band | |||
add r4, lr, r4 | |||
add r7, r7, r2 @ bap + start | |||
ldrb r10, [r4], #1 | |||
1: | |||
ldrsh r9, [r0], #2 @ mask[band] | |||
mov r8, #0xff0 | |||
sub r9, r9, r12 @ - snr_offset | |||
mov r11, r10 | |||
ldrb r10, [r4], #1 @ band_start_tab[band++] | |||
ldrb r10, [r4, #1]! @ band_start_tab[++band] | |||
subs r9, r9, r5 @ - floor | |||
it lt | |||
movlt r9, #0 | |||
cmp r10, r3 @ - end | |||
and r9, r9, r8, lsl #1 @ & 0x1fe0 | |||
ite gt | |||
subgt r8, r3, r11 | |||
suble r8, r10, r11 | |||
subgt r8, r3, r2 | |||
suble r8, r10, r2 | |||
mov r2, r10 | |||
add r9, r9, r5 @ + floor => m | |||
tst r8, #1 | |||
add r2, r7, r8 | |||
add r11, r7, r8 | |||
bne 3f | |||
b 5f | |||
2: | |||
@@ -65,9 +64,9 @@ function ff_ac3_bit_alloc_calc_bap_armv6, export=1 | |||
ldrb lr, [r6, lr] | |||
strb r8, [r7], #1 @ bap[bin] | |||
strb lr, [r7], #1 | |||
5: cmp r7, r2 | |||
5: cmp r7, r11 | |||
blo 2b | |||
cmp r3, r11 | |||
cmp r3, r10 | |||
bgt 1b | |||
pop {r4-r11,pc} | |||
3: | |||
@@ -61,7 +61,7 @@ static int set_palette(BethsoftvidContext *ctx) | |||
palette[a] |= palette[a] >> 6 & 0x30303; | |||
} | |||
ctx->frame.palette_has_changed = 1; | |||
return 256*3; | |||
return 0; | |||
} | |||
static int bethsoftvid_decode_frame(AVCodecContext *avctx, | |||
@@ -88,7 +88,13 @@ static int bethsoftvid_decode_frame(AVCodecContext *avctx, | |||
switch(block_type = bytestream2_get_byte(&vid->g)){ | |||
case PALETTE_BLOCK: { | |||
return set_palette(vid); | |||
int ret; | |||
*data_size = 0; | |||
if ((ret = set_palette(vid)) < 0) { | |||
av_log(avctx, AV_LOG_ERROR, "error reading palette\n"); | |||
return ret; | |||
} | |||
return bytestream2_tell(&vid->g); | |||
} | |||
case VIDEO_YOFF_P_FRAME: | |||
yoffset = bytestream2_get_le16(&vid->g); | |||
@@ -130,6 +130,7 @@ int avpriv_unlock_avformat(void); | |||
* If avpkt->data is already set, avpkt->size is checked | |||
* to ensure it is large enough. | |||
* If avpkt->data is NULL, a new buffer is allocated. | |||
* avpkt->size is set to the specified size. | |||
* All other AVPacket fields will be reset with av_init_packet(). | |||
* @param size the minimum required packet size | |||
* @return 0 on success, negative error code on failure | |||
@@ -188,12 +188,12 @@ static int X264_frame(AVCodecContext *ctx, uint8_t *buf, | |||
do { | |||
bufsize = orig_bufsize; | |||
if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0) | |||
return -1; | |||
if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0) | |||
return -1; | |||
bufsize = encode_nals(ctx, buf, bufsize, nal, nnal, 0); | |||
if (bufsize < 0) | |||
return -1; | |||
bufsize = encode_nals(ctx, buf, bufsize, nal, nnal, 0); | |||
if (bufsize < 0) | |||
return -1; | |||
} while (!bufsize && !frame && x264_encoder_delayed_frames(x4->enc)); | |||
/* FIXME: libx264 now provides DTS, but AVFrame doesn't have a field for it. */ | |||
@@ -66,8 +66,6 @@ typedef struct { | |||
int buf_size; | |||
AVLFG rnd; | |||
int frames_to_skip; | |||
uint8_t *buffer; | |||
int buffer_size; | |||
/* for synthesis */ | |||
DECLARE_ALIGNED(16, MPA_INT, synth_buf)[MPA_MAX_CHANNELS][512*2]; | |||
int synth_buf_offset[MPA_MAX_CHANNELS]; | |||
@@ -200,34 +200,46 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data, | |||
int *got_frame_ptr, AVPacket *avpkt) | |||
{ | |||
const uint8_t *buf = avpkt->data; | |||
int buf_size = avpkt->size; | |||
int buf_size; | |||
MPCContext *c = avctx->priv_data; | |||
GetBitContext gb; | |||
int i, ch; | |||
int mb = -1; | |||
Band *bands = c->bands; | |||
int off, ret; | |||
int off, ret, last_frame, skip; | |||
int bits_used, bits_avail; | |||
memset(bands, 0, sizeof(*bands) * (c->maxbands + 1)); | |||
if(buf_size <= 4){ | |||
av_log(avctx, AV_LOG_ERROR, "Too small buffer passed (%i bytes)\n", buf_size); | |||
return AVERROR(EINVAL); | |||
buf_size = avpkt->size & ~3; | |||
if (buf_size <= 0) { | |||
av_log(avctx, AV_LOG_ERROR, "packet size is too small (%i bytes)\n", | |||
avpkt->size); | |||
return AVERROR_INVALIDDATA; | |||
} | |||
if (buf_size != avpkt->size) { | |||
av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. " | |||
"extra bytes at the end will be skipped.\n"); | |||
} | |||
skip = buf[0]; | |||
last_frame = buf[1]; | |||
buf += 4; | |||
buf_size -= 4; | |||
/* get output buffer */ | |||
c->frame.nb_samples = buf[1] ? c->lastframelen : MPC_FRAME_SIZE; | |||
c->frame.nb_samples = last_frame ? c->lastframelen : MPC_FRAME_SIZE; | |||
if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) { | |||
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |||
return ret; | |||
} | |||
av_fast_padded_malloc(&c->buffer, &c->buffer_size, FFALIGN(buf_size - 1, 4)); | |||
if (!c->buffer) | |||
av_fast_padded_malloc(&c->bits, &c->buf_size, buf_size); | |||
if (!c->bits) | |||
return AVERROR(ENOMEM); | |||
c->dsp.bswap_buf((uint32_t*)c->buffer, (const uint32_t*)(buf + 4), (buf_size - 4) >> 2); | |||
init_get_bits(&gb, c->buffer, (buf_size - 4)* 8); | |||
skip_bits_long(&gb, buf[0]); | |||
c->dsp.bswap_buf((uint32_t *)c->bits, (const uint32_t *)buf, buf_size >> 2); | |||
init_get_bits(&gb, c->bits, buf_size * 8); | |||
skip_bits_long(&gb, skip); | |||
/* read subband indexes */ | |||
for(i = 0; i <= c->maxbands; i++){ | |||
@@ -284,21 +296,21 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data, | |||
ff_mpc_dequantize_and_synth(c, mb, c->frame.data[0], 2); | |||
bits_used = get_bits_count(&gb); | |||
bits_avail = (buf_size - 4) * 8; | |||
if(!buf[1] && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))){ | |||
bits_avail = buf_size * 8; | |||
if (!last_frame && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))) { | |||
av_log(NULL,0, "Error decoding frame: used %i of %i bits\n", bits_used, bits_avail); | |||
return -1; | |||
} | |||
if(c->frames_to_skip){ | |||
c->frames_to_skip--; | |||
*got_frame_ptr = 0; | |||
return buf_size; | |||
return avpkt->size; | |||
} | |||
*got_frame_ptr = 1; | |||
*(AVFrame *)data = c->frame; | |||
return buf_size; | |||
return avpkt->size; | |||
} | |||
static void mpc7_decode_flush(AVCodecContext *avctx) | |||
@@ -312,8 +324,8 @@ static void mpc7_decode_flush(AVCodecContext *avctx) | |||
static av_cold int mpc7_decode_close(AVCodecContext *avctx) | |||
{ | |||
MPCContext *c = avctx->priv_data; | |||
av_freep(&c->buffer); | |||
c->buffer_size = 0; | |||
av_freep(&c->bits); | |||
c->buf_size = 0; | |||
return 0; | |||
} | |||
@@ -194,7 +194,6 @@ static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, | |||
return -1; | |||
} | |||
avpkt->size = frame->nb_samples * avctx->channels * sample_size; | |||
*got_packet_ptr = 1; | |||
return 0; | |||
} | |||
@@ -521,5 +521,5 @@ AVCodec ff_ra_144_encoder = { | |||
.close = ra144_encode_close, | |||
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, | |||
AV_SAMPLE_FMT_NONE }, | |||
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K) encoder"), | |||
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"), | |||
}; |
@@ -919,16 +919,14 @@ int ff_alloc_packet(AVPacket *avpkt, int size) | |||
if (avpkt->data) { | |||
uint8_t *pkt_data; | |||
int pkt_size; | |||
if (avpkt->size < size) | |||
return AVERROR(EINVAL); | |||
pkt_data = avpkt->data; | |||
pkt_size = avpkt->size; | |||
av_init_packet(avpkt); | |||
avpkt->data = pkt_data; | |||
avpkt->size = pkt_size; | |||
avpkt->size = size; | |||
return 0; | |||
} else { | |||
return av_new_packet(avpkt, size); | |||
@@ -156,7 +156,7 @@ void ff_vorbis_ready_floor1_list(vorbis_floor1_entry * list, int values) | |||
} | |||
} | |||
static inline void render_line_unrolled(intptr_t x, uint8_t y, int x1, | |||
static inline void render_line_unrolled(intptr_t x, int y, int x1, | |||
intptr_t sy, int ady, int adx, | |||
float *buf) | |||
{ | |||
@@ -168,30 +168,30 @@ static inline void render_line_unrolled(intptr_t x, uint8_t y, int x1, | |||
if (err >= 0) { | |||
err += ady - adx; | |||
y += sy; | |||
buf[x++] = ff_vorbis_floor1_inverse_db_table[y]; | |||
buf[x++] = ff_vorbis_floor1_inverse_db_table[av_clip_uint8(y)]; | |||
} | |||
buf[x] = ff_vorbis_floor1_inverse_db_table[y]; | |||
buf[x] = ff_vorbis_floor1_inverse_db_table[av_clip_uint8(y)]; | |||
} | |||
if (x <= 0) { | |||
if (err + ady >= 0) | |||
y += sy; | |||
buf[x] = ff_vorbis_floor1_inverse_db_table[y]; | |||
buf[x] = ff_vorbis_floor1_inverse_db_table[av_clip_uint8(y)]; | |||
} | |||
} | |||
static void render_line(int x0, uint8_t y0, int x1, int y1, float *buf) | |||
static void render_line(int x0, int y0, int x1, int y1, float *buf) | |||
{ | |||
int dy = y1 - y0; | |||
int adx = x1 - x0; | |||
int ady = FFABS(dy); | |||
int sy = dy < 0 ? -1 : 1; | |||
buf[x0] = ff_vorbis_floor1_inverse_db_table[y0]; | |||
buf[x0] = ff_vorbis_floor1_inverse_db_table[av_clip_uint8(y0)]; | |||
if (ady*2 <= adx) { // optimized common case | |||
render_line_unrolled(x0, y0, x1, sy, ady, adx, buf); | |||
} else { | |||
int base = dy / adx; | |||
int x = x0; | |||
uint8_t y = y0; | |||
int y = y0; | |||
int err = -adx; | |||
ady -= FFABS(base) * adx; | |||
while (++x < x1) { | |||
@@ -201,7 +201,7 @@ static void render_line(int x0, uint8_t y0, int x1, int y1, float *buf) | |||
err -= adx; | |||
y += sy; | |||
} | |||
buf[x] = ff_vorbis_floor1_inverse_db_table[y]; | |||
buf[x] = ff_vorbis_floor1_inverse_db_table[av_clip_uint8(y)]; | |||
} | |||
} | |||
} | |||
@@ -210,8 +210,7 @@ void ff_vorbis_floor1_render_list(vorbis_floor1_entry * list, int values, | |||
uint16_t *y_list, int *flag, | |||
int multiplier, float *out, int samples) | |||
{ | |||
int lx, i; | |||
uint8_t ly; | |||
int lx, ly, i; | |||
lx = 0; | |||
ly = y_list[0] * multiplier; | |||
for (i = 1; i < values; i++) { | |||
@@ -1256,20 +1256,20 @@ static int vorbis_floor1_decode(vorbis_context *vc, | |||
floor1_flag[i] = 1; | |||
if (val >= room) { | |||
if (highroom > lowroom) { | |||
floor1_Y_final[i] = val - lowroom + predicted; | |||
floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted); | |||
} else { | |||
floor1_Y_final[i] = predicted - val + highroom - 1; | |||
floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1); | |||
} | |||
} else { | |||
if (val & 1) { | |||
floor1_Y_final[i] = predicted - (val + 1) / 2; | |||
floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2); | |||
} else { | |||
floor1_Y_final[i] = predicted + val / 2; | |||
floor1_Y_final[i] = av_clip_uint16(predicted + val / 2); | |||
} | |||
} | |||
} else { | |||
floor1_flag[i] = 0; | |||
floor1_Y_final[i] = predicted; | |||
floor1_Y_final[i] = av_clip_uint16(predicted); | |||
} | |||
av_dlog(NULL, " Decoded floor(%d) = %u / val %u\n", | |||
@@ -83,3 +83,4 @@ OBJS-$(HAVE_MMX) += x86/dsputil_mmx.o \ | |||
x86/mpegvideo_mmx.o \ | |||
x86/simple_idct_mmx.o \ | |||
OBJS-$(CONFIG_XMM_CLOBBER_TEST) += x86/w64xmmtest.o |
@@ -1063,7 +1063,7 @@ emu_edge mmx | |||
; %4 = CLIPD function takes min/max as float instead of int (CLIPD_SSE2) | |||
; %5 = suffix | |||
%macro VECTOR_CLIP_INT32 4-5 | |||
cglobal vector_clip_int32%5, 5,5,%2, dst, src, min, max, len | |||
cglobal vector_clip_int32%5, 5,5,%1, dst, src, min, max, len | |||
%if %4 | |||
cvtsi2ss m4, minm | |||
cvtsi2ss m5, maxm | |||
@@ -0,0 +1,80 @@ | |||
/* | |||
* check XMM registers for clobbers on Win64 | |||
* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.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 "libavcodec/avcodec.h" | |||
#include "libavutil/x86/w64xmmtest.h" | |||
wrap(avcodec_open2(AVCodecContext *avctx, | |||
AVCodec *codec, | |||
AVDictionary **options)) | |||
{ | |||
testxmmclobbers(avcodec_open2, avctx, codec, options); | |||
} | |||
wrap(avcodec_decode_audio4(AVCodecContext *avctx, | |||
AVFrame *frame, | |||
int *got_frame_ptr, | |||
AVPacket *avpkt)) | |||
{ | |||
testxmmclobbers(avcodec_decode_audio4, avctx, frame, | |||
got_frame_ptr, avpkt); | |||
} | |||
wrap(avcodec_decode_video2(AVCodecContext *avctx, | |||
AVFrame *picture, | |||
int *got_picture_ptr, | |||
AVPacket *avpkt)) | |||
{ | |||
testxmmclobbers(avcodec_decode_video2, avctx, picture, | |||
got_picture_ptr, avpkt); | |||
} | |||
wrap(avcodec_decode_subtitle2(AVCodecContext *avctx, | |||
AVSubtitle *sub, | |||
int *got_sub_ptr, | |||
AVPacket *avpkt)) | |||
{ | |||
testxmmclobbers(avcodec_decode_subtitle2, avctx, sub, | |||
got_sub_ptr, avpkt); | |||
} | |||
wrap(avcodec_encode_audio2(AVCodecContext *avctx, | |||
AVPacket *avpkt, | |||
const AVFrame *frame, | |||
int *got_packet_ptr)) | |||
{ | |||
testxmmclobbers(avcodec_encode_audio2, avctx, avpkt, frame, | |||
got_packet_ptr); | |||
} | |||
wrap(avcodec_encode_video(AVCodecContext *avctx, | |||
uint8_t *buf, int buf_size, | |||
const AVFrame *pict)) | |||
{ | |||
testxmmclobbers(avcodec_encode_video, avctx, buf, buf_size, pict); | |||
} | |||
wrap(avcodec_encode_subtitle(AVCodecContext *avctx, | |||
uint8_t *buf, int buf_size, | |||
const AVSubtitle *sub)) | |||
{ | |||
testxmmclobbers(avcodec_encode_subtitle, avctx, buf, buf_size, sub); | |||
} |
@@ -129,6 +129,7 @@ typedef struct MOVStreamContext { | |||
int has_palette; | |||
int64_t data_size; | |||
uint32_t tmcd_flags; ///< tmcd track flags | |||
int64_t track_end; ///< used for dts generation in fragmented movie files | |||
} MOVStreamContext; | |||
typedef struct MOVContext { | |||
@@ -1012,6 +1012,32 @@ static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom) | |||
return 0; | |||
} | |||
static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom) | |||
{ | |||
AVStream *st; | |||
uint8_t profile_level; | |||
if (c->fc->nb_streams < 1) | |||
return 0; | |||
st = c->fc->streams[c->fc->nb_streams-1]; | |||
if (atom.size >= (1<<28) || atom.size < 7) | |||
return AVERROR_INVALIDDATA; | |||
profile_level = avio_r8(pb); | |||
if (profile_level & 0xf0 != 0xc0) | |||
return 0; | |||
av_free(st->codec->extradata); | |||
st->codec->extradata = av_mallocz(atom.size - 7 + FF_INPUT_BUFFER_PADDING_SIZE); | |||
if (!st->codec->extradata) | |||
return AVERROR(ENOMEM); | |||
st->codec->extradata_size = atom.size - 7; | |||
avio_seek(pb, 6, SEEK_CUR); | |||
avio_read(pb, st->codec->extradata, st->codec->extradata_size); | |||
return 0; | |||
} | |||
/** | |||
* An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself, | |||
* but can have extradata appended at the end after the 40 bytes belonging | |||
@@ -1706,6 +1732,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom) | |||
st->nb_frames= total_sample_count; | |||
if (duration) | |||
st->duration= duration; | |||
sc->track_end = duration; | |||
return 0; | |||
} | |||
@@ -2326,7 +2353,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom) | |||
if (flags & 0x001) data_offset = avio_rb32(pb); | |||
if (flags & 0x004) first_sample_flags = avio_rb32(pb); | |||
dts = st->duration - sc->time_offset; | |||
dts = sc->track_end - sc->time_offset; | |||
offset = frag->base_data_offset + data_offset; | |||
distance = 0; | |||
av_dlog(c->fc, "first sample flags 0x%x\n", first_sample_flags); | |||
@@ -2356,7 +2383,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom) | |||
sc->data_size += sample_size; | |||
} | |||
frag->moof_offset = offset; | |||
st->duration = dts + sc->time_offset; | |||
st->duration = sc->track_end = dts + sc->time_offset; | |||
return 0; | |||
} | |||
@@ -2538,6 +2565,7 @@ static const MOVParseTableEntry mov_default_parse_table[] = { | |||
{ MKTAG('w','f','e','x'), mov_read_wfex }, | |||
{ MKTAG('c','m','o','v'), mov_read_cmov }, | |||
{ MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */ | |||
{ MKTAG('d','v','c','1'), mov_read_dvc1 }, | |||
{ 0, NULL } | |||
}; | |||
@@ -0,0 +1,71 @@ | |||
/* | |||
* check XMM registers for clobbers on Win64 | |||
* Copyright (c) 2008 Ramiro Polla <ramiro.polla@gmail.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 <stdint.h> | |||
#include <stdlib.h> | |||
#include <stdarg.h> | |||
#include "libavutil/bswap.h" | |||
#define storexmmregs(mem) \ | |||
__asm__ volatile( \ | |||
"movups %%xmm6 , 0x00(%0)\n\t" \ | |||
"movups %%xmm7 , 0x10(%0)\n\t" \ | |||
"movups %%xmm8 , 0x20(%0)\n\t" \ | |||
"movups %%xmm9 , 0x30(%0)\n\t" \ | |||
"movups %%xmm10, 0x40(%0)\n\t" \ | |||
"movups %%xmm11, 0x50(%0)\n\t" \ | |||
"movups %%xmm12, 0x60(%0)\n\t" \ | |||
"movups %%xmm13, 0x70(%0)\n\t" \ | |||
"movups %%xmm14, 0x80(%0)\n\t" \ | |||
"movups %%xmm15, 0x90(%0)\n\t" \ | |||
:: "r"(mem) : "memory") | |||
#define testxmmclobbers(func, ctx, ...) \ | |||
uint64_t xmm[2][10][2]; \ | |||
int ret; \ | |||
storexmmregs(xmm[0]); \ | |||
ret = __real_ ## func(ctx, __VA_ARGS__); \ | |||
storexmmregs(xmm[1]); \ | |||
if (memcmp(xmm[0], xmm[1], sizeof(xmm[0]))) { \ | |||
int i; \ | |||
av_log(ctx, AV_LOG_ERROR, \ | |||
"XMM REGS CLOBBERED IN %s!\n", #func); \ | |||
for (i = 0; i < 10; i ++) \ | |||
if (xmm[0][i][0] != xmm[1][i][0] || \ | |||
xmm[0][i][1] != xmm[1][i][1]) { \ | |||
av_log(ctx, AV_LOG_ERROR, \ | |||
"xmm%-2d = %016"PRIx64"%016"PRIx64"\n", \ | |||
6 + i, av_bswap64(xmm[0][i][0]), \ | |||
av_bswap64(xmm[0][i][1])); \ | |||
av_log(ctx, AV_LOG_ERROR, \ | |||
" -> %016"PRIx64"%016"PRIx64"\n", \ | |||
av_bswap64(xmm[1][i][0]), \ | |||
av_bswap64(xmm[1][i][1])); \ | |||
} \ | |||
abort(); \ | |||
} \ | |||
return ret | |||
#define wrap(func) \ | |||
int __real_ ## func; \ | |||
int __wrap_ ## func; \ | |||
int __wrap_ ## func |
@@ -25,6 +25,8 @@ MMX-OBJS-$(HAVE_YASM) += x86/input.o \ | |||
$(SUBDIR)x86/swscale_mmx.o: CFLAGS += $(NOREDZONE_FLAGS) | |||
OBJS-$(CONFIG_XMM_CLOBBER_TEST) += x86/w64xmmtest.o | |||
TESTPROGS = colorspace swscale | |||
DIRS = bfin mlib ppc sparc x86 |
@@ -30,11 +30,11 @@ and converts it to RGB565. R:5 bits, G:6 bits, B:5 bits.. packed into shorts. | |||
The following calculation is used for the conversion: | |||
r = clipz((y-oy)*cy + crv*(v-128)) | |||
g = clipz((y-oy)*cy + cgv*(v-128) + cgu*(u-128)) | |||
b = clipz((y-oy)*cy + cbu*(u-128)) | |||
r = clipz((y - oy) * cy + crv * (v - 128)) | |||
g = clipz((y - oy) * cy + cgv * (v - 128) + cgu * (u - 128)) | |||
b = clipz((y - oy) * cy + cbu * (u - 128)) | |||
y,u,v are prescaled by a factor of 4 i.e. left-shifted to gain precision. | |||
y, u, v are prescaled by a factor of 4 i.e. left-shifted to gain precision. | |||
New factorization to eliminate the truncation error which was | |||
@@ -47,7 +47,7 @@ occurring due to the byteop3p. | |||
2) Scale operands up by a factor of 4 not 8 because Blackfin | |||
multiplies include a shift. | |||
3) Compute into the accumulators cy*yx0, cy*yx1. | |||
3) Compute into the accumulators cy * yx0, cy * yx1. | |||
4) Compute each of the linear equations: | |||
r = clipz((y - oy) * cy + crv * (v - 128)) | |||
@@ -73,7 +73,7 @@ occurring due to the byteop3p. | |||
Where coeffs have the following layout in memory. | |||
uint32_t oy,oc,zero,cy,crv,rmask,cbu,bmask,cgu,cgv; | |||
uint32_t oy, oc, zero, cy, crv, rmask, cbu, bmask, cgu, cgv; | |||
coeffs is a pointer to oy. | |||
@@ -27,32 +27,34 @@ | |||
#include <assert.h> | |||
#include "config.h" | |||
#include <unistd.h> | |||
#include "libswscale/rgb2rgb.h" | |||
#include "libswscale/swscale.h" | |||
#include "libswscale/swscale_internal.h" | |||
#if defined (__FDPIC__) && CONFIG_SRAM | |||
#define L1CODE __attribute__ ((l1_text)) | |||
#define L1CODE __attribute__((l1_text)) | |||
#else | |||
#define L1CODE | |||
#endif | |||
int ff_bfin_uyvytoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |||
int width, int height, | |||
int ff_bfin_uyvytoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, | |||
uint8_t *vdst, int width, int height, | |||
int lumStride, int chromStride, int srcStride) L1CODE; | |||
int ff_bfin_yuyvtoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst, | |||
int width, int height, | |||
int ff_bfin_yuyvtoyv12(const uint8_t *src, uint8_t *ydst, uint8_t *udst, | |||
uint8_t *vdst, int width, int height, | |||
int lumStride, int chromStride, int srcStride) L1CODE; | |||
static int uyvytoyv12_unscaled(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY, | |||
int srcSliceH, uint8_t* dst[], int dstStride[]) | |||
static int uyvytoyv12_unscaled(SwsContext *c, uint8_t *src[], int srcStride[], | |||
int srcSliceY, int srcSliceH, uint8_t *dst[], | |||
int dstStride[]) | |||
{ | |||
uint8_t *dsty = dst[0] + dstStride[0]*srcSliceY; | |||
uint8_t *dstu = dst[1] + dstStride[1]*srcSliceY/2; | |||
uint8_t *dstv = dst[2] + dstStride[2]*srcSliceY/2; | |||
uint8_t *ip = src[0] + srcStride[0]*srcSliceY; | |||
int w = dstStride[0]; | |||
uint8_t *dsty = dst[0] + dstStride[0] * srcSliceY; | |||
uint8_t *dstu = dst[1] + dstStride[1] * srcSliceY / 2; | |||
uint8_t *dstv = dst[2] + dstStride[2] * srcSliceY / 2; | |||
uint8_t *ip = src[0] + srcStride[0] * srcSliceY; | |||
int w = dstStride[0]; | |||
ff_bfin_uyvytoyv12(ip, dsty, dstu, dstv, w, srcSliceH, | |||
dstStride[0], dstStride[1], srcStride[0]); | |||
@@ -60,14 +62,15 @@ static int uyvytoyv12_unscaled(SwsContext *c, uint8_t* src[], int srcStride[], i | |||
return srcSliceH; | |||
} | |||
static int yuyvtoyv12_unscaled(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY, | |||
int srcSliceH, uint8_t* dst[], int dstStride[]) | |||
static int yuyvtoyv12_unscaled(SwsContext *c, uint8_t *src[], int srcStride[], | |||
int srcSliceY, int srcSliceH, uint8_t *dst[], | |||
int dstStride[]) | |||
{ | |||
uint8_t *dsty = dst[0] + dstStride[0]*srcSliceY; | |||
uint8_t *dstu = dst[1] + dstStride[1]*srcSliceY/2; | |||
uint8_t *dstv = dst[2] + dstStride[2]*srcSliceY/2; | |||
uint8_t *ip = src[0] + srcStride[0]*srcSliceY; | |||
int w = dstStride[0]; | |||
uint8_t *dsty = dst[0] + dstStride[0] * srcSliceY; | |||
uint8_t *dstu = dst[1] + dstStride[1] * srcSliceY / 2; | |||
uint8_t *dstv = dst[2] + dstStride[2] * srcSliceY / 2; | |||
uint8_t *ip = src[0] + srcStride[0] * srcSliceY; | |||
int w = dstStride[0]; | |||
ff_bfin_yuyvtoyv12(ip, dsty, dstu, dstv, w, srcSliceH, | |||
dstStride[0], dstStride[1], srcStride[0]); | |||
@@ -75,15 +78,16 @@ static int yuyvtoyv12_unscaled(SwsContext *c, uint8_t* src[], int srcStride[], i | |||
return srcSliceH; | |||
} | |||
void ff_bfin_get_unscaled_swscale(SwsContext *c) | |||
{ | |||
if (c->dstFormat == PIX_FMT_YUV420P && c->srcFormat == PIX_FMT_UYVY422) { | |||
av_log (NULL, AV_LOG_VERBOSE, "selecting Blackfin optimized uyvytoyv12_unscaled\n"); | |||
av_log(NULL, AV_LOG_VERBOSE, | |||
"selecting Blackfin optimized uyvytoyv12_unscaled\n"); | |||
c->swScale = uyvytoyv12_unscaled; | |||
} | |||
if (c->dstFormat == PIX_FMT_YUV420P && c->srcFormat == PIX_FMT_YUYV422) { | |||
av_log (NULL, AV_LOG_VERBOSE, "selecting Blackfin optimized yuyvtoyv12_unscaled\n"); | |||
av_log(NULL, AV_LOG_VERBOSE, | |||
"selecting Blackfin optimized yuyvtoyv12_unscaled\n"); | |||
c->swScale = yuyvtoyv12_unscaled; | |||
} | |||
} |
@@ -26,15 +26,16 @@ | |||
#include <string.h> | |||
#include <inttypes.h> | |||
#include <assert.h> | |||
#include "config.h" | |||
#include <unistd.h> | |||
#include "libavutil/pixdesc.h" | |||
#include "config.h" | |||
#include "libswscale/rgb2rgb.h" | |||
#include "libswscale/swscale.h" | |||
#include "libswscale/swscale_internal.h" | |||
#if defined(__FDPIC__) && CONFIG_SRAM | |||
#define L1CODE __attribute__ ((l1_text)) | |||
#define L1CODE __attribute__((l1_text)) | |||
#else | |||
#define L1CODE | |||
#endif | |||
@@ -48,21 +49,20 @@ void ff_bfin_yuv2rgb565_line(uint8_t *Y, uint8_t *U, uint8_t *V, uint8_t *out, | |||
void ff_bfin_yuv2rgb24_line(uint8_t *Y, uint8_t *U, uint8_t *V, uint8_t *out, | |||
int w, uint32_t *coeffs) L1CODE; | |||
typedef void (* ltransform)(uint8_t *Y, uint8_t *U, uint8_t *V, uint8_t *out, | |||
int w, uint32_t *coeffs); | |||
typedef void (*ltransform)(uint8_t *Y, uint8_t *U, uint8_t *V, uint8_t *out, | |||
int w, uint32_t *coeffs); | |||
static void bfin_prepare_coefficients(SwsContext *c, int rgb, int masks) | |||
{ | |||
int oy; | |||
oy = c->yOffset&0xffff; | |||
oy = oy >> 3; // keep everything U8.0 for offset calculation | |||
oy = c->yOffset & 0xffff; | |||
oy = oy >> 3; // keep everything U8.0 for offset calculation | |||
c->oc = 128*0x01010101U; | |||
c->oy = oy*0x01010101U; | |||
c->oc = 128 * 0x01010101U; | |||
c->oy = oy * 0x01010101U; | |||
/* copy 64bit vector coeffs down to 32bit vector coeffs */ | |||
c->cy = c->yCoeff; | |||
c->cy = c->yCoeff; | |||
c->zero = 0; | |||
if (rgb) { | |||
@@ -77,7 +77,6 @@ static void bfin_prepare_coefficients(SwsContext *c, int rgb, int masks) | |||
c->cgv = c->ugCoeff; | |||
} | |||
if (masks == 555) { | |||
c->rmask = 0x001f * 0x00010001U; | |||
c->gmask = 0x03e0 * 0x00010001U; | |||
@@ -89,27 +88,25 @@ static void bfin_prepare_coefficients(SwsContext *c, int rgb, int masks) | |||
} | |||
} | |||
static int core_yuv420_rgb(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides, | |||
ltransform lcscf, int rgb, int masks) | |||
static int core_yuv420_rgb(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, uint8_t **oplanes, | |||
int *outstrides, ltransform lcscf, | |||
int rgb, int masks) | |||
{ | |||
uint8_t *py,*pu,*pv,*op; | |||
uint8_t *py, *pu, *pv, *op; | |||
int w = instrides[0]; | |||
int h2 = srcSliceH>>1; | |||
int h2 = srcSliceH >> 1; | |||
int i; | |||
bfin_prepare_coefficients(c, rgb, masks); | |||
py = in[0]; | |||
pu = in[1+(1^rgb)]; | |||
pv = in[1+(0^rgb)]; | |||
op = oplanes[0] + srcSliceY*outstrides[0]; | |||
pu = in[1 + (1 ^ rgb)]; | |||
pv = in[1 + (0 ^ rgb)]; | |||
for (i=0;i<h2;i++) { | |||
op = oplanes[0] + srcSliceY * outstrides[0]; | |||
for (i = 0; i < h2; i++) { | |||
lcscf(py, pu, pv, op, w, &c->oy); | |||
py += instrides[0]; | |||
@@ -126,9 +123,7 @@ static int core_yuv420_rgb(SwsContext *c, | |||
return srcSliceH; | |||
} | |||
static int bfin_yuv420_rgb555(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
static int bfin_yuv420_rgb555(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides) | |||
{ | |||
@@ -136,8 +131,7 @@ static int bfin_yuv420_rgb555(SwsContext *c, | |||
outstrides, ff_bfin_yuv2rgb555_line, 1, 555); | |||
} | |||
static int bfin_yuv420_bgr555(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
static int bfin_yuv420_bgr555(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides) | |||
{ | |||
@@ -145,8 +139,7 @@ static int bfin_yuv420_bgr555(SwsContext *c, | |||
outstrides, ff_bfin_yuv2rgb555_line, 0, 555); | |||
} | |||
static int bfin_yuv420_rgb24(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
static int bfin_yuv420_rgb24(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides) | |||
{ | |||
@@ -154,8 +147,7 @@ static int bfin_yuv420_rgb24(SwsContext *c, | |||
outstrides, ff_bfin_yuv2rgb24_line, 1, 888); | |||
} | |||
static int bfin_yuv420_bgr24(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
static int bfin_yuv420_bgr24(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides) | |||
{ | |||
@@ -163,8 +155,7 @@ static int bfin_yuv420_bgr24(SwsContext *c, | |||
outstrides, ff_bfin_yuv2rgb24_line, 0, 888); | |||
} | |||
static int bfin_yuv420_rgb565(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
static int bfin_yuv420_rgb565(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides) | |||
{ | |||
@@ -172,8 +163,7 @@ static int bfin_yuv420_rgb565(SwsContext *c, | |||
outstrides, ff_bfin_yuv2rgb565_line, 1, 565); | |||
} | |||
static int bfin_yuv420_bgr565(SwsContext *c, | |||
uint8_t **in, int *instrides, | |||
static int bfin_yuv420_bgr565(SwsContext *c, uint8_t **in, int *instrides, | |||
int srcSliceY, int srcSliceH, | |||
uint8_t **oplanes, int *outstrides) | |||
{ | |||
@@ -181,18 +171,29 @@ static int bfin_yuv420_bgr565(SwsContext *c, | |||
outstrides, ff_bfin_yuv2rgb565_line, 0, 565); | |||
} | |||
SwsFunc ff_yuv2rgb_get_func_ptr_bfin(SwsContext *c) | |||
{ | |||
SwsFunc f; | |||
switch(c->dstFormat) { | |||
case PIX_FMT_RGB555: f = bfin_yuv420_rgb555; break; | |||
case PIX_FMT_BGR555: f = bfin_yuv420_bgr555; break; | |||
case PIX_FMT_RGB565: f = bfin_yuv420_rgb565; break; | |||
case PIX_FMT_BGR565: f = bfin_yuv420_bgr565; break; | |||
case PIX_FMT_RGB24: f = bfin_yuv420_rgb24; break; | |||
case PIX_FMT_BGR24: f = bfin_yuv420_bgr24; break; | |||
switch (c->dstFormat) { | |||
case PIX_FMT_RGB555: | |||
f = bfin_yuv420_rgb555; | |||
break; | |||
case PIX_FMT_BGR555: | |||
f = bfin_yuv420_bgr555; | |||
break; | |||
case PIX_FMT_RGB565: | |||
f = bfin_yuv420_rgb565; | |||
break; | |||
case PIX_FMT_BGR565: | |||
f = bfin_yuv420_bgr565; | |||
break; | |||
case PIX_FMT_RGB24: | |||
f = bfin_yuv420_rgb24; | |||
break; | |||
case PIX_FMT_BGR24: | |||
f = bfin_yuv420_bgr24; | |||
break; | |||
default: | |||
return 0; | |||
} | |||
@@ -51,6 +51,19 @@ bgr_Vcoeff_3x56: times 2 dw RV, 0, GV, RV | |||
rgb_Vcoeff_12x4: times 2 dw RV, GV, 0, RV | |||
rgb_Vcoeff_3x56: times 2 dw BV, 0, GV, BV | |||
rgba_Ycoeff_rb: times 4 dw RY, BY | |||
rgba_Ycoeff_br: times 4 dw BY, RY | |||
rgba_Ycoeff_ga: times 4 dw GY, 0 | |||
rgba_Ycoeff_ag: times 4 dw 0, GY | |||
rgba_Ucoeff_rb: times 4 dw RU, BU | |||
rgba_Ucoeff_br: times 4 dw BU, RU | |||
rgba_Ucoeff_ga: times 4 dw GU, 0 | |||
rgba_Ucoeff_ag: times 4 dw 0, GU | |||
rgba_Vcoeff_rb: times 4 dw RV, BV | |||
rgba_Vcoeff_br: times 4 dw BV, RV | |||
rgba_Vcoeff_ga: times 4 dw GV, 0 | |||
rgba_Vcoeff_ag: times 4 dw 0, GV | |||
shuf_rgb_12x4: db 0, 0x80, 1, 0x80, 2, 0x80, 3, 0x80, \ | |||
6, 0x80, 7, 0x80, 8, 0x80, 9, 0x80 | |||
shuf_rgb_3x56: db 2, 0x80, 3, 0x80, 4, 0x80, 5, 0x80, \ | |||
@@ -294,6 +307,150 @@ RGB24_FUNCS 11, 13 | |||
INIT_XMM avx | |||
RGB24_FUNCS 11, 13 | |||
; %1 = nr. of XMM registers | |||
; %2-5 = rgba, bgra, argb or abgr (in individual characters) | |||
%macro RGB32_TO_Y_FN 5-6 | |||
cglobal %2%3%4%5 %+ ToY, 6, 6, %1, dst, src, u1, u2, w, u3 | |||
mova m5, [rgba_Ycoeff_%2%4] | |||
mova m6, [rgba_Ycoeff_%3%5] | |||
%if %0 == 6 | |||
jmp mangle(program_name %+ _ %+ %6 %+ ToY %+ SUFFIX).body | |||
%else ; %0 == 6 | |||
.body: | |||
%if ARCH_X86_64 | |||
movsxd wq, wd | |||
%endif | |||
lea srcq, [srcq+wq*4] | |||
add wq, wq | |||
add dstq, wq | |||
neg wq | |||
mova m4, [rgb_Yrnd] | |||
pcmpeqb m7, m7 | |||
psrlw m7, 8 ; (word) { 0x00ff } x4 | |||
.loop: | |||
; FIXME check alignment and use mova | |||
movu m0, [srcq+wq*2+0] ; (byte) { Bx, Gx, Rx, xx }[0-3] | |||
movu m2, [srcq+wq*2+mmsize] ; (byte) { Bx, Gx, Rx, xx }[4-7] | |||
DEINTB 1, 0, 3, 2, 7 ; (word) { Gx, xx (m0/m2) or Bx, Rx (m1/m3) }[0-3]/[4-7] | |||
pmaddwd m1, m5 ; (dword) { Bx*BY + Rx*RY }[0-3] | |||
pmaddwd m0, m6 ; (dword) { Gx*GY }[0-3] | |||
pmaddwd m3, m5 ; (dword) { Bx*BY + Rx*RY }[4-7] | |||
pmaddwd m2, m6 ; (dword) { Gx*GY }[4-7] | |||
paddd m0, m4 ; += rgb_Yrnd | |||
paddd m2, m4 ; += rgb_Yrnd | |||
paddd m0, m1 ; (dword) { Y[0-3] } | |||
paddd m2, m3 ; (dword) { Y[4-7] } | |||
psrad m0, 9 | |||
psrad m2, 9 | |||
packssdw m0, m2 ; (word) { Y[0-7] } | |||
mova [dstq+wq], m0 | |||
add wq, mmsize | |||
jl .loop | |||
REP_RET | |||
%endif ; %0 == 3 | |||
%endmacro | |||
; %1 = nr. of XMM registers | |||
; %2-5 = rgba, bgra, argb or abgr (in individual characters) | |||
%macro RGB32_TO_UV_FN 5-6 | |||
cglobal %2%3%4%5 %+ ToUV, 7, 7, %1, dstU, dstV, u1, src, u2, w, u3 | |||
%if ARCH_X86_64 | |||
mova m8, [rgba_Ucoeff_%2%4] | |||
mova m9, [rgba_Ucoeff_%3%5] | |||
mova m10, [rgba_Vcoeff_%2%4] | |||
mova m11, [rgba_Vcoeff_%3%5] | |||
%define coeffU1 m8 | |||
%define coeffU2 m9 | |||
%define coeffV1 m10 | |||
%define coeffV2 m11 | |||
%else ; x86-32 | |||
%define coeffU1 [rgba_Ucoeff_%2%4] | |||
%define coeffU2 [rgba_Ucoeff_%3%5] | |||
%define coeffV1 [rgba_Vcoeff_%2%4] | |||
%define coeffV2 [rgba_Vcoeff_%3%5] | |||
%endif ; x86-64/32 | |||
%if ARCH_X86_64 && %0 == 6 | |||
jmp mangle(program_name %+ _ %+ %6 %+ ToUV %+ SUFFIX).body | |||
%else ; ARCH_X86_64 && %0 == 6 | |||
.body: | |||
%if ARCH_X86_64 | |||
movsxd wq, dword r5m | |||
%else ; x86-32 | |||
mov wq, r5m | |||
%endif | |||
add wq, wq | |||
add dstUq, wq | |||
add dstVq, wq | |||
lea srcq, [srcq+wq*2] | |||
neg wq | |||
pcmpeqb m7, m7 | |||
psrlw m7, 8 ; (word) { 0x00ff } x4 | |||
mova m6, [rgb_UVrnd] | |||
.loop: | |||
; FIXME check alignment and use mova | |||
movu m0, [srcq+wq*2+0] ; (byte) { Bx, Gx, Rx, xx }[0-3] | |||
movu m4, [srcq+wq*2+mmsize] ; (byte) { Bx, Gx, Rx, xx }[4-7] | |||
DEINTB 1, 0, 5, 4, 7 ; (word) { Gx, xx (m0/m4) or Bx, Rx (m1/m5) }[0-3]/[4-7] | |||
pmaddwd m3, m1, coeffV1 ; (dword) { Bx*BV + Rx*RV }[0-3] | |||
pmaddwd m2, m0, coeffV2 ; (dword) { Gx*GV }[0-3] | |||
pmaddwd m1, coeffU1 ; (dword) { Bx*BU + Rx*RU }[0-3] | |||
pmaddwd m0, coeffU2 ; (dword) { Gx*GU }[0-3] | |||
paddd m3, m6 ; += rgb_UVrnd | |||
paddd m1, m6 ; += rgb_UVrnd | |||
paddd m2, m3 ; (dword) { V[0-3] } | |||
paddd m0, m1 ; (dword) { U[0-3] } | |||
pmaddwd m3, m5, coeffV1 ; (dword) { Bx*BV + Rx*RV }[4-7] | |||
pmaddwd m1, m4, coeffV2 ; (dword) { Gx*GV }[4-7] | |||
pmaddwd m5, coeffU1 ; (dword) { Bx*BU + Rx*RU }[4-7] | |||
pmaddwd m4, coeffU2 ; (dword) { Gx*GU }[4-7] | |||
paddd m3, m6 ; += rgb_UVrnd | |||
paddd m5, m6 ; += rgb_UVrnd | |||
psrad m0, 9 | |||
paddd m1, m3 ; (dword) { V[4-7] } | |||
paddd m4, m5 ; (dword) { U[4-7] } | |||
psrad m2, 9 | |||
psrad m4, 9 | |||
psrad m1, 9 | |||
packssdw m0, m4 ; (word) { U[0-7] } | |||
packssdw m2, m1 ; (word) { V[0-7] } | |||
%if mmsize == 8 | |||
mova [dstUq+wq], m0 | |||
mova [dstVq+wq], m2 | |||
%else ; mmsize == 16 | |||
mova [dstUq+wq], m0 | |||
mova [dstVq+wq], m2 | |||
%endif ; mmsize == 8/16 | |||
add wq, mmsize | |||
jl .loop | |||
REP_RET | |||
%endif ; ARCH_X86_64 && %0 == 3 | |||
%endmacro | |||
; %1 = nr. of XMM registers for rgb-to-Y func | |||
; %2 = nr. of XMM registers for rgb-to-UV func | |||
%macro RGB32_FUNCS 2 | |||
RGB32_TO_Y_FN %1, r, g, b, a | |||
RGB32_TO_Y_FN %1, b, g, r, a, rgba | |||
RGB32_TO_Y_FN %1, a, r, g, b, rgba | |||
RGB32_TO_Y_FN %1, a, b, g, r, rgba | |||
RGB32_TO_UV_FN %2, r, g, b, a | |||
RGB32_TO_UV_FN %2, b, g, r, a, rgba | |||
RGB32_TO_UV_FN %2, a, r, g, b, rgba | |||
RGB32_TO_UV_FN %2, a, b, g, r, rgba | |||
%endmacro | |||
%if ARCH_X86_32 | |||
INIT_MMX mmx | |||
RGB32_FUNCS 0, 0 | |||
%endif | |||
INIT_XMM sse2 | |||
RGB32_FUNCS 8, 12 | |||
INIT_XMM avx | |||
RGB32_FUNCS 8, 12 | |||
;----------------------------------------------------------------------------- | |||
; YUYV/UYVY/NV12/NV21 packed pixel shuffling. | |||
; | |||
@@ -308,6 +308,10 @@ extern void ff_ ## fmt ## ToUV_ ## opt(uint8_t *dstU, uint8_t *dstV, \ | |||
INPUT_FUNC(yuyv, opt); \ | |||
INPUT_UV_FUNC(nv12, opt); \ | |||
INPUT_UV_FUNC(nv21, opt); \ | |||
INPUT_FUNC(rgba, opt); \ | |||
INPUT_FUNC(bgra, opt); \ | |||
INPUT_FUNC(argb, opt); \ | |||
INPUT_FUNC(abgr, opt); \ | |||
INPUT_FUNC(rgb24, opt); \ | |||
INPUT_FUNC(bgr24, opt) | |||
@@ -406,6 +410,10 @@ switch(c->dstBpc){ \ | |||
break; | |||
case_rgb(rgb24, RGB24, mmx); | |||
case_rgb(bgr24, BGR24, mmx); | |||
case_rgb(bgra, BGRA, mmx); | |||
case_rgb(rgba, RGBA, mmx); | |||
case_rgb(abgr, ABGR, mmx); | |||
case_rgb(argb, ARGB, mmx); | |||
default: | |||
break; | |||
} | |||
@@ -450,6 +458,10 @@ switch(c->dstBpc){ \ | |||
break; | |||
case_rgb(rgb24, RGB24, sse2); | |||
case_rgb(bgr24, BGR24, sse2); | |||
case_rgb(bgra, BGRA, sse2); | |||
case_rgb(rgba, RGBA, sse2); | |||
case_rgb(abgr, ABGR, sse2); | |||
case_rgb(argb, ARGB, sse2); | |||
default: | |||
break; | |||
} | |||
@@ -493,6 +505,10 @@ switch(c->dstBpc){ \ | |||
break; | |||
case_rgb(rgb24, RGB24, avx); | |||
case_rgb(bgr24, BGR24, avx); | |||
case_rgb(bgra, BGRA, avx); | |||
case_rgb(rgba, RGBA, avx); | |||
case_rgb(abgr, ABGR, avx); | |||
case_rgb(argb, ARGB, avx); | |||
default: | |||
break; | |||
} | |||
@@ -0,0 +1,31 @@ | |||
/* | |||
* check XMM registers for clobbers on Win64 | |||
* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.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 "libavutil/x86/w64xmmtest.h" | |||
#include "libswscale/swscale.h" | |||
wrap(sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], | |||
const int srcStride[], int srcSliceY, int srcSliceH, | |||
uint8_t *const dst[], const int dstStride[])) | |||
{ | |||
testxmmclobbers(sws_scale, c, srcSlice, srcStride, srcSliceY, | |||
srcSliceH, dst, dstStride); | |||
} |
@@ -368,7 +368,7 @@ $tiny_psnr $pcm_dst $pcm_ref 2 1924 | |||
fi | |||
if [ -n "$do_ac3_fixed" ] ; then | |||
do_audio_encoding ac3.rm "-vn -acodec ac3_fixed" | |||
do_audio_encoding ac3.ac3 "-vn -acodec ac3_fixed" | |||
# binaries configured with --disable-sse decode ac3 differently | |||
#do_audio_decoding | |||
#$tiny_psnr $pcm_dst $pcm_ref 2 1024 | |||
@@ -1,2 +1,2 @@ | |||
e7fa185030a56d9db8663ad9e38c6c94 *./tests/data/acodec/ac3.rm | |||
98751 ./tests/data/acodec/ac3.rm | |||
a1d1fc116463b771abf5aef7ed37d7b1 *./tests/data/acodec/ac3.ac3 | |||
96408 ./tests/data/acodec/ac3.ac3 |
@@ -117,4 +117,3 @@ | |||
0, 438750, 37440, 0xf0fe8c1c | |||
0, 442500, 37440, 0xc0036222 | |||
0, 446250, 37440, 0x3058385c | |||
0, 450000, 37440, 0x68141016 |
@@ -0,0 +1,49 @@ | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 0 size: 556 | |||
ret: 0 st:-1 flags:0 ts:-1.000000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 0 size: 556 | |||
ret: 0 st:-1 flags:1 ts: 1.894167 | |||
ret: 0 st: 0 flags:1 dts: 1.880400 pts: 1.880400 pos: 30092 size: 558 | |||
ret: 0 st: 0 flags:0 ts: 0.788333 | |||
ret: 0 st: 0 flags:1 dts: 0.800911 pts: 0.800911 pos: 12818 size: 556 | |||
ret:-1 st: 0 flags:1 ts:-0.317500 | |||
ret: 0 st:-1 flags:0 ts: 2.576668 | |||
ret: 0 st: 0 flags:1 dts: 2.576844 pts: 2.576844 pos: 41238 size: 558 | |||
ret: 0 st:-1 flags:1 ts: 1.470835 | |||
ret: 0 st: 0 flags:1 dts: 1.462533 pts: 1.462533 pos: 23406 size: 556 | |||
ret: 0 st: 0 flags:0 ts: 0.365000 | |||
ret: 0 st: 0 flags:1 dts: 0.383044 pts: 0.383044 pos: 6130 size: 558 | |||
ret:-1 st: 0 flags:1 ts:-0.740833 | |||
ret: 0 st:-1 flags:0 ts: 2.153336 | |||
ret: 0 st: 0 flags:1 dts: 2.158978 pts: 2.158978 pos: 34552 size: 556 | |||
ret: 0 st:-1 flags:1 ts: 1.047503 | |||
ret: 0 st: 0 flags:1 dts: 1.044667 pts: 1.044667 pos: 16718 size: 558 | |||
ret: 0 st: 0 flags:0 ts:-0.058333 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 0 size: 556 | |||
ret: 0 st: 0 flags:1 ts: 2.835833 | |||
ret: 0 st: 0 flags:1 dts: 2.820600 pts: 2.820600 pos: 45140 size: 556 | |||
ret: 0 st:-1 flags:0 ts: 1.730004 | |||
ret: 0 st: 0 flags:1 dts: 1.741111 pts: 1.741111 pos: 27864 size: 556 | |||
ret: 0 st:-1 flags:1 ts: 0.624171 | |||
ret: 0 st: 0 flags:1 dts: 0.591978 pts: 0.591978 pos: 9474 size: 556 | |||
ret: 0 st: 0 flags:0 ts:-0.481667 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 0 size: 556 | |||
ret: 0 st: 0 flags:1 ts: 2.412500 | |||
ret: 0 st: 0 flags:1 dts: 2.402733 pts: 2.402733 pos: 38452 size: 558 | |||
ret: 0 st:-1 flags:0 ts: 1.306672 | |||
ret: 0 st: 0 flags:1 dts: 1.323244 pts: 1.323244 pos: 21176 size: 558 | |||
ret: 0 st:-1 flags:1 ts: 0.200839 | |||
ret: 0 st: 0 flags:1 dts: 0.174111 pts: 0.174111 pos: 2786 size: 558 | |||
ret: 0 st: 0 flags:0 ts:-0.904989 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 0 size: 556 | |||
ret: 0 st: 0 flags:1 ts: 1.989178 | |||
ret: 0 st: 0 flags:1 dts: 1.984867 pts: 1.984867 pos: 31764 size: 558 | |||
ret: 0 st:-1 flags:0 ts: 0.883340 | |||
ret: 0 st: 0 flags:1 dts: 0.905378 pts: 0.905378 pos: 14488 size: 558 | |||
ret:-1 st:-1 flags:1 ts:-0.222493 | |||
ret: 0 st: 0 flags:0 ts: 2.671678 | |||
ret: 0 st: 0 flags:1 dts: 2.681311 pts: 2.681311 pos: 42910 size: 558 | |||
ret: 0 st: 0 flags:1 ts: 1.565844 | |||
ret: 0 st: 0 flags:1 dts: 1.532178 pts: 1.532178 pos: 24520 size: 558 | |||
ret: 0 st:-1 flags:0 ts: 0.460008 | |||
ret: 0 st: 0 flags:1 dts: 0.487511 pts: 0.487511 pos: 7802 size: 556 | |||
ret:-1 st:-1 flags:1 ts:-0.645825 |
@@ -1,41 +0,0 @@ | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret: 0 st:-1 flags:0 ts:-1.000000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret:-1 st:-1 flags:1 ts: 1.894167 | |||
ret:-1 st: 0 flags:0 ts: 0.788000 | |||
ret: 0 st: 0 flags:1 ts:-0.317000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret: 0 st:-1 flags:0 ts: 2.576668 | |||
ret: 0 st: 0 flags:1 dts: 2.124000 pts: 2.124000 pos: 34997 size: 558 | |||
ret:-1 st:-1 flags:1 ts: 1.470835 | |||
ret:-1 st: 0 flags:0 ts: 0.365000 | |||
ret: 0 st: 0 flags:1 ts:-0.741000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret: 0 st:-1 flags:0 ts: 2.153336 | |||
ret: 0 st: 0 flags:1 dts: 2.124000 pts: 2.124000 pos: 34997 size: 558 | |||
ret:-1 st:-1 flags:1 ts: 1.047503 | |||
ret: 0 st: 0 flags:0 ts:-0.058000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret: 0 st: 0 flags:1 ts: 2.836000 | |||
ret: 0 st: 0 flags:1 dts: 2.124000 pts: 2.124000 pos: 34997 size: 558 | |||
ret:-1 st:-1 flags:0 ts: 1.730004 | |||
ret:-1 st:-1 flags:1 ts: 0.624171 | |||
ret: 0 st: 0 flags:0 ts:-0.482000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret: 0 st: 0 flags:1 ts: 2.413000 | |||
ret: 0 st: 0 flags:1 dts: 2.124000 pts: 2.124000 pos: 34997 size: 558 | |||
ret: 0 st:-1 flags:0 ts: 1.306672 | |||
ret: 0 st: 0 flags:1 dts:65.537000 pts:65.537000 pos: 87488 size: 6132 | |||
ret:-1 st:-1 flags:1 ts: 0.200839 | |||
ret: 0 st: 0 flags:0 ts:-0.905000 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret:-1 st: 0 flags:1 ts: 1.989000 | |||
ret:-1 st:-1 flags:0 ts: 0.883340 | |||
ret: 0 st:-1 flags:1 ts:-0.222493 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 | |||
ret:-1 st: 0 flags:0 ts: 2.672000 | |||
ret:-1 st: 0 flags:1 ts: 1.566000 | |||
ret: 0 st:-1 flags:0 ts: 0.460008 | |||
ret: 0 st: 0 flags:1 dts: 1.567000 pts: 1.567000 pos: 25889 size: 556 | |||
ret: 0 st:-1 flags:1 ts:-0.645825 | |||
ret: 0 st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 271 size: 556 |