falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Merge remote-tracking branch 'qatar/master' 

* qatar/master:
  swscale: make yuv2yuv1 use named registers.
  h264: mark h264_idct_add8_10 with number of XMM registers.
  swscale: fix V plane memory location in bilinear/unscaled RGB/YUYV case.
  vp8: always update next_framep[] before returning from decode_frame().
  avconv: estimate next_dts from framerate if it is set.
  avconv: better next_dts usage.
  avconv: rename InputStream.pts to last_dts.
  avconv: reduce overloading for InputStream.pts.
  avconv: rename InputStream.next_pts to next_dts.
  avconv: rework -t handling for encoding.
  avconv: set encoder timebase for subtitles.
  pva-demux test: add -vn
  swscale: K&R formatting cosmetics for SPARC code
  apedec: allow the user to set the maximum number of output samples per call
  apedec: do not unnecessarily zero output samples for mono frames
  apedec: allocate a single flat buffer for decoded samples
  apedec: use sizeof(field) instead of sizeof(type)
  swscale: split C output functions into separate file.
  swscale: Split C input functions into separate file.
  bytestream: Add bytestream2 writing API.

The avconv changes are due to massive regressions and bugs not merged yet.

Conflicts:
	ffmpeg.c
	libavcodec/vp8.c
	libswscale/swscale.c
	libswscale/x86/swscale_template.c
	tests/fate/demux.mak
	tests/ref/lavf/asf
	tests/ref/lavf/avi
	tests/ref/lavf/mkv
	tests/ref/lavf/mpg
	tests/ref/lavf/nut
	tests/ref/lavf/ogg
	tests/ref/lavf/rm
	tests/ref/lavf/ts
	tests/ref/seek/lavf_avi
	tests/ref/seek/lavf_mkv
	tests/ref/seek/lavf_rm

Merged-by: Michael Niedermayer <michaelni@gmx.at>
tags/n0.11
Michael Niedermayer 13 years ago
parent
950930b461 ef1c785f11
commit
18d0a16fc9
14 changed files with 2822 additions and 2630 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -0
      ffmpeg.c
  2. +61
    -43
      libavcodec/apedec.c
  3. +112
    -0
      libavcodec/bytestream.h
  4. +32
    -46
      libavcodec/vp8.c
  5. +1
    -1
      libavcodec/x86/h264_idct_10bit.asm
  6. +2
    -2
      libswscale/Makefile
  7. +799
    -0
      libswscale/input.c
  8. +1523
    -0
      libswscale/output.c
  9. +125
    -126
      libswscale/sparc/yuv2rgb_vis.c
  10. +23
    -2373
      libswscale/swscale.c
  11. +10
    -2
      libswscale/swscale_internal.h
  12. +96
    -0
      libswscale/swscale_unscaled.c
  13. +25
    -25
      libswscale/x86/output.asm
  14. +12
    -12
      libswscale/x86/swscale_template.c

+ 1
- 0
ffmpeg.c View File

@@ -2616,6 +2616,7 @@ static int transcode_init(OutputFile *output_files, int nb_output_files,
#endif #endif
break; break;
case AVMEDIA_TYPE_SUBTITLE: case AVMEDIA_TYPE_SUBTITLE:
codec->time_base = (AVRational){1, 1000};
break; break;
default: default:
abort(); abort();


+ 61
- 43
libavcodec/apedec.c View File

@@ -25,13 +25,13 @@
#include "bytestream.h" #include "bytestream.h"
#include "libavutil/audioconvert.h" #include "libavutil/audioconvert.h"
#include "libavutil/avassert.h" #include "libavutil/avassert.h"
#include "libavutil/opt.h"


/** /**
* @file * @file
* Monkey's Audio lossless audio decoder * Monkey's Audio lossless audio decoder
*/ */


#define BLOCKS_PER_LOOP 4608
#define MAX_CHANNELS 2 #define MAX_CHANNELS 2
#define MAX_BYTESPERSAMPLE 3 #define MAX_BYTESPERSAMPLE 3


@@ -126,6 +126,7 @@ typedef struct APEPredictor {


/** Decoder context */ /** Decoder context */
typedef struct APEContext { typedef struct APEContext {
AVClass *class; ///< class for AVOptions
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame frame; AVFrame frame;
DSPContext dsp; DSPContext dsp;
@@ -142,8 +143,10 @@ typedef struct APEContext {
int frameflags; ///< frame flags int frameflags; ///< frame flags
APEPredictor predictor; ///< predictor used for final reconstruction APEPredictor predictor; ///< predictor used for final reconstruction


int32_t decoded0[BLOCKS_PER_LOOP]; ///< decoded data for the first channel
int32_t decoded1[BLOCKS_PER_LOOP]; ///< decoded data for the second channel
int32_t *decoded_buffer;
int decoded_size;
int32_t *decoded[MAX_CHANNELS]; ///< decoded data for each channel
int blocks_per_loop; ///< maximum number of samples to decode for each call


int16_t* filterbuf[APE_FILTER_LEVELS]; ///< filter memory int16_t* filterbuf[APE_FILTER_LEVELS]; ///< filter memory


@@ -170,8 +173,9 @@ static av_cold int ape_decode_close(AVCodecContext *avctx)
for (i = 0; i < APE_FILTER_LEVELS; i++) for (i = 0; i < APE_FILTER_LEVELS; i++)
av_freep(&s->filterbuf[i]); av_freep(&s->filterbuf[i]);


av_freep(&s->decoded_buffer);
av_freep(&s->data); av_freep(&s->data);
s->data_size = 0;
s->decoded_size = s->data_size = 0;


return 0; return 0;
} }
@@ -469,19 +473,13 @@ static inline int ape_decode_value(APEContext *ctx, APERice *rice)


static void entropy_decode(APEContext *ctx, int blockstodecode, int stereo) static void entropy_decode(APEContext *ctx, int blockstodecode, int stereo)
{ {
int32_t *decoded0 = ctx->decoded0;
int32_t *decoded1 = ctx->decoded1;
int32_t *decoded0 = ctx->decoded[0];
int32_t *decoded1 = ctx->decoded[1];


if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
/* We are pure silence, just memset the output buffer. */
memset(decoded0, 0, blockstodecode * sizeof(int32_t));
memset(decoded1, 0, blockstodecode * sizeof(int32_t));
} else {
while (blockstodecode--) {
*decoded0++ = ape_decode_value(ctx, &ctx->riceY);
if (stereo)
*decoded1++ = ape_decode_value(ctx, &ctx->riceX);
}
while (blockstodecode--) {
*decoded0++ = ape_decode_value(ctx, &ctx->riceY);
if (stereo)
*decoded1++ = ape_decode_value(ctx, &ctx->riceX);
} }
} }


@@ -525,7 +523,7 @@ static void init_predictor_decoder(APEContext *ctx)
APEPredictor *p = &ctx->predictor; APEPredictor *p = &ctx->predictor;


/* Zero the history buffers */ /* Zero the history buffers */
memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(int32_t));
memset(p->historybuffer, 0, PREDICTOR_SIZE * sizeof(*p->historybuffer));
p->buf = p->historybuffer; p->buf = p->historybuffer;


/* Initialize and zero the coefficients */ /* Initialize and zero the coefficients */
@@ -593,8 +591,8 @@ static av_always_inline int predictor_update_filter(APEPredictor *p,
static void predictor_decode_stereo(APEContext *ctx, int count) static void predictor_decode_stereo(APEContext *ctx, int count)
{ {
APEPredictor *p = &ctx->predictor; APEPredictor *p = &ctx->predictor;
int32_t *decoded0 = ctx->decoded0;
int32_t *decoded1 = ctx->decoded1;
int32_t *decoded0 = ctx->decoded[0];
int32_t *decoded1 = ctx->decoded[1];


while (count--) { while (count--) {
/* Predictor Y */ /* Predictor Y */
@@ -610,7 +608,8 @@ static void predictor_decode_stereo(APEContext *ctx, int count)


/* Have we filled the history buffer? */ /* Have we filled the history buffer? */
if (p->buf == p->historybuffer + HISTORY_SIZE) { if (p->buf == p->historybuffer + HISTORY_SIZE) {
memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t));
memmove(p->historybuffer, p->buf,
PREDICTOR_SIZE * sizeof(*p->historybuffer));
p->buf = p->historybuffer; p->buf = p->historybuffer;
} }
} }
@@ -619,7 +618,7 @@ static void predictor_decode_stereo(APEContext *ctx, int count)
static void predictor_decode_mono(APEContext *ctx, int count) static void predictor_decode_mono(APEContext *ctx, int count)
{ {
APEPredictor *p = &ctx->predictor; APEPredictor *p = &ctx->predictor;
int32_t *decoded0 = ctx->decoded0;
int32_t *decoded0 = ctx->decoded[0];
int32_t predictionA, currentA, A, sign; int32_t predictionA, currentA, A, sign;


currentA = p->lastA[0]; currentA = p->lastA[0];
@@ -650,7 +649,8 @@ static void predictor_decode_mono(APEContext *ctx, int count)


/* Have we filled the history buffer? */ /* Have we filled the history buffer? */
if (p->buf == p->historybuffer + HISTORY_SIZE) { if (p->buf == p->historybuffer + HISTORY_SIZE) {
memmove(p->historybuffer, p->buf, PREDICTOR_SIZE * sizeof(int32_t));
memmove(p->historybuffer, p->buf,
PREDICTOR_SIZE * sizeof(*p->historybuffer));
p->buf = p->historybuffer; p->buf = p->historybuffer;
} }


@@ -668,8 +668,8 @@ static void do_init_filter(APEFilter *f, int16_t *buf, int order)
f->delay = f->historybuffer + order * 2; f->delay = f->historybuffer + order * 2;
f->adaptcoeffs = f->historybuffer + order; f->adaptcoeffs = f->historybuffer + order;


memset(f->historybuffer, 0, (order * 2) * sizeof(int16_t));
memset(f->coeffs, 0, order * sizeof(int16_t));
memset(f->historybuffer, 0, (order * 2) * sizeof(*f->historybuffer));
memset(f->coeffs, 0, order * sizeof(*f->coeffs));
f->avg = 0; f->avg = 0;
} }


@@ -725,7 +725,7 @@ static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
/* Have we filled the history buffer? */ /* Have we filled the history buffer? */
if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) { if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
memmove(f->historybuffer, f->delay - (order * 2), memmove(f->historybuffer, f->delay - (order * 2),
(order * 2) * sizeof(int16_t));
(order * 2) * sizeof(*f->historybuffer));
f->delay = f->historybuffer + order * 2; f->delay = f->historybuffer + order * 2;
f->adaptcoeffs = f->historybuffer + order; f->adaptcoeffs = f->historybuffer + order;
} }
@@ -773,33 +773,29 @@ static int init_frame_decoder(APEContext *ctx)


static void ape_unpack_mono(APEContext *ctx, int count) static void ape_unpack_mono(APEContext *ctx, int count)
{ {
int32_t *decoded0 = ctx->decoded0;
int32_t *decoded1 = ctx->decoded1;

if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
entropy_decode(ctx, count, 0);
/* We are pure silence, so we're done. */ /* We are pure silence, so we're done. */
av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n"); av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence mono\n");
return; return;
} }


entropy_decode(ctx, count, 0); entropy_decode(ctx, count, 0);
ape_apply_filters(ctx, decoded0, NULL, count);
ape_apply_filters(ctx, ctx->decoded[0], NULL, count);


/* Now apply the predictor decoding */ /* Now apply the predictor decoding */
predictor_decode_mono(ctx, count); predictor_decode_mono(ctx, count);


/* Pseudo-stereo - just copy left channel to right channel */ /* Pseudo-stereo - just copy left channel to right channel */
if (ctx->channels == 2) { if (ctx->channels == 2) {
memcpy(decoded1, decoded0, count * sizeof(*decoded1));
memcpy(ctx->decoded[1], ctx->decoded[0], count * sizeof(*ctx->decoded[1]));
} }
} }


static void ape_unpack_stereo(APEContext *ctx, int count) static void ape_unpack_stereo(APEContext *ctx, int count)
{ {
int32_t left, right; int32_t left, right;
int32_t *decoded0 = ctx->decoded0;
int32_t *decoded1 = ctx->decoded1;
int32_t *decoded0 = ctx->decoded[0];
int32_t *decoded1 = ctx->decoded[1];


if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) { if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
/* We are pure silence, so we're done. */ /* We are pure silence, so we're done. */
@@ -883,9 +879,6 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
} }
s->samples = nblocks; s->samples = nblocks;


memset(s->decoded0, 0, sizeof(s->decoded0));
memset(s->decoded1, 0, sizeof(s->decoded1));

/* Initialize the frame decoder */ /* Initialize the frame decoder */
if (init_frame_decoder(s) < 0) { if (init_frame_decoder(s) < 0) {
av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n"); av_log(avctx, AV_LOG_ERROR, "Error reading frame header\n");
@@ -900,7 +893,16 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
return avpkt->size; return avpkt->size;
} }


blockstodecode = FFMIN(BLOCKS_PER_LOOP, s->samples);
blockstodecode = FFMIN(s->blocks_per_loop, s->samples);

/* reallocate decoded sample buffer if needed */
av_fast_malloc(&s->decoded_buffer, &s->decoded_size,
2 * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer));
if (!s->decoded_buffer)
return AVERROR(ENOMEM);
memset(s->decoded_buffer, 0, s->decoded_size);
s->decoded[0] = s->decoded_buffer;
s->decoded[1] = s->decoded_buffer + FFALIGN(blockstodecode, 8);


/* get output buffer */ /* get output buffer */
s->frame.nb_samples = blockstodecode; s->frame.nb_samples = blockstodecode;
@@ -927,25 +929,25 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
case 8: case 8:
sample8 = (uint8_t *)s->frame.data[0]; sample8 = (uint8_t *)s->frame.data[0];
for (i = 0; i < blockstodecode; i++) { for (i = 0; i < blockstodecode; i++) {
*sample8++ = (s->decoded0[i] + 0x80) & 0xff;
*sample8++ = (s->decoded[0][i] + 0x80) & 0xff;
if (s->channels == 2) if (s->channels == 2)
*sample8++ = (s->decoded1[i] + 0x80) & 0xff;
*sample8++ = (s->decoded[1][i] + 0x80) & 0xff;
} }
break; break;
case 16: case 16:
sample16 = (int16_t *)s->frame.data[0]; sample16 = (int16_t *)s->frame.data[0];
for (i = 0; i < blockstodecode; i++) { for (i = 0; i < blockstodecode; i++) {
*sample16++ = s->decoded0[i];
*sample16++ = s->decoded[0][i];
if (s->channels == 2) if (s->channels == 2)
*sample16++ = s->decoded1[i];
*sample16++ = s->decoded[1][i];
} }
break; break;
case 24: case 24:
sample24 = (int32_t *)s->frame.data[0]; sample24 = (int32_t *)s->frame.data[0];
for (i = 0; i < blockstodecode; i++) { for (i = 0; i < blockstodecode; i++) {
*sample24++ = s->decoded0[i] << 8;
*sample24++ = s->decoded[0][i] << 8;
if (s->channels == 2) if (s->channels == 2)
*sample24++ = s->decoded1[i] << 8;
*sample24++ = s->decoded[1][i] << 8;
} }
break; break;
} }
@@ -964,6 +966,21 @@ static void ape_flush(AVCodecContext *avctx)
s->samples= 0; s->samples= 0;
} }


#define OFFSET(x) offsetof(APEContext, x)
#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
static const AVOption options[] = {
{ "max_samples", "maximum number of samples decoded per call", OFFSET(blocks_per_loop), AV_OPT_TYPE_INT, { 4608 }, 1, INT_MAX, PAR, "max_samples" },
{ "all", "no maximum. decode all samples for each packet at once", 0, AV_OPT_TYPE_CONST, { INT_MAX }, INT_MIN, INT_MAX, PAR, "max_samples" },
{ NULL},
};

static const AVClass ape_decoder_class = {
.class_name = "APE decoder",
.item_name = av_default_item_name,
.option = options,
.version = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_ape_decoder = { AVCodec ff_ape_decoder = {
.name = "ape", .name = "ape",
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
@@ -975,4 +992,5 @@ AVCodec ff_ape_decoder = {
.capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY | CODEC_CAP_DR1, .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY | CODEC_CAP_DR1,
.flush = ape_flush, .flush = ape_flush,
.long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"), .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
.priv_class = &ape_decoder_class,
}; };

+ 112
- 0
libavcodec/bytestream.h View File

@@ -1,6 +1,7 @@
/* /*
* Bytestream functions * Bytestream functions
* copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr> * copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr>
* Copyright (c) 2012 Aneesh Dogra (lionaneesh) <lionaneesh@gmail.com>
* *
* This file is part of FFmpeg. * This file is part of FFmpeg.
* *
@@ -30,6 +31,11 @@ typedef struct {
const uint8_t *buffer, *buffer_end, *buffer_start; const uint8_t *buffer, *buffer_end, *buffer_start;
} GetByteContext; } GetByteContext;


typedef struct {
uint8_t *buffer, *buffer_end, *buffer_start;
int eof;
} PutByteContext;

#define DEF_T(type, name, bytes, read, write) \ #define DEF_T(type, name, bytes, read, write) \
static av_always_inline type bytestream_get_ ## name(const uint8_t **b){\ static av_always_inline type bytestream_get_ ## name(const uint8_t **b){\
(*b) += bytes;\ (*b) += bytes;\
@@ -39,6 +45,17 @@ static av_always_inline void bytestream_put_ ##name(uint8_t **b, const type valu
write(*b, value);\ write(*b, value);\
(*b) += bytes;\ (*b) += bytes;\
}\ }\
static av_always_inline void bytestream2_put_ ## name ## u(PutByteContext *p, const type value)\
{\
bytestream_put_ ## name(&p->buffer, value);\
}\
static av_always_inline void bytestream2_put_ ## name(PutByteContext *p, const type value){\
if (!p->eof && (p->buffer_end - p->buffer >= bytes)) {\
write(p->buffer, value);\
p->buffer += bytes;\
} else\
p->eof = 1;\
}\
static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g)\ static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g)\
{\ {\
return bytestream_get_ ## name(&g->buffer);\ return bytestream_get_ ## name(&g->buffer);\
@@ -119,22 +136,53 @@ static av_always_inline void bytestream2_init(GetByteContext *g,
g->buffer_end = buf + buf_size; g->buffer_end = buf + buf_size;
} }


static av_always_inline void bytestream2_init_writer(PutByteContext *p,
uint8_t *buf, int buf_size)
{
p->buffer = buf;
p->buffer_start = buf;
p->buffer_end = buf + buf_size;
p->eof = 0;
}

static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g) static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
{ {
return g->buffer_end - g->buffer; return g->buffer_end - g->buffer;
} }


static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
{
return p->buffer_end - p->buffer;
}

static av_always_inline void bytestream2_skip(GetByteContext *g, static av_always_inline void bytestream2_skip(GetByteContext *g,
unsigned int size) unsigned int size)
{ {
g->buffer += FFMIN(g->buffer_end - g->buffer, size); g->buffer += FFMIN(g->buffer_end - g->buffer, size);
} }


static av_always_inline void bytestream2_skip_p(PutByteContext *p,
unsigned int size)
{
int size2;
if (p->eof)
return;
size2 = FFMIN(p->buffer_end - p->buffer, size);
if (size2 != size)
p->eof = 1;
p->buffer += size2;
}

static av_always_inline int bytestream2_tell(GetByteContext *g) static av_always_inline int bytestream2_tell(GetByteContext *g)
{ {
return (int)(g->buffer - g->buffer_start); return (int)(g->buffer - g->buffer_start);
} }


static av_always_inline int bytestream2_tell_p(PutByteContext *p)
{
return (int)(p->buffer - p->buffer_start);
}

static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, static av_always_inline int bytestream2_seek(GetByteContext *g, int offset,
int whence) int whence)
{ {
@@ -158,6 +206,36 @@ static av_always_inline int bytestream2_seek(GetByteContext *g, int offset,
return bytestream2_tell(g); return bytestream2_tell(g);
} }


static av_always_inline int bytestream2_seek_p(PutByteContext *p, int offset,
int whence)
{
p->eof = 0;
switch (whence) {
case SEEK_CUR:
if (p->buffer_end - p->buffer < offset)
p->eof = 1;
offset = av_clip(offset, -(p->buffer - p->buffer_start),
p->buffer_end - p->buffer);
p->buffer += offset;
break;
case SEEK_END:
if (offset > 0)
p->eof = 1;
offset = av_clip(offset, -(p->buffer_end - p->buffer_start), 0);
p->buffer = p->buffer_end + offset;
break;
case SEEK_SET:
if (p->buffer_end - p->buffer_start < offset)
p->eof = 1;
offset = av_clip(offset, 0, p->buffer_end - p->buffer_start);
p->buffer = p->buffer_start + offset;
break;
default:
return AVERROR(EINVAL);
}
return bytestream2_tell_p(p);
}

static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
uint8_t *dst, uint8_t *dst,
unsigned int size) unsigned int size)
@@ -168,6 +246,40 @@ static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
return size2; return size2;
} }


static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p,
const uint8_t *src,
unsigned int size)
{
int size2;
if (p->eof)
return 0;
size2 = FFMIN(p->buffer_end - p->buffer, size);
if (size2 != size)
p->eof = 1;
memcpy(p->buffer, src, size2);
p->buffer += size2;
return size2;
}

static av_always_inline void bytestream2_set_buffer(PutByteContext *p,
const uint8_t c,
unsigned int size)
{
int size2;
if (p->eof)
return;
size2 = FFMIN(p->buffer_end - p->buffer, size);
if (size2 != size)
p->eof = 1;
memset(p->buffer, c, size2);
p->buffer += size2;
}

static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
{
return p->eof;
}

static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size) static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
{ {
memcpy(dst, *b, size); memcpy(dst, *b, size);


+ 32
- 46
libavcodec/vp8.c View File

@@ -1561,18 +1561,6 @@ static void release_queued_segmaps(VP8Context *s, int is_close)
s->maps_are_invalid = 0; s->maps_are_invalid = 0;
} }


/**
* Sets things up for skipping the current frame.
* In particular, removes it from the reference buffers.
*/
static void skipframe_clear(VP8Context *s)
{
s->invisible = 1;
s->next_framep[VP56_FRAME_CURRENT] = NULL;
if (s->update_last)
s->next_framep[VP56_FRAME_PREVIOUS] = NULL;
}

static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size, static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt) AVPacket *avpkt)
{ {
@@ -1584,7 +1572,7 @@ static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
release_queued_segmaps(s, 0); release_queued_segmaps(s, 0);


if ((ret = decode_frame_header(s, avpkt->data, avpkt->size)) < 0) if ((ret = decode_frame_header(s, avpkt->data, avpkt->size)) < 0)
return ret;
goto err;


prev_frame = s->framep[VP56_FRAME_CURRENT]; prev_frame = s->framep[VP56_FRAME_CURRENT];


@@ -1594,6 +1582,11 @@ static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
skip_thresh = !referenced ? AVDISCARD_NONREF : skip_thresh = !referenced ? AVDISCARD_NONREF :
!s->keyframe ? AVDISCARD_NONKEY : AVDISCARD_ALL; !s->keyframe ? AVDISCARD_NONKEY : AVDISCARD_ALL;


if (avctx->skip_frame >= skip_thresh) {
s->invisible = 1;
memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
goto skip_decode;
}
s->deblock_filter = s->filter.level && avctx->skip_loop_filter < skip_thresh; s->deblock_filter = s->filter.level && avctx->skip_loop_filter < skip_thresh;


// release no longer referenced frames // release no longer referenced frames
@@ -1618,6 +1611,27 @@ static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
av_log(avctx, AV_LOG_FATAL, "Ran out of free frames!\n"); av_log(avctx, AV_LOG_FATAL, "Ran out of free frames!\n");
abort(); abort();
} }
if (curframe->data[0])
vp8_release_frame(s, curframe, 1, 0);

// Given that arithmetic probabilities are updated every frame, it's quite likely
// that the values we have on a random interframe are complete junk if we didn't
// start decode on a keyframe. So just don't display anything rather than junk.
if (!s->keyframe && (!s->framep[VP56_FRAME_PREVIOUS] ||
!s->framep[VP56_FRAME_GOLDEN] ||
!s->framep[VP56_FRAME_GOLDEN2])) {
av_log(avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
ret = AVERROR_INVALIDDATA;
goto err;
}

curframe->key_frame = s->keyframe;
curframe->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
curframe->reference = referenced ? 3 : 0;
if ((ret = vp8_alloc_frame(s, curframe))) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed!\n");
goto err;
}


// check if golden and altref are swapped // check if golden and altref are swapped
if (s->update_altref != VP56_FRAME_NONE) { if (s->update_altref != VP56_FRAME_NONE) {
@@ -1637,36 +1651,6 @@ static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
} }
s->next_framep[VP56_FRAME_CURRENT] = curframe; s->next_framep[VP56_FRAME_CURRENT] = curframe;


if (avctx->skip_frame >= skip_thresh) {
skipframe_clear(s);
ret = avpkt->size;
goto skip_decode;
}

// Given that arithmetic probabilities are updated every frame, it's quite likely
// that the values we have on a random interframe are complete junk if we didn't
// start decode on a keyframe. So just don't display anything rather than junk.
if (!s->keyframe && (!s->framep[VP56_FRAME_PREVIOUS] ||
!s->framep[VP56_FRAME_GOLDEN] ||
!s->framep[VP56_FRAME_GOLDEN2])) {
av_log(avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
skipframe_clear(s);
ret = AVERROR_INVALIDDATA;
goto skip_decode;
}

if (curframe->data[0])
vp8_release_frame(s, curframe, 1, 0);

curframe->key_frame = s->keyframe;
curframe->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
curframe->reference = referenced ? 3 : 0;
if ((ret = vp8_alloc_frame(s, curframe))) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed!\n");
skipframe_clear(s);
goto skip_decode;
}

ff_thread_finish_setup(avctx); ff_thread_finish_setup(avctx);


s->linesize = curframe->linesize[0]; s->linesize = curframe->linesize[0];
@@ -1778,20 +1762,22 @@ static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
} }


ff_thread_report_progress(curframe, INT_MAX, 0); ff_thread_report_progress(curframe, INT_MAX, 0);
ret = avpkt->size;
memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);

skip_decode: skip_decode:
// if future frames don't use the updated probabilities, // if future frames don't use the updated probabilities,
// reset them to the values we saved // reset them to the values we saved
if (!s->update_probabilities) if (!s->update_probabilities)
s->prob[0] = s->prob[1]; s->prob[0] = s->prob[1];


memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);

if (!s->invisible) { if (!s->invisible) {
*(AVFrame*)data = *curframe; *(AVFrame*)data = *curframe;
*data_size = sizeof(AVFrame); *data_size = sizeof(AVFrame);
} }


return avpkt->size;
err:
memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
return ret; return ret;
} }




+ 1
- 1
libavcodec/x86/h264_idct_10bit.asm View File

@@ -315,7 +315,7 @@ IDCT_ADD16INTRA_10 avx
; h264_idct_add8(pixel **dst, const int *block_offset, dctcoef *block, int stride, const uint8_t nnzc[6*8]) ; h264_idct_add8(pixel **dst, const int *block_offset, dctcoef *block, int stride, const uint8_t nnzc[6*8])
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
%macro IDCT_ADD8 1 %macro IDCT_ADD8 1
cglobal h264_idct_add8_10_%1,5,7
cglobal h264_idct_add8_10_%1,5,7,7
%if ARCH_X86_64 %if ARCH_X86_64
mov r10, r0 mov r10, r0
%endif %endif


+ 2
- 2
libswscale/Makefile View File

@@ -5,8 +5,8 @@ FFLIBS = avutil


HEADERS = swscale.h HEADERS = swscale.h


OBJS = options.o rgb2rgb.o swscale.o utils.o yuv2rgb.o \
swscale_unscaled.o
OBJS = input.o options.o output.o rgb2rgb.o swscale.o \
swscale_unscaled.o utils.o yuv2rgb.o


OBJS-$(ARCH_BFIN) += bfin/internal_bfin.o \ OBJS-$(ARCH_BFIN) += bfin/internal_bfin.o \
bfin/swscale_bfin.o \ bfin/swscale_bfin.o \


+ 799
- 0
libswscale/input.c View File

@@ -0,0 +1,799 @@
/*
* Copyright (C) 2001-2012 Michael Niedermayer <michaelni@gmx.at>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include <assert.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "libavutil/avutil.h"
#include "libavutil/bswap.h"
#include "libavutil/cpu.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
#include "libavutil/pixdesc.h"
#include "config.h"
#include "rgb2rgb.h"
#include "swscale.h"
#include "swscale_internal.h"

#define RGB2YUV_SHIFT 15
#define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))
#define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))
#define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
#define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))
#define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))
#define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))
#define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))
#define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
#define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))

#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))

#define r ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? b_r : r_b)
#define b ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? r_b : b_r)

static av_always_inline void
rgb48ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
enum PixelFormat origin)
{
int i;
for (i = 0; i < width; i++) {
unsigned int r_b = input_pixel(&src[i*3+0]);
unsigned int g = input_pixel(&src[i*3+1]);
unsigned int b_r = input_pixel(&src[i*3+2]);

dst[i] = (RY*r + GY*g + BY*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
}
}

static av_always_inline void
rgb48ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
const uint16_t *src1, const uint16_t *src2,
int width, enum PixelFormat origin)
{
int i;
assert(src1==src2);
for (i = 0; i < width; i++) {
int r_b = input_pixel(&src1[i*3+0]);
int g = input_pixel(&src1[i*3+1]);
int b_r = input_pixel(&src1[i*3+2]);

dstU[i] = (RU*r + GU*g + BU*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
dstV[i] = (RV*r + GV*g + BV*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
}
}

static av_always_inline void
rgb48ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
const uint16_t *src1, const uint16_t *src2,
int width, enum PixelFormat origin)
{
int i;
assert(src1==src2);
for (i = 0; i < width; i++) {
int r_b = (input_pixel(&src1[6 * i + 0]) + input_pixel(&src1[6 * i + 3]) + 1) >> 1;
int g = (input_pixel(&src1[6 * i + 1]) + input_pixel(&src1[6 * i + 4]) + 1) >> 1;
int b_r = (input_pixel(&src1[6 * i + 2]) + input_pixel(&src1[6 * i + 5]) + 1) >> 1;

dstU[i]= (RU*r + GU*g + BU*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
dstV[i]= (RV*r + GV*g + BV*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
}
}

#undef r
#undef b
#undef input_pixel

#define rgb48funcs(pattern, BE_LE, origin) \
static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, const uint8_t *unused1,\
int width, uint32_t *unused) \
{ \
const uint16_t *src = (const uint16_t *) _src; \
uint16_t *dst = (uint16_t *) _dst; \
rgb48ToY_c_template(dst, src, width, origin); \
} \
\
static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
int width, uint32_t *unused) \
{ \
const uint16_t *src1 = (const uint16_t *) _src1, \
*src2 = (const uint16_t *) _src2; \
uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin); \
} \
\
static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
int width, uint32_t *unused) \
{ \
const uint16_t *src1 = (const uint16_t *) _src1, \
*src2 = (const uint16_t *) _src2; \
uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin); \
}

rgb48funcs(rgb, LE, PIX_FMT_RGB48LE)
rgb48funcs(rgb, BE, PIX_FMT_RGB48BE)
rgb48funcs(bgr, LE, PIX_FMT_BGR48LE)
rgb48funcs(bgr, BE, PIX_FMT_BGR48BE)

#define input_pixel(i) ((origin == PIX_FMT_RGBA || origin == PIX_FMT_BGRA || \
origin == PIX_FMT_ARGB || origin == PIX_FMT_ABGR) ? AV_RN32A(&src[(i)*4]) : \
(isBE(origin) ? AV_RB16(&src[(i)*2]) : AV_RL16(&src[(i)*2])))

static av_always_inline void
rgb16_32ToY_c_template(int16_t *dst, const uint8_t *src,
int width, enum PixelFormat origin,
int shr, int shg, int shb, int shp,
int maskr, int maskg, int maskb,
int rsh, int gsh, int bsh, int S)
{
const int ry = RY << rsh, gy = GY << gsh, by = BY << bsh;
const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
int i;

for (i = 0; i < width; i++) {
int px = input_pixel(i) >> shp;
int b = (px & maskb) >> shb;
int g = (px & maskg) >> shg;
int r = (px & maskr) >> shr;

dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
}
}

static av_always_inline void
rgb16_32ToUV_c_template(int16_t *dstU, int16_t *dstV,
const uint8_t *src, int width,
enum PixelFormat origin,
int shr, int shg, int shb, int shp,
int maskr, int maskg, int maskb,
int rsh, int gsh, int bsh, int S)
{
const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh,
rv = RV << rsh, gv = GV << gsh, bv = BV << bsh;
const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
int i;

for (i = 0; i < width; i++) {
int px = input_pixel(i) >> shp;
int b = (px & maskb) >> shb;
int g = (px & maskg) >> shg;
int r = (px & maskr) >> shr;

dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
}
}

static av_always_inline void
rgb16_32ToUV_half_c_template(int16_t *dstU, int16_t *dstV,
const uint8_t *src, int width,
enum PixelFormat origin,
int shr, int shg, int shb, int shp,
int maskr, int maskg, int maskb,
int rsh, int gsh, int bsh, int S)
{
const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh,
rv = RV << rsh, gv = GV << gsh, bv = BV << bsh,
maskgx = ~(maskr | maskb);
const unsigned rnd = (256U<<(S)) + (1<<(S-6));
int i;

maskr |= maskr << 1; maskb |= maskb << 1; maskg |= maskg << 1;
for (i = 0; i < width; i++) {
int px0 = input_pixel(2 * i + 0) >> shp;
int px1 = input_pixel(2 * i + 1) >> shp;
int b, r, g = (px0 & maskgx) + (px1 & maskgx);
int rb = px0 + px1 - g;

b = (rb & maskb) >> shb;
if (shp || origin == PIX_FMT_BGR565LE || origin == PIX_FMT_BGR565BE ||
origin == PIX_FMT_RGB565LE || origin == PIX_FMT_RGB565BE) {
g >>= shg;
} else {
g = (g & maskg) >> shg;
}
r = (rb & maskr) >> shr;

dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
}
}

#undef input_pixel

#define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr, \
maskg, maskb, rsh, gsh, bsh, S) \
static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, \
int width, uint32_t *unused) \
{ \
rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, \
shr, shg, shb, shp, \
maskr, maskg, maskb, rsh, gsh, bsh, S); \
} \
\
static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy, \
int width, uint32_t *unused) \
{ \
rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
shr, shg, shb, shp, \
maskr, maskg, maskb, rsh, gsh, bsh, S); \
} \
\
static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \
const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy, \
int width, uint32_t *unused) \
{ \
rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
shr, shg, shb, shp, \
maskr, maskg, maskb, rsh, gsh, bsh, S); \
}

rgb16_32_wrapper(PIX_FMT_BGR32, bgr32, 16, 0, 0, 0, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR32_1, bgr321, 16, 0, 0, 8, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_RGB32, rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_BGR444LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT+4)
rgb16_32_wrapper(PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_RGB444LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT+4)
rgb16_32_wrapper(PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_BGR444BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT+4)
rgb16_32_wrapper(PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8)
rgb16_32_wrapper(PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7)
rgb16_32_wrapper(PIX_FMT_RGB444BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT+4)

static void gbr24pToUV_half_c(uint16_t *dstU, uint16_t *dstV,
const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
int width, enum PixelFormat origin)
{
int i;
for (i=0; i<width; i++) {
unsigned int g = gsrc[2*i] + gsrc[2*i+1];
unsigned int b = bsrc[2*i] + bsrc[2*i+1];
unsigned int r = rsrc[2*i] + rsrc[2*i+1];

dstU[i] = (RU*r + GU*g + BU*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
dstV[i] = (RV*r + GV*g + BV*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
}
}

static void abgrToA_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
dst[i]= src[4*i]<<6;
}
}

static void rgbaToA_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
dst[i]= src[4*i+3]<<6;
}
}

static void palToA_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
{
int i;
for (i=0; i<width; i++) {
int d= src[i];

dst[i]= (pal[d] >> 24)<<6;
}
}

static void palToY_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, long width, uint32_t *pal)
{
int i;
for (i=0; i<width; i++) {
int d= src[i];

dst[i]= (pal[d] & 0xFF)<<6;
}
}

static void palToUV_c(uint16_t *dstU, int16_t *dstV,
const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *pal)
{
int i;
assert(src1 == src2);
for (i=0; i<width; i++) {
int p= pal[src1[i]];

dstU[i]= (uint8_t)(p>> 8)<<6;
dstV[i]= (uint8_t)(p>>16)<<6;
}
}

static void monowhite2Y_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
{
int i, j;
for (i=0; i<width/8; i++) {
int d= ~src[i];
for(j=0; j<8; j++)
dst[8*i+j]= ((d>>(7-j))&1)*16383;
}
if(width&7){
int d= ~src[i];
for(j=0; j<(width&7); j++)
dst[8*i+j]= ((d>>(7-j))&1)*16383;
}
}

static void monoblack2Y_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
{
int i, j;
for (i=0; i<width/8; i++) {
int d= src[i];
for(j=0; j<8; j++)
dst[8*i+j]= ((d>>(7-j))&1)*16383;
}
if(width&7){
int d= src[i];
for(j=0; j<(width&7); j++)
dst[8*i+j]= ((d>>(7-j))&1)*16383;
}
}

static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
uint32_t *unused)
{
int i;
for (i=0; i<width; i++)
dst[i]= src[2*i];
}

static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
const uint8_t *src2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
dstU[i]= src1[4*i + 1];
dstV[i]= src1[4*i + 3];
}
assert(src1 == src2);
}

static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
{
int i;
const uint16_t *src = (const uint16_t *) _src;
uint16_t *dst = (uint16_t *) _dst;
for (i=0; i<width; i++) {
dst[i] = av_bswap16(src[i]);
}
}

static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
const uint8_t *_src2, int width, uint32_t *unused)
{
int i;
const uint16_t *src1 = (const uint16_t *) _src1,
*src2 = (const uint16_t *) _src2;
uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV;
for (i=0; i<width; i++) {
dstU[i] = av_bswap16(src1[i]);
dstV[i] = av_bswap16(src2[i]);
}
}

/* This is almost identical to the previous, end exists only because
* yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */
static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
uint32_t *unused)
{
int i;
for (i=0; i<width; i++)
dst[i]= src[2*i+1];
}

static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
const uint8_t *src2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
dstU[i]= src1[4*i + 0];
dstV[i]= src1[4*i + 2];
}
assert(src1 == src2);
}

static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
const uint8_t *src, int width)
{
int i;
for (i = 0; i < width; i++) {
dst1[i] = src[2*i+0];
dst2[i] = src[2*i+1];
}
}

static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *unused)
{
nvXXtoUV_c(dstU, dstV, src1, width);
}

static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
int width, uint32_t *unused)
{
nvXXtoUV_c(dstV, dstU, src1, width);
}

#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))

static void bgr24ToY_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
int b= src[i*3+0];
int g= src[i*3+1];
int r= src[i*3+2];

dst[i]= ((RY*r + GY*g + BY*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
}
}

static void bgr24ToUV_c(int16_t *dstU, int16_t *dstV, const uint8_t *unused0, const uint8_t *src1,
const uint8_t *src2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
int b= src1[3*i + 0];
int g= src1[3*i + 1];
int r= src1[3*i + 2];

dstU[i]= (RU*r + GU*g + BU*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
dstV[i]= (RV*r + GV*g + BV*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
}
assert(src1 == src2);
}

static void bgr24ToUV_half_c(int16_t *dstU, int16_t *dstV, const uint8_t *unused0, const uint8_t *src1,
const uint8_t *src2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
int b= src1[6*i + 0] + src1[6*i + 3];
int g= src1[6*i + 1] + src1[6*i + 4];
int r= src1[6*i + 2] + src1[6*i + 5];

dstU[i]= (RU*r + GU*g + BU*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
dstV[i]= (RV*r + GV*g + BV*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
}
assert(src1 == src2);
}

static void rgb24ToY_c(int16_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
int r= src[i*3+0];
int g= src[i*3+1];
int b= src[i*3+2];

dst[i]= ((RY*r + GY*g + BY*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
}
}

static void rgb24ToUV_c(int16_t *dstU, int16_t *dstV, const uint8_t *unused0, const uint8_t *src1,
const uint8_t *src2, int width, uint32_t *unused)
{
int i;
assert(src1==src2);
for (i=0; i<width; i++) {
int r= src1[3*i + 0];
int g= src1[3*i + 1];
int b= src1[3*i + 2];

dstU[i]= (RU*r + GU*g + BU*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
dstV[i]= (RV*r + GV*g + BV*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
}
}

static void rgb24ToUV_half_c(int16_t *dstU, int16_t *dstV, const uint8_t *unused0, const uint8_t *src1,
const uint8_t *src2, int width, uint32_t *unused)
{
int i;
assert(src1==src2);
for (i=0; i<width; i++) {
int r= src1[6*i + 0] + src1[6*i + 3];
int g= src1[6*i + 1] + src1[6*i + 4];
int b= src1[6*i + 2] + src1[6*i + 5];

dstU[i]= (RU*r + GU*g + BU*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
dstV[i]= (RV*r + GV*g + BV*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
}
}

static void planar_rgb_to_y(uint16_t *dst, const uint8_t *src[4], int width)
{
int i;
for (i = 0; i < width; i++) {
int g = src[0][i];
int b = src[1][i];
int r = src[2][i];

dst[i] = (RY*r + GY*g + BY*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
}
}

static void planar_rgb16le_to_y(uint8_t *_dst, const uint8_t *_src[4], int width)
{
int i;
const uint16_t **src = (const uint16_t **) _src;
uint16_t *dst = (uint16_t *) _dst;
for (i = 0; i < width; i++) {
int g = AV_RL16(src[0] + i);
int b = AV_RL16(src[1] + i);
int r = AV_RL16(src[2] + i);

dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
}
}

static void planar_rgb16be_to_y(uint8_t *_dst, const uint8_t *_src[4], int width)
{
int i;
const uint16_t **src = (const uint16_t **) _src;
uint16_t *dst = (uint16_t *) _dst;
for (i = 0; i < width; i++) {
int g = AV_RB16(src[0] + i);
int b = AV_RB16(src[1] + i);
int r = AV_RB16(src[2] + i);

dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
}
}

static void planar_rgb_to_uv(uint16_t *dstU, uint16_t *dstV, const uint8_t *src[4], int width)
{
int i;
for (i = 0; i < width; i++) {
int g = src[0][i];
int b = src[1][i];
int r = src[2][i];

dstU[i] = (RU*r + GU*g + BU*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
dstV[i] = (RV*r + GV*g + BV*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
}
}

static void planar_rgb16le_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src[4], int width)
{
int i;
const uint16_t **src = (const uint16_t **) _src;
uint16_t *dstU = (uint16_t *) _dstU;
uint16_t *dstV = (uint16_t *) _dstV;
for (i = 0; i < width; i++) {
int g = AV_RL16(src[0] + i);
int b = AV_RL16(src[1] + i);
int r = AV_RL16(src[2] + i);

dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
}
}

static void planar_rgb16be_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src[4], int width)
{
int i;
const uint16_t **src = (const uint16_t **) _src;
uint16_t *dstU = (uint16_t *) _dstU;
uint16_t *dstV = (uint16_t *) _dstV;
for (i = 0; i < width; i++) {
int g = AV_RB16(src[0] + i);
int b = AV_RB16(src[1] + i);
int r = AV_RB16(src[2] + i);

dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
}
}

av_cold void ff_sws_init_input_funcs(SwsContext *c)
{
enum PixelFormat srcFormat = c->srcFormat;

c->chrToYV12 = NULL;
switch(srcFormat) {
case PIX_FMT_YUYV422 : c->chrToYV12 = yuy2ToUV_c; break;
case PIX_FMT_UYVY422 : c->chrToYV12 = uyvyToUV_c; break;
case PIX_FMT_NV12 : c->chrToYV12 = nv12ToUV_c; break;
case PIX_FMT_NV21 : c->chrToYV12 = nv21ToUV_c; break;
case PIX_FMT_RGB8 :
case PIX_FMT_BGR8 :
case PIX_FMT_PAL8 :
case PIX_FMT_BGR4_BYTE:
case PIX_FMT_RGB4_BYTE: c->chrToYV12 = palToUV_c; break;
case PIX_FMT_GBRP9LE:
case PIX_FMT_GBRP10LE:
case PIX_FMT_GBRP16LE: c->readChrPlanar = planar_rgb16le_to_uv; break;
case PIX_FMT_GBRP9BE:
case PIX_FMT_GBRP10BE:
case PIX_FMT_GBRP16BE: c->readChrPlanar = planar_rgb16be_to_uv; break;
case PIX_FMT_GBRP: c->readChrPlanar = planar_rgb_to_uv; break;
#if HAVE_BIGENDIAN
case PIX_FMT_YUV444P9LE:
case PIX_FMT_YUV422P9LE:
case PIX_FMT_YUV420P9LE:
case PIX_FMT_YUV422P10LE:
case PIX_FMT_YUV444P10LE:
case PIX_FMT_YUV420P10LE:
case PIX_FMT_YUV420P16LE:
case PIX_FMT_YUV422P16LE:
case PIX_FMT_YUV444P16LE: c->chrToYV12 = bswap16UV_c; break;
#else
case PIX_FMT_YUV444P9BE:
case PIX_FMT_YUV422P9BE:
case PIX_FMT_YUV420P9BE:
case PIX_FMT_YUV444P10BE:
case PIX_FMT_YUV422P10BE:
case PIX_FMT_YUV420P10BE:
case PIX_FMT_YUV420P16BE:
case PIX_FMT_YUV422P16BE:
case PIX_FMT_YUV444P16BE: c->chrToYV12 = bswap16UV_c; break;
#endif
}
if (c->chrSrcHSubSample) {
switch(srcFormat) {
case PIX_FMT_RGB48BE : c->chrToYV12 = rgb48BEToUV_half_c; break;
case PIX_FMT_RGB48LE : c->chrToYV12 = rgb48LEToUV_half_c; break;
case PIX_FMT_BGR48BE : c->chrToYV12 = bgr48BEToUV_half_c; break;
case PIX_FMT_BGR48LE : c->chrToYV12 = bgr48LEToUV_half_c; break;
case PIX_FMT_RGB32 : c->chrToYV12 = bgr32ToUV_half_c; break;
case PIX_FMT_RGB32_1 : c->chrToYV12 = bgr321ToUV_half_c; break;
case PIX_FMT_BGR24 : c->chrToYV12 = bgr24ToUV_half_c; break;
case PIX_FMT_BGR565LE: c->chrToYV12 = bgr16leToUV_half_c; break;
case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_half_c; break;
case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_half_c; break;
case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_half_c; break;
case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_half_c; break;
case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_half_c; break;
case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_half_c; break;
case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_half_c; break;
case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_half_c; break;
case PIX_FMT_RGB565LE: c->chrToYV12 = rgb16leToUV_half_c; break;
case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_half_c; break;
case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_half_c; break;
case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_half_c; break;
case PIX_FMT_GBR24P : c->chrToYV12 = gbr24pToUV_half_c; break;
case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_half_c; break;
case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_half_c; break;
}
} else {
switch(srcFormat) {
case PIX_FMT_RGB48BE : c->chrToYV12 = rgb48BEToUV_c; break;
case PIX_FMT_RGB48LE : c->chrToYV12 = rgb48LEToUV_c; break;
case PIX_FMT_BGR48BE : c->chrToYV12 = bgr48BEToUV_c; break;
case PIX_FMT_BGR48LE : c->chrToYV12 = bgr48LEToUV_c; break;
case PIX_FMT_RGB32 : c->chrToYV12 = bgr32ToUV_c; break;
case PIX_FMT_RGB32_1 : c->chrToYV12 = bgr321ToUV_c; break;
case PIX_FMT_BGR24 : c->chrToYV12 = bgr24ToUV_c; break;
case PIX_FMT_BGR565LE: c->chrToYV12 = bgr16leToUV_c; break;
case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_c; break;
case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_c; break;
case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_c; break;
case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_c; break;
case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_c; break;
case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_c; break;
case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_c; break;
case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_c; break;
case PIX_FMT_RGB565LE: c->chrToYV12 = rgb16leToUV_c; break;
case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_c; break;
case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_c; break;
case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_c; break;
case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_c; break;
case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_c; break;
}
}

c->lumToYV12 = NULL;
c->alpToYV12 = NULL;
switch (srcFormat) {
case PIX_FMT_GBRP9LE:
case PIX_FMT_GBRP10LE:
case PIX_FMT_GBRP16LE: c->readLumPlanar = planar_rgb16le_to_y; break;
case PIX_FMT_GBRP9BE:
case PIX_FMT_GBRP10BE:
case PIX_FMT_GBRP16BE: c->readLumPlanar = planar_rgb16be_to_y; break;
case PIX_FMT_GBRP: c->readLumPlanar = planar_rgb_to_y; break;
#if HAVE_BIGENDIAN
case PIX_FMT_YUV444P9LE:
case PIX_FMT_YUV422P9LE:
case PIX_FMT_YUV420P9LE:
case PIX_FMT_YUV444P10LE:
case PIX_FMT_YUV422P10LE:
case PIX_FMT_YUV420P10LE:
case PIX_FMT_YUV420P16LE:
case PIX_FMT_YUV422P16LE:
case PIX_FMT_YUV444P16LE:
case PIX_FMT_GRAY16LE: c->lumToYV12 = bswap16Y_c; break;
#else
case PIX_FMT_YUV444P9BE:
case PIX_FMT_YUV422P9BE:
case PIX_FMT_YUV420P9BE:
case PIX_FMT_YUV444P10BE:
case PIX_FMT_YUV422P10BE:
case PIX_FMT_YUV420P10BE:
case PIX_FMT_YUV420P16BE:
case PIX_FMT_YUV422P16BE:
case PIX_FMT_YUV444P16BE:
case PIX_FMT_GRAY16BE: c->lumToYV12 = bswap16Y_c; break;
#endif
case PIX_FMT_YUYV422 :
case PIX_FMT_Y400A : c->lumToYV12 = yuy2ToY_c; break;
case PIX_FMT_UYVY422 : c->lumToYV12 = uyvyToY_c; break;
case PIX_FMT_BGR24 : c->lumToYV12 = bgr24ToY_c; break;
case PIX_FMT_BGR565LE : c->lumToYV12 = bgr16leToY_c; break;
case PIX_FMT_BGR565BE : c->lumToYV12 = bgr16beToY_c; break;
case PIX_FMT_BGR555LE : c->lumToYV12 = bgr15leToY_c; break;
case PIX_FMT_BGR555BE : c->lumToYV12 = bgr15beToY_c; break;
case PIX_FMT_BGR444LE : c->lumToYV12 = bgr12leToY_c; break;
case PIX_FMT_BGR444BE : c->lumToYV12 = bgr12beToY_c; break;
case PIX_FMT_RGB24 : c->lumToYV12 = rgb24ToY_c; break;
case PIX_FMT_RGB565LE : c->lumToYV12 = rgb16leToY_c; break;
case PIX_FMT_RGB565BE : c->lumToYV12 = rgb16beToY_c; break;
case PIX_FMT_RGB555LE : c->lumToYV12 = rgb15leToY_c; break;
case PIX_FMT_RGB555BE : c->lumToYV12 = rgb15beToY_c; break;
case PIX_FMT_RGB444LE : c->lumToYV12 = rgb12leToY_c; break;
case PIX_FMT_RGB444BE : c->lumToYV12 = rgb12beToY_c; break;
case PIX_FMT_RGB8 :
case PIX_FMT_BGR8 :
case PIX_FMT_PAL8 :
case PIX_FMT_BGR4_BYTE:
case PIX_FMT_RGB4_BYTE: c->lumToYV12 = palToY_c; break;
case PIX_FMT_MONOBLACK: c->lumToYV12 = monoblack2Y_c; break;
case PIX_FMT_MONOWHITE: c->lumToYV12 = monowhite2Y_c; break;
case PIX_FMT_RGB32 : c->lumToYV12 = bgr32ToY_c; break;
case PIX_FMT_RGB32_1: c->lumToYV12 = bgr321ToY_c; break;
case PIX_FMT_BGR32 : c->lumToYV12 = rgb32ToY_c; break;
case PIX_FMT_BGR32_1: c->lumToYV12 = rgb321ToY_c; break;
case PIX_FMT_RGB48BE: c->lumToYV12 = rgb48BEToY_c; break;
case PIX_FMT_RGB48LE: c->lumToYV12 = rgb48LEToY_c; break;
case PIX_FMT_BGR48BE: c->lumToYV12 = bgr48BEToY_c; break;
case PIX_FMT_BGR48LE: c->lumToYV12 = bgr48LEToY_c; break;
}
if (c->alpPixBuf) {
switch (srcFormat) {
case PIX_FMT_BGRA:
case PIX_FMT_RGBA: c->alpToYV12 = rgbaToA_c; break;
case PIX_FMT_ABGR:
case PIX_FMT_ARGB: c->alpToYV12 = abgrToA_c; break;
case PIX_FMT_Y400A: c->alpToYV12 = uyvyToY_c; break;
case PIX_FMT_PAL8 : c->alpToYV12 = palToA_c; break;
}
}
}

+ 1523
- 0
libswscale/output.c
File diff suppressed because it is too large
View File


+ 125
- 126
libswscale/sparc/yuv2rgb_vis.c View File

@@ -25,149 +25,148 @@
#include "libswscale/swscale.h" #include "libswscale/swscale.h"
#include "libswscale/swscale_internal.h" #include "libswscale/swscale_internal.h"


#define YUV2RGB_INIT \
"wr %%g0, 0x10, %%gsr \n\t" \
"ldd [%5], %%f32 \n\t" \
"ldd [%5+8], %%f34 \n\t" \
"ldd [%5+16], %%f36 \n\t" \
"ldd [%5+24], %%f38 \n\t" \
"ldd [%5+32], %%f40 \n\t" \
"ldd [%5+40], %%f42 \n\t" \
"ldd [%5+48], %%f44 \n\t" \
"ldd [%5+56], %%f46 \n\t" \
"ldd [%5+64], %%f48 \n\t" \
"ldd [%5+72], %%f50 \n\t"

#define YUV2RGB_KERNEL \
/* ^^^^ f0=Y f3=u f5=v */ \
"fmul8x16 %%f3, %%f48, %%f6 \n\t" \
"fmul8x16 %%f19, %%f48, %%f22 \n\t" \
"fmul8x16 %%f5, %%f44, %%f8 \n\t" \
"fmul8x16 %%f21, %%f44, %%f24 \n\t" \
"fmul8x16 %%f0, %%f42, %%f0 \n\t" \
"fmul8x16 %%f16, %%f42, %%f16 \n\t" \
"fmul8x16 %%f3, %%f50, %%f2 \n\t" \
"fmul8x16 %%f19, %%f50, %%f18 \n\t" \
"fmul8x16 %%f5, %%f46, %%f4 \n\t" \
"fmul8x16 %%f21, %%f46, %%f20 \n\t" \
\
"fpsub16 %%f6, %%f34, %%f6 \n\t" /* 1 */ \
"fpsub16 %%f22, %%f34, %%f22 \n\t" /* 1 */ \
"fpsub16 %%f8, %%f38, %%f8 \n\t" /* 3 */ \
"fpsub16 %%f24, %%f38, %%f24 \n\t" /* 3 */ \
"fpsub16 %%f0, %%f32, %%f0 \n\t" /* 0 */ \
"fpsub16 %%f16, %%f32, %%f16 \n\t" /* 0 */ \
"fpsub16 %%f2, %%f36, %%f2 \n\t" /* 2 */ \
"fpsub16 %%f18, %%f36, %%f18 \n\t" /* 2 */ \
"fpsub16 %%f4, %%f40, %%f4 \n\t" /* 4 */ \
"fpsub16 %%f20, %%f40, %%f20 \n\t" /* 4 */ \
\
"fpadd16 %%f0, %%f8, %%f8 \n\t" /* Gt */ \
"fpadd16 %%f16, %%f24, %%f24 \n\t" /* Gt */ \
"fpadd16 %%f0, %%f4, %%f4 \n\t" /* R */ \
"fpadd16 %%f16, %%f20, %%f20 \n\t" /* R */ \
"fpadd16 %%f0, %%f6, %%f6 \n\t" /* B */ \
"fpadd16 %%f16, %%f22, %%f22 \n\t" /* B */ \
"fpadd16 %%f8, %%f2, %%f2 \n\t" /* G */ \
"fpadd16 %%f24, %%f18, %%f18 \n\t" /* G */ \
\
"fpack16 %%f4, %%f4 \n\t" \
"fpack16 %%f20, %%f20 \n\t" \
"fpack16 %%f6, %%f6 \n\t" \
"fpack16 %%f22, %%f22 \n\t" \
"fpack16 %%f2, %%f2 \n\t" \
"fpack16 %%f18, %%f18 \n\t"


#define YUV2RGB_INIT \
"wr %%g0, 0x10, %%gsr \n\t" \
"ldd [%5], %%f32 \n\t" \
"ldd [%5 + 8], %%f34 \n\t" \
"ldd [%5 + 16], %%f36 \n\t" \
"ldd [%5 + 24], %%f38 \n\t" \
"ldd [%5 + 32], %%f40 \n\t" \
"ldd [%5 + 40], %%f42 \n\t" \
"ldd [%5 + 48], %%f44 \n\t" \
"ldd [%5 + 56], %%f46 \n\t" \
"ldd [%5 + 64], %%f48 \n\t" \
"ldd [%5 + 72], %%f50 \n\t"

#define YUV2RGB_KERNEL \
/* ^^^^ f0=Y f3=u f5=v */ \
"fmul8x16 %%f3, %%f48, %%f6 \n\t" \
"fmul8x16 %%f19, %%f48, %%f22 \n\t" \
"fmul8x16 %%f5, %%f44, %%f8 \n\t" \
"fmul8x16 %%f21, %%f44, %%f24 \n\t" \
"fmul8x16 %%f0, %%f42, %%f0 \n\t" \
"fmul8x16 %%f16, %%f42, %%f16 \n\t" \
"fmul8x16 %%f3, %%f50, %%f2 \n\t" \
"fmul8x16 %%f19, %%f50, %%f18 \n\t" \
"fmul8x16 %%f5, %%f46, %%f4 \n\t" \
"fmul8x16 %%f21, %%f46, %%f20 \n\t" \
\
"fpsub16 %%f6, %%f34, %%f6 \n\t" /* 1 */ \
"fpsub16 %%f22, %%f34, %%f22 \n\t" /* 1 */ \
"fpsub16 %%f8, %%f38, %%f8 \n\t" /* 3 */ \
"fpsub16 %%f24, %%f38, %%f24 \n\t" /* 3 */ \
"fpsub16 %%f0, %%f32, %%f0 \n\t" /* 0 */ \
"fpsub16 %%f16, %%f32, %%f16 \n\t" /* 0 */ \
"fpsub16 %%f2, %%f36, %%f2 \n\t" /* 2 */ \
"fpsub16 %%f18, %%f36, %%f18 \n\t" /* 2 */ \
"fpsub16 %%f4, %%f40, %%f4 \n\t" /* 4 */ \
"fpsub16 %%f20, %%f40, %%f20 \n\t" /* 4 */ \
\
"fpadd16 %%f0, %%f8, %%f8 \n\t" /* Gt */ \
"fpadd16 %%f16, %%f24, %%f24 \n\t" /* Gt */ \
"fpadd16 %%f0, %%f4, %%f4 \n\t" /* R */ \
"fpadd16 %%f16, %%f20, %%f20 \n\t" /* R */ \
"fpadd16 %%f0, %%f6, %%f6 \n\t" /* B */ \
"fpadd16 %%f16, %%f22, %%f22 \n\t" /* B */ \
"fpadd16 %%f8, %%f2, %%f2 \n\t" /* G */ \
"fpadd16 %%f24, %%f18, %%f18 \n\t" /* G */ \
\
"fpack16 %%f4, %%f4 \n\t" \
"fpack16 %%f20, %%f20 \n\t" \
"fpack16 %%f6, %%f6 \n\t" \
"fpack16 %%f22, %%f22 \n\t" \
"fpack16 %%f2, %%f2 \n\t" \
"fpack16 %%f18, %%f18 \n\t"


// FIXME: must be changed to set alpha to 255 instead of 0 // FIXME: must be changed to set alpha to 255 instead of 0
static int vis_420P_ARGB32(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[])
static int vis_420P_ARGB32(SwsContext *c, uint8_t *src[], int srcStride[],
int srcSliceY, int srcSliceH,
uint8_t *dst[], int dstStride[])
{ {
int y, out1, out2, out3, out4, out5, out6; int y, out1, out2, out3, out4, out5, out6;


for(y=0;y < srcSliceH;++y) {
for (y = 0; y < srcSliceH; ++y)
__asm__ volatile ( __asm__ volatile (
YUV2RGB_INIT YUV2RGB_INIT
"wr %%g0, 0xd2, %%asi \n\t" /* ASI_FL16_P */
"wr %%g0, 0xd2, %%asi \n\t" /* ASI_FL16_P */
"1: \n\t" "1: \n\t"
"ldda [%1] %%asi, %%f2 \n\t"
"ldda [%1+2] %%asi, %%f18 \n\t"
"ldda [%2] %%asi, %%f4 \n\t"
"ldda [%2+2] %%asi, %%f20 \n\t"
"ldda [%1] %%asi, %%f2 \n\t"
"ldda [%1 + 2] %%asi, %%f18 \n\t"
"ldda [%2] %%asi, %%f4 \n\t"
"ldda [%2 + 2] %%asi, %%f20 \n\t"
"ld [%0], %%f0 \n\t" "ld [%0], %%f0 \n\t"
"ld [%0+4], %%f16 \n\t" "ld [%0+4], %%f16 \n\t"
"fpmerge %%f3, %%f3, %%f2 \n\t"
"fpmerge %%f3, %%f3, %%f2 \n\t"
"fpmerge %%f19, %%f19, %%f18 \n\t" "fpmerge %%f19, %%f19, %%f18 \n\t"
"fpmerge %%f5, %%f5, %%f4 \n\t"
"fpmerge %%f5, %%f5, %%f4 \n\t"
"fpmerge %%f21, %%f21, %%f20 \n\t" "fpmerge %%f21, %%f21, %%f20 \n\t"
YUV2RGB_KERNEL YUV2RGB_KERNEL
"fzero %%f0 \n\t" "fzero %%f0 \n\t"
"fpmerge %%f4, %%f6, %%f8 \n\t" // r,b,t1
"fpmerge %%f20, %%f22, %%f24 \n\t" // r,b,t1
"fpmerge %%f0, %%f2, %%f10 \n\t" // 0,g,t2
"fpmerge %%f0, %%f18, %%f26 \n\t" // 0,g,t2
"fpmerge %%f10, %%f8, %%f4 \n\t" // t2,t1,msb
"fpmerge %%f26, %%f24, %%f20 \n\t" // t2,t1,msb
"fpmerge %%f11, %%f9, %%f6 \n\t" // t2,t1,lsb
"fpmerge %%f27, %%f25, %%f22 \n\t" // t2,t1,lsb
"std %%f4, [%3] \n\t"
"std %%f20, [%3+16] \n\t"
"std %%f6, [%3+8] \n\t"
"std %%f22, [%3+24] \n\t"
"fpmerge %%f4, %%f6, %%f8 \n\t" // r, b, t1
"fpmerge %%f20, %%f22, %%f24 \n\t" // r, b, t1
"fpmerge %%f0, %%f2, %%f10 \n\t" // 0, g, t2
"fpmerge %%f0, %%f18, %%f26 \n\t" // 0, g, t2
"fpmerge %%f10, %%f8, %%f4 \n\t" // t2, t1, msb
"fpmerge %%f26, %%f24, %%f20 \n\t" // t2, t1, msb
"fpmerge %%f11, %%f9, %%f6 \n\t" // t2, t1, lsb
"fpmerge %%f27, %%f25, %%f22 \n\t" // t2, t1, lsb
"std %%f4, [%3] \n\t"
"std %%f20, [%3 + 16] \n\t"
"std %%f6, [%3 + 8] \n\t"
"std %%f22, [%3 + 24] \n\t"


"add %0, 8, %0 \n\t" "add %0, 8, %0 \n\t"
"add %1, 4, %1 \n\t" "add %1, 4, %1 \n\t"
"add %2, 4, %2 \n\t" "add %2, 4, %2 \n\t"
"subcc %4, 8, %4 \n\t" "subcc %4, 8, %4 \n\t"
"bne 1b \n\t" "bne 1b \n\t"
"add %3, 32, %3 \n\t" //delay slot
"add %3, 32, %3 \n\t" // delay slot
: "=r" (out1), "=r" (out2), "=r" (out3), "=r" (out4), "=r" (out5), "=r" (out6) : "=r" (out1), "=r" (out2), "=r" (out3), "=r" (out4), "=r" (out5), "=r" (out6)
: "0" (src[0]+(y+srcSliceY)*srcStride[0]), "1" (src[1]+((y+srcSliceY)>>1)*srcStride[1]),
"2" (src[2]+((y+srcSliceY)>>1)*srcStride[2]), "3" (dst[0]+(y+srcSliceY)*dstStride[0]),
"4" (c->dstW),
"5" (c->sparc_coeffs)
);
}
: "0" (src[0] + (y + srcSliceY) * srcStride[0]), "1" (src[1] + ((y + srcSliceY) >> 1) * srcStride[1]),
"2" (src[2] + ((y + srcSliceY) >> 1) * srcStride[2]), "3" (dst[0] + (y + srcSliceY) * dstStride[0]),
"4" (c->dstW),
"5" (c->sparc_coeffs)
);


return srcSliceH; return srcSliceH;
} }


// FIXME: must be changed to set alpha to 255 instead of 0 // FIXME: must be changed to set alpha to 255 instead of 0
static int vis_422P_ARGB32(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[])
static int vis_422P_ARGB32(SwsContext *c, uint8_t *src[], int srcStride[],
int srcSliceY, int srcSliceH,
uint8_t *dst[], int dstStride[])
{ {
int y, out1, out2, out3, out4, out5, out6; int y, out1, out2, out3, out4, out5, out6;


for(y=0;y < srcSliceH;++y) {
for (y = 0; y < srcSliceH; ++y)
__asm__ volatile ( __asm__ volatile (
YUV2RGB_INIT YUV2RGB_INIT
"wr %%g0, 0xd2, %%asi \n\t" /* ASI_FL16_P */ "wr %%g0, 0xd2, %%asi \n\t" /* ASI_FL16_P */
"1: \n\t" "1: \n\t"
"ldda [%1] %%asi, %%f2 \n\t"
"ldda [%1+2] %%asi, %%f18 \n\t"
"ldda [%2] %%asi, %%f4 \n\t"
"ldda [%2+2] %%asi, %%f20 \n\t"
"ld [%0], %%f0 \n\t"
"ld [%0+4], %%f16 \n\t"
"fpmerge %%f3, %%f3, %%f2 \n\t"
"ldda [%1] %%asi, %%f2 \n\t"
"ldda [%1 + 2] %%asi, %%f18 \n\t"
"ldda [%2] %%asi, %%f4 \n\t"
"ldda [%2 + 2] %%asi, %%f20 \n\t"
"ld [%0], %%f0 \n\t"
"ld [%0 + 4], %%f16 \n\t"
"fpmerge %%f3, %%f3, %%f2 \n\t"
"fpmerge %%f19, %%f19, %%f18 \n\t" "fpmerge %%f19, %%f19, %%f18 \n\t"
"fpmerge %%f5, %%f5, %%f4 \n\t"
"fpmerge %%f5, %%f5, %%f4 \n\t"
"fpmerge %%f21, %%f21, %%f20 \n\t" "fpmerge %%f21, %%f21, %%f20 \n\t"
YUV2RGB_KERNEL YUV2RGB_KERNEL
"fzero %%f0 \n\t" "fzero %%f0 \n\t"
"fpmerge %%f4, %%f6, %%f8 \n\t" // r,b,t1
"fpmerge %%f4, %%f6, %%f8 \n\t" // r,b,t1
"fpmerge %%f20, %%f22, %%f24 \n\t" // r,b,t1 "fpmerge %%f20, %%f22, %%f24 \n\t" // r,b,t1
"fpmerge %%f0, %%f2, %%f10 \n\t" // 0,g,t2
"fpmerge %%f0, %%f18, %%f26 \n\t" // 0,g,t2
"fpmerge %%f10, %%f8, %%f4 \n\t" // t2,t1,msb
"fpmerge %%f0, %%f2, %%f10 \n\t" // 0,g,t2
"fpmerge %%f0, %%f18, %%f26 \n\t" // 0,g,t2
"fpmerge %%f10, %%f8, %%f4 \n\t" // t2,t1,msb
"fpmerge %%f26, %%f24, %%f20 \n\t" // t2,t1,msb "fpmerge %%f26, %%f24, %%f20 \n\t" // t2,t1,msb
"fpmerge %%f11, %%f9, %%f6 \n\t" // t2,t1,lsb
"fpmerge %%f11, %%f9, %%f6 \n\t" // t2,t1,lsb
"fpmerge %%f27, %%f25, %%f22 \n\t" // t2,t1,lsb "fpmerge %%f27, %%f25, %%f22 \n\t" // t2,t1,lsb
"std %%f4, [%3] \n\t"
"std %%f20, [%3+16] \n\t"
"std %%f6, [%3+8] \n\t"
"std %%f22, [%3+24] \n\t"
"std %%f4, [%3] \n\t"
"std %%f20, [%3 + 16] \n\t"
"std %%f6, [%3 + 8] \n\t"
"std %%f22, [%3 + 24] \n\t"


"add %0, 8, %0 \n\t" "add %0, 8, %0 \n\t"
"add %1, 4, %1 \n\t" "add %1, 4, %1 \n\t"
@@ -176,36 +175,36 @@ static int vis_422P_ARGB32(SwsContext *c, uint8_t* src[], int srcStride[], int s
"bne 1b \n\t" "bne 1b \n\t"
"add %3, 32, %3 \n\t" //delay slot "add %3, 32, %3 \n\t" //delay slot
: "=r" (out1), "=r" (out2), "=r" (out3), "=r" (out4), "=r" (out5), "=r" (out6) : "=r" (out1), "=r" (out2), "=r" (out3), "=r" (out4), "=r" (out5), "=r" (out6)
: "0" (src[0]+(y+srcSliceY)*srcStride[0]), "1" (src[1]+(y+srcSliceY)*srcStride[1]),
"2" (src[2]+(y+srcSliceY)*srcStride[2]), "3" (dst[0]+(y+srcSliceY)*dstStride[0]),
"4" (c->dstW),
"5" (c->sparc_coeffs)
);
}
: "0" (src[0] + (y + srcSliceY) * srcStride[0]), "1" (src[1] + (y + srcSliceY) * srcStride[1]),
"2" (src[2] + (y + srcSliceY) * srcStride[2]), "3" (dst[0] + (y + srcSliceY) * dstStride[0]),
"4" (c->dstW),
"5" (c->sparc_coeffs)
);


return srcSliceH; return srcSliceH;
} }


SwsFunc ff_yuv2rgb_init_vis(SwsContext *c) SwsFunc ff_yuv2rgb_init_vis(SwsContext *c)
{ {
c->sparc_coeffs[5]=c->yCoeff;
c->sparc_coeffs[6]=c->vgCoeff;
c->sparc_coeffs[7]=c->vrCoeff;
c->sparc_coeffs[8]=c->ubCoeff;
c->sparc_coeffs[9]=c->ugCoeff;

c->sparc_coeffs[0]=(((int16_t)c->yOffset*(int16_t)c->yCoeff >>11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[1]=(((int16_t)c->uOffset*(int16_t)c->ubCoeff>>11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[2]=(((int16_t)c->uOffset*(int16_t)c->ugCoeff>>11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[3]=(((int16_t)c->vOffset*(int16_t)c->vgCoeff>>11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[4]=(((int16_t)c->vOffset*(int16_t)c->vrCoeff>>11) & 0xffff) * 0x0001000100010001ULL;

if (c->dstFormat == PIX_FMT_RGB32 && c->srcFormat == PIX_FMT_YUV422P && (c->dstW & 7)==0) {
av_log(c, AV_LOG_INFO, "SPARC VIS accelerated YUV422P -> RGB32 (WARNING: alpha value is wrong)\n");
c->sparc_coeffs[5] = c->yCoeff;
c->sparc_coeffs[6] = c->vgCoeff;
c->sparc_coeffs[7] = c->vrCoeff;
c->sparc_coeffs[8] = c->ubCoeff;
c->sparc_coeffs[9] = c->ugCoeff;

c->sparc_coeffs[0] = (((int16_t)c->yOffset * (int16_t)c->yCoeff >> 11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[1] = (((int16_t)c->uOffset * (int16_t)c->ubCoeff >> 11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[2] = (((int16_t)c->uOffset * (int16_t)c->ugCoeff >> 11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[3] = (((int16_t)c->vOffset * (int16_t)c->vgCoeff >> 11) & 0xffff) * 0x0001000100010001ULL;
c->sparc_coeffs[4] = (((int16_t)c->vOffset * (int16_t)c->vrCoeff >> 11) & 0xffff) * 0x0001000100010001ULL;

if (c->dstFormat == PIX_FMT_RGB32 && c->srcFormat == PIX_FMT_YUV422P && (c->dstW & 7) == 0) {
av_log(c, AV_LOG_INFO,
"SPARC VIS accelerated YUV422P -> RGB32 (WARNING: alpha value is wrong)\n");
return vis_422P_ARGB32; return vis_422P_ARGB32;
}
else if (c->dstFormat == PIX_FMT_RGB32 && c->srcFormat == PIX_FMT_YUV420P && (c->dstW & 7)==0) {
av_log(c, AV_LOG_INFO, "SPARC VIS accelerated YUV420P -> RGB32 (WARNING: alpha value is wrong)\n");
} else if (c->dstFormat == PIX_FMT_RGB32 && c->srcFormat == PIX_FMT_YUV420P && (c->dstW & 7) == 0) {
av_log(c, AV_LOG_INFO,
"SPARC VIS accelerated YUV420P -> RGB32 (WARNING: alpha value is wrong)\n");
return vis_420P_ARGB32; return vis_420P_ARGB32;
} }
return NULL; return NULL;


+ 23
- 2373
libswscale/swscale.c
File diff suppressed because it is too large
View File


+ 10
- 2
libswscale/swscale_internal.h View File

@@ -359,8 +359,8 @@ typedef struct SwsContext {
#define V_TEMP "11*8+4*4*256*2+32" #define V_TEMP "11*8+4*4*256*2+32"
#define Y_TEMP "11*8+4*4*256*2+40" #define Y_TEMP "11*8+4*4*256*2+40"
#define ALP_MMX_FILTER_OFFSET "11*8+4*4*256*2+48" #define ALP_MMX_FILTER_OFFSET "11*8+4*4*256*2+48"
#define UV_OFF "11*8+4*4*256*3+48"
#define UV_OFFx2 "11*8+4*4*256*3+56"
#define UV_OFF_PX "11*8+4*4*256*3+48"
#define UV_OFF_BYTE "11*8+4*4*256*3+56"
#define DITHER16 "11*8+4*4*256*3+64" #define DITHER16 "11*8+4*4*256*3+64"
#define DITHER32 "11*8+4*4*256*3+80" #define DITHER32 "11*8+4*4*256*3+80"


@@ -706,6 +706,14 @@ void ff_swscale_get_unscaled_altivec(SwsContext *c);
*/ */
SwsFunc ff_getSwsFunc(SwsContext *c); SwsFunc ff_getSwsFunc(SwsContext *c);


void ff_sws_init_input_funcs(SwsContext *c);
void ff_sws_init_output_funcs(SwsContext *c,
yuv2planar1_fn *yuv2plane1,
yuv2planarX_fn *yuv2planeX,
yuv2interleavedX_fn *yuv2nv12cX,
yuv2packed1_fn *yuv2packed1,
yuv2packed2_fn *yuv2packed2,
yuv2packedX_fn *yuv2packedX);
void ff_sws_init_swScale_altivec(SwsContext *c); void ff_sws_init_swScale_altivec(SwsContext *c);
void ff_sws_init_swScale_mmx(SwsContext *c); void ff_sws_init_swScale_mmx(SwsContext *c);




+ 96
- 0
libswscale/swscale_unscaled.c View File

@@ -45,6 +45,102 @@
#define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)) #define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5)) #define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))


DECLARE_ALIGNED(8, const uint8_t, dithers)[8][8][8]={
{
{ 0, 1, 0, 1, 0, 1, 0, 1,},
{ 1, 0, 1, 0, 1, 0, 1, 0,},
{ 0, 1, 0, 1, 0, 1, 0, 1,},
{ 1, 0, 1, 0, 1, 0, 1, 0,},
{ 0, 1, 0, 1, 0, 1, 0, 1,},
{ 1, 0, 1, 0, 1, 0, 1, 0,},
{ 0, 1, 0, 1, 0, 1, 0, 1,},
{ 1, 0, 1, 0, 1, 0, 1, 0,},
},{
{ 1, 2, 1, 2, 1, 2, 1, 2,},
{ 3, 0, 3, 0, 3, 0, 3, 0,},
{ 1, 2, 1, 2, 1, 2, 1, 2,},
{ 3, 0, 3, 0, 3, 0, 3, 0,},
{ 1, 2, 1, 2, 1, 2, 1, 2,},
{ 3, 0, 3, 0, 3, 0, 3, 0,},
{ 1, 2, 1, 2, 1, 2, 1, 2,},
{ 3, 0, 3, 0, 3, 0, 3, 0,},
},{
{ 2, 4, 3, 5, 2, 4, 3, 5,},
{ 6, 0, 7, 1, 6, 0, 7, 1,},
{ 3, 5, 2, 4, 3, 5, 2, 4,},
{ 7, 1, 6, 0, 7, 1, 6, 0,},
{ 2, 4, 3, 5, 2, 4, 3, 5,},
{ 6, 0, 7, 1, 6, 0, 7, 1,},
{ 3, 5, 2, 4, 3, 5, 2, 4,},
{ 7, 1, 6, 0, 7, 1, 6, 0,},
},{
{ 4, 8, 7, 11, 4, 8, 7, 11,},
{ 12, 0, 15, 3, 12, 0, 15, 3,},
{ 6, 10, 5, 9, 6, 10, 5, 9,},
{ 14, 2, 13, 1, 14, 2, 13, 1,},
{ 4, 8, 7, 11, 4, 8, 7, 11,},
{ 12, 0, 15, 3, 12, 0, 15, 3,},
{ 6, 10, 5, 9, 6, 10, 5, 9,},
{ 14, 2, 13, 1, 14, 2, 13, 1,},
},{
{ 9, 17, 15, 23, 8, 16, 14, 22,},
{ 25, 1, 31, 7, 24, 0, 30, 6,},
{ 13, 21, 11, 19, 12, 20, 10, 18,},
{ 29, 5, 27, 3, 28, 4, 26, 2,},
{ 8, 16, 14, 22, 9, 17, 15, 23,},
{ 24, 0, 30, 6, 25, 1, 31, 7,},
{ 12, 20, 10, 18, 13, 21, 11, 19,},
{ 28, 4, 26, 2, 29, 5, 27, 3,},
},{
{ 18, 34, 30, 46, 17, 33, 29, 45,},
{ 50, 2, 62, 14, 49, 1, 61, 13,},
{ 26, 42, 22, 38, 25, 41, 21, 37,},
{ 58, 10, 54, 6, 57, 9, 53, 5,},
{ 16, 32, 28, 44, 19, 35, 31, 47,},
{ 48, 0, 60, 12, 51, 3, 63, 15,},
{ 24, 40, 20, 36, 27, 43, 23, 39,},
{ 56, 8, 52, 4, 59, 11, 55, 7,},
},{
{ 18, 34, 30, 46, 17, 33, 29, 45,},
{ 50, 2, 62, 14, 49, 1, 61, 13,},
{ 26, 42, 22, 38, 25, 41, 21, 37,},
{ 58, 10, 54, 6, 57, 9, 53, 5,},
{ 16, 32, 28, 44, 19, 35, 31, 47,},
{ 48, 0, 60, 12, 51, 3, 63, 15,},
{ 24, 40, 20, 36, 27, 43, 23, 39,},
{ 56, 8, 52, 4, 59, 11, 55, 7,},
},{
{ 36, 68, 60, 92, 34, 66, 58, 90,},
{ 100, 4,124, 28, 98, 2,122, 26,},
{ 52, 84, 44, 76, 50, 82, 42, 74,},
{ 116, 20,108, 12,114, 18,106, 10,},
{ 32, 64, 56, 88, 38, 70, 62, 94,},
{ 96, 0,120, 24,102, 6,126, 30,},
{ 48, 80, 40, 72, 54, 86, 46, 78,},
{ 112, 16,104, 8,118, 22,110, 14,},
}};

static const uint8_t flat64[8]={64,64,64,64,64,64,64,64};

const uint16_t dither_scale[15][16]={
{ 2, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,},
{ 2, 3, 7, 7, 13, 13, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,},
{ 3, 3, 4, 15, 15, 29, 57, 57, 57, 113, 113, 113, 113, 113, 113, 113,},
{ 3, 4, 4, 5, 31, 31, 61, 121, 241, 241, 241, 241, 481, 481, 481, 481,},
{ 3, 4, 5, 5, 6, 63, 63, 125, 249, 497, 993, 993, 993, 993, 993, 1985,},
{ 3, 5, 6, 6, 6, 7, 127, 127, 253, 505, 1009, 2017, 4033, 4033, 4033, 4033,},
{ 3, 5, 6, 7, 7, 7, 8, 255, 255, 509, 1017, 2033, 4065, 8129,16257,16257,},
{ 3, 5, 6, 8, 8, 8, 8, 9, 511, 511, 1021, 2041, 4081, 8161,16321,32641,},
{ 3, 5, 7, 8, 9, 9, 9, 9, 10, 1023, 1023, 2045, 4089, 8177,16353,32705,},
{ 3, 5, 7, 8, 10, 10, 10, 10, 10, 11, 2047, 2047, 4093, 8185,16369,32737,},
{ 3, 5, 7, 8, 10, 11, 11, 11, 11, 11, 12, 4095, 4095, 8189,16377,32753,},
{ 3, 5, 7, 9, 10, 12, 12, 12, 12, 12, 12, 13, 8191, 8191,16381,32761,},
{ 3, 5, 7, 9, 10, 12, 13, 13, 13, 13, 13, 13, 14,16383,16383,32765,},
{ 3, 5, 7, 9, 10, 12, 14, 14, 14, 14, 14, 14, 14, 15,32767,32767,},
{ 3, 5, 7, 9, 11, 12, 14, 15, 15, 15, 15, 15, 15, 15, 16,65535,},
};


static void fillPlane(uint8_t *plane, int stride, int width, int height, int y, static void fillPlane(uint8_t *plane, int stride, int width, int height, int y,
uint8_t val) uint8_t val)
{ {


+ 25
- 25
libswscale/x86/output.asm View File

@@ -275,17 +275,17 @@ yuv2planeX_fn 10, 7, 5
%macro yuv2plane1_mainloop 2 %macro yuv2plane1_mainloop 2
.loop_%2: .loop_%2:
%if %1 == 8 %if %1 == 8
paddsw m0, m2, [r0+r2*2+mmsize*0]
paddsw m1, m3, [r0+r2*2+mmsize*1]
paddsw m0, m2, [srcq+dstwq*2+mmsize*0]
paddsw m1, m3, [srcq+dstwq*2+mmsize*1]
psraw m0, 7 psraw m0, 7
psraw m1, 7 psraw m1, 7
packuswb m0, m1 packuswb m0, m1
mov%2 [r1+r2], m0 mov%2 [r1+r2], m0
%elif %1 == 16 %elif %1 == 16
paddd m0, m4, [r0+r2*4+mmsize*0]
paddd m1, m4, [r0+r2*4+mmsize*1]
paddd m2, m4, [r0+r2*4+mmsize*2]
paddd m3, m4, [r0+r2*4+mmsize*3]
paddd m0, m4, [srcq+dstwq*4+mmsize*0]
paddd m1, m4, [srcq+dstwq*4+mmsize*1]
paddd m2, m4, [srcq+dstwq*4+mmsize*2]
paddd m3, m4, [srcq+dstwq*4+mmsize*3]
psrad m0, 3 psrad m0, 3
psrad m1, 3 psrad m1, 3
psrad m2, 3 psrad m2, 3
@@ -299,46 +299,46 @@ yuv2planeX_fn 10, 7, 5
paddw m0, m5 paddw m0, m5
paddw m2, m5 paddw m2, m5
%endif ; mmx/sse2/sse4/avx %endif ; mmx/sse2/sse4/avx
mov%2 [r1+r2*2], m0
mov%2 [r1+r2*2+mmsize], m2
%else
paddsw m0, m2, [r0+r2*2+mmsize*0]
paddsw m1, m2, [r0+r2*2+mmsize*1]
mov%2 [dstq+dstwq*2+mmsize*0], m0
mov%2 [dstq+dstwq*2+mmsize*1], m2
%else ; %1 == 9/10
paddsw m0, m2, [srcq+dstwq*2+mmsize*0]
paddsw m1, m2, [srcq+dstwq*2+mmsize*1]
psraw m0, 15 - %1 psraw m0, 15 - %1
psraw m1, 15 - %1 psraw m1, 15 - %1
pmaxsw m0, m4 pmaxsw m0, m4
pmaxsw m1, m4 pmaxsw m1, m4
pminsw m0, m3 pminsw m0, m3
pminsw m1, m3 pminsw m1, m3
mov%2 [r1+r2*2], m0
mov%2 [r1+r2*2+mmsize], m1
mov%2 [dstq+dstwq*2+mmsize*0], m0
mov%2 [dstq+dstwq*2+mmsize*1], m1
%endif %endif
add r2, mmsize
add dstwq, mmsize
jl .loop_%2 jl .loop_%2
%endmacro %endmacro


%macro yuv2plane1_fn 3 %macro yuv2plane1_fn 3
cglobal yuv2plane1_%1, %3, %3, %2
add r2, mmsize - 1
and r2, ~(mmsize - 1)
cglobal yuv2plane1_%1, %3, %3, %2, src, dst, dstw, dither, offset
add dstwq, mmsize - 1
and dstwq, ~(mmsize - 1)
%if %1 == 8 %if %1 == 8
add r1, r2
add dstq, dstwq
%else ; %1 != 8 %else ; %1 != 8
lea r1, [r1+r2*2]
lea dstq, [dstq+dstwq*2]
%endif ; %1 == 8 %endif ; %1 == 8
%if %1 == 16 %if %1 == 16
lea r0, [r0+r2*4]
lea srcq, [srcq+dstwq*4]
%else ; %1 != 16 %else ; %1 != 16
lea r0, [r0+r2*2]
lea srcq, [srcq+dstwq*2]
%endif ; %1 == 16 %endif ; %1 == 16
neg r2
neg dstwq


%if %1 == 8 %if %1 == 8
pxor m4, m4 ; zero pxor m4, m4 ; zero


; create registers holding dither ; create registers holding dither
movq m3, [r3] ; dither
test r4d, r4d
movq m3, [ditherq] ; dither
test offsetd, offsetd
jz .no_rot jz .no_rot
%if mmsize == 16 %if mmsize == 16
punpcklqdq m3, m3 punpcklqdq m3, m3
@@ -374,7 +374,7 @@ cglobal yuv2plane1_%1, %3, %3, %2
%if mmsize == 8 %if mmsize == 8
yuv2plane1_mainloop %1, a yuv2plane1_mainloop %1, a
%else ; mmsize == 16 %else ; mmsize == 16
test r1, 15
test dstq, 15
jnz .unaligned jnz .unaligned
yuv2plane1_mainloop %1, a yuv2plane1_mainloop %1, a
REP_RET REP_RET


+ 12
- 12
libswscale/x86/swscale_template.c View File

@@ -762,10 +762,10 @@ static void RENAME(yuv2yuyv422_X)(SwsContext *c, const int16_t *lumFilter,
"1: \n\t"\ "1: \n\t"\
"movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\ "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
"movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\ "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
"add "UV_OFFx2"("#c"), "#index" \n\t" \
"add "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\ "movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
"movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\ "movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
"sub "UV_OFFx2"("#c"), "#index" \n\t" \
"sub "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"psubw %%mm3, %%mm2 \n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\ "psubw %%mm3, %%mm2 \n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\
"psubw %%mm4, %%mm5 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\ "psubw %%mm4, %%mm5 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\
"movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\ "movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\
@@ -993,10 +993,10 @@ static void RENAME(yuv2rgb565_2)(SwsContext *c, const int16_t *buf[2],
"1: \n\t"\ "1: \n\t"\
"movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\ "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
"movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\ "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
"add "UV_OFFx2"("#c"), "#index" \n\t" \
"add "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\ "movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
"movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\ "movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
"sub "UV_OFFx2"("#c"), "#index" \n\t" \
"sub "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"psubw %%mm3, %%mm2 \n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\ "psubw %%mm3, %%mm2 \n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\
"psubw %%mm4, %%mm5 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\ "psubw %%mm4, %%mm5 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\
"movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\ "movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\
@@ -1048,9 +1048,9 @@ static void RENAME(yuv2yuyv422_2)(SwsContext *c, const int16_t *buf[2],
".p2align 4 \n\t"\ ".p2align 4 \n\t"\
"1: \n\t"\ "1: \n\t"\
"movq (%2, "#index"), %%mm3 \n\t" /* uvbuf0[eax]*/\ "movq (%2, "#index"), %%mm3 \n\t" /* uvbuf0[eax]*/\
"add "UV_OFFx2"("#c"), "#index" \n\t" \
"add "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"movq (%2, "#index"), %%mm4 \n\t" /* uvbuf0[eax+2048]*/\ "movq (%2, "#index"), %%mm4 \n\t" /* uvbuf0[eax+2048]*/\
"sub "UV_OFFx2"("#c"), "#index" \n\t" \
"sub "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"psraw $4, %%mm3 \n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\ "psraw $4, %%mm3 \n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\
"psraw $4, %%mm4 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\ "psraw $4, %%mm4 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\
"psubw "U_OFFSET"("#c"), %%mm3 \n\t" /* (U-128)8*/\ "psubw "U_OFFSET"("#c"), %%mm3 \n\t" /* (U-128)8*/\
@@ -1101,10 +1101,10 @@ static void RENAME(yuv2yuyv422_2)(SwsContext *c, const int16_t *buf[2],
"1: \n\t"\ "1: \n\t"\
"movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\ "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
"movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\ "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
"add "UV_OFFx2"("#c"), "#index" \n\t" \
"add "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\ "movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
"movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\ "movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
"sub "UV_OFFx2"("#c"), "#index" \n\t" \
"sub "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\ "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\
"paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\ "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\
"psrlw $5, %%mm3 \n\t" /*FIXME might overflow*/\ "psrlw $5, %%mm3 \n\t" /*FIXME might overflow*/\
@@ -1368,9 +1368,9 @@ static void RENAME(yuv2rgb565_1)(SwsContext *c, const int16_t *buf0,
".p2align 4 \n\t"\ ".p2align 4 \n\t"\
"1: \n\t"\ "1: \n\t"\
"movq (%2, "#index"), %%mm3 \n\t" /* uvbuf0[eax]*/\ "movq (%2, "#index"), %%mm3 \n\t" /* uvbuf0[eax]*/\
"add "UV_OFFx2"("#c"), "#index" \n\t" \
"add "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"movq (%2, "#index"), %%mm4 \n\t" /* uvbuf0[eax+2048]*/\ "movq (%2, "#index"), %%mm4 \n\t" /* uvbuf0[eax+2048]*/\
"sub "UV_OFFx2"("#c"), "#index" \n\t" \
"sub "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"psraw $7, %%mm3 \n\t" \ "psraw $7, %%mm3 \n\t" \
"psraw $7, %%mm4 \n\t" \ "psraw $7, %%mm4 \n\t" \
"movq (%0, "#index", 2), %%mm1 \n\t" /*buf0[eax]*/\ "movq (%0, "#index", 2), %%mm1 \n\t" /*buf0[eax]*/\
@@ -1386,10 +1386,10 @@ static void RENAME(yuv2rgb565_1)(SwsContext *c, const int16_t *buf0,
"1: \n\t"\ "1: \n\t"\
"movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\ "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
"movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\ "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
"add "UV_OFFx2"("#c"), "#index" \n\t" \
"add "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\ "movq (%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
"movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\ "movq (%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
"sub "UV_OFFx2"("#c"), "#index" \n\t" \
"sub "UV_OFF_BYTE"("#c"), "#index" \n\t" \
"paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\ "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\
"paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\ "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\
"psrlw $8, %%mm3 \n\t" \ "psrlw $8, %%mm3 \n\t" \


Write Preview
Loading…
Cancel
Save