version <next>:
-
-
-version 0.7_beta2:
-
+- many many things we forgot because we rather write code than changelogs
+- libmpcodecs video filter support (3 times as many filters than before)
+- mpeg2 aspect ratio dection fixed
+- libxvid aspect pickiness fixed
+- Frame multithreaded decoding
+ - E-AC-3 audio encoder
- Lots of deprecated API cruft removed
- fft and imdct optimizations for AVX (Sandy Bridge) processors
+- showinfo filter added
- DPX image encoder
- SMPTE 302M AES3 audio decoder
-- Remove support for quitting ffmpeg with 'q', ctrl+c should be used.
-- 9bit and 10bit per sample support in the h264 decoder
+- Apple Core Audio Format muxer
+- 9bit and 10bit H.264 decoding
+- 9bit and 10bit FFV1 encoding / decoding
+- split filter added
+- select filter added
+- sdl output device added
version 0.7_beta1:
API changes, most recent first:
+2011-05-28 - xxxxxx - lavu 51.3.0 - pixdesc.h
+ Add av_get_pix_fmt_name() in libavutil/pixdesc.h, and deprecate
+ avcodec_get_pix_fmt_name() in libavcodec/avcodec.h in its favor.
+
+2011-05-22 - xxxxxx - lavf 53.2.0 - avformat.h
+ Introduce avformat_alloc_output_context2() and deprecate
+ avformat_alloc_output_context().
+
+2011-05-22 - xxxxxx - lavfi 2.10.0 - vsrc_buffer.h
+ Make libavfilter/vsrc_buffer.h public.
+
+2011-05-XX - XXXXXX - lavfi 2.8.0 - avcodec.h
+ Add av_vsrc_buffer_add_frame() to libavfilter/avcodec.h.
+
+2011-05-XX - XXXXXX - lavfi 2.6.0 - avcodec.h
+ Add avfilter_get_video_buffer_ref_from_frame() to libavfilter/avcodec.h.
+
+ 2011-05-28 - 0420bd7 - lavu 51.2.0 - pixdesc.h
+ Add av_get_pix_fmt_name() in libavutil/pixdesc.h, and deprecate
+ avcodec_get_pix_fmt_name() in libavcodec/avcodec.h in its favor.
+
2011-05-25 - 30315a8 - lavf 53.1.0 - avformat.h
Add fps_probe_size to AVFormatContext.
--- /dev/null
- ff_ac3_options, LIBAVUTIL_VERSION_INT };
+
+#include "libavutil/opt.h"
+#include "libavutil/samplefmt.h"
+#include "avcodec.h"
+#include "ac3.h"
+
+typedef struct CombineContext{
+ AVClass *av_class; ///< AVClass used for AVOption
+ AC3EncOptions options; ///< encoding options
+ void *ctx;
+ AVCodec *codec;
+}CombineContext;
+
++#define OFFSET(param) offsetof(CombineContext, options.param)
++#define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
++
++#define AC3ENC_TYPE_AC3_FIXED 0
++#define AC3ENC_TYPE_AC3 1
++#define AC3ENC_TYPE_EAC3 2
++
++#define AC3ENC_TYPE 12354
++#include "ac3enc_opts_template.c"
++
+static AVClass ac3enc_class = { "AC-3 Encoder", av_default_item_name,
++ eac3_options, LIBAVUTIL_VERSION_INT };
+
+static av_cold AVCodec *get_codec(enum AVSampleFormat s){
+#if CONFIG_AC3_FIXED_ENCODER
+ if(s==AV_SAMPLE_FMT_S16) return &ff_ac3_fixed_encoder;
+#endif
+#if CONFIG_AC3_FLOAT_ENCODER
+ if(s==AV_SAMPLE_FMT_FLT) return &ff_ac3_float_encoder;
+#endif
+ return NULL;
+}
+
+
+static av_cold int encode_init(AVCodecContext *avctx)
+{
+ CombineContext *c= avctx->priv_data;
+ int ret;
+ int offset= (uint8_t*)&c->options - (uint8_t*)c;
+
+ c->codec= get_codec(avctx->sample_fmt);
+ if(!c->codec){
+ av_log(avctx, AV_LOG_ERROR, "Unsupported sample format\n");
+ return -1;
+ }
+ c->ctx= av_mallocz(c->codec->priv_data_size);
+ memcpy((uint8_t*)c->ctx + offset, &c->options, (uint8_t*)&c->ctx - (uint8_t*)&c->options);
+ FFSWAP(void *,avctx->priv_data, c->ctx);
+ ret= c->codec->init(avctx);
+ FFSWAP(void *,avctx->priv_data, c->ctx);
+ return ret;
+}
+
+static int encode_frame(AVCodecContext *avctx, unsigned char *frame,
+ int buf_size, void *data)
+{
+ CombineContext *c= avctx->priv_data;
+ int ret;
+
+ FFSWAP(void *,avctx->priv_data, c->ctx);
+ ret= c->codec->encode(avctx, frame, buf_size, data);
+ FFSWAP(void *,avctx->priv_data, c->ctx);
+ return ret;
+}
+
+static av_cold int encode_close(AVCodecContext *avctx)
+{
+ CombineContext *c= avctx->priv_data;
+ int ret;
+
+ FFSWAP(void *,avctx->priv_data, c->ctx);
+ ret= c->codec->close(avctx);
+ FFSWAP(void *,avctx->priv_data, c->ctx);
+ return ret;
+}
+
+AVCodec ff_ac3_encoder = {
+ "ac3",
+ AVMEDIA_TYPE_AUDIO,
+ CODEC_ID_AC3,
+ sizeof(CombineContext),
+ encode_init,
+ encode_frame,
+ encode_close,
+ NULL,
+ .sample_fmts = (const enum AVSampleFormat[]){
+#if CONFIG_AC3_FLOAT_ENCODER
+ AV_SAMPLE_FMT_FLT,
+#endif
+#if CONFIG_AC3_FIXED_ENCODER
+ AV_SAMPLE_FMT_S16,
+#endif
+ AV_SAMPLE_FMT_NONE},
+ .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
+ .priv_class = &ac3enc_class,
+ .channel_layouts = ff_ac3_channel_layouts,
+};
}
-AVCodec ff_ac3_encoder = {
- "ac3",
+ #if CONFIG_AC3_ENCODER
+AVCodec ff_ac3_float_encoder = {
+ "ac3_float",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3,
sizeof(AC3EncodeContext),
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.priv_class = &ac3enc_class,
- .channel_layouts = ac3_channel_layouts,
+ .channel_layouts = ff_ac3_channel_layouts,
};
- .channel_layouts = ac3_channel_layouts,
+ #endif
+
+ #if CONFIG_EAC3_ENCODER
+ AVCodec ff_eac3_encoder = {
+ .name = "eac3",
+ .type = AVMEDIA_TYPE_AUDIO,
+ .id = CODEC_ID_EAC3,
+ .priv_data_size = sizeof(AC3EncodeContext),
+ .init = ac3_encode_init,
+ .encode = ac3_encode_frame,
+ .close = ac3_encode_close,
+ .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
+ .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"),
+ .priv_class = &eac3enc_class,
++ .channel_layouts = ff_ac3_channel_layouts,
+ };
+ #endif
REGISTER_DECODER (BINKAUDIO_DCT, binkaudio_dct);
REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft);
REGISTER_DECODER (COOK, cook);
- REGISTER_DECODER (DCA, dca);
+ REGISTER_ENCDEC (DCA, dca);
REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
- REGISTER_DECODER (EAC3, eac3);
+ REGISTER_ENCDEC (EAC3, eac3);
REGISTER_ENCDEC (FLAC, flac);
REGISTER_DECODER (GSM, gsm);
REGISTER_DECODER (GSM_MS, gsm_ms);
*/
#include "config.h"
-#include "libavformat/avformat.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
+#include "avdevice.h"
+
+#include <stdlib.h>
+#include <string.h>
#include "libavutil/parseutils.h"
+ #include "libavutil/pixdesc.h"
-#if HAVE_LIBDC1394_2
#include <dc1394/dc1394.h>
-#elif HAVE_LIBDC1394_1
-#include <libraw1394/raw1394.h>
-#include <libdc1394/dc1394_control.h>
-
-#define DC1394_VIDEO_MODE_320x240_YUV422 MODE_320x240_YUV422
-#define DC1394_VIDEO_MODE_640x480_YUV411 MODE_640x480_YUV411
-#define DC1394_VIDEO_MODE_640x480_YUV422 MODE_640x480_YUV422
-#define DC1394_FRAMERATE_1_875 FRAMERATE_1_875
-#define DC1394_FRAMERATE_3_75 FRAMERATE_3_75
-#define DC1394_FRAMERATE_7_5 FRAMERATE_7_5
-#define DC1394_FRAMERATE_15 FRAMERATE_15
-#define DC1394_FRAMERATE_30 FRAMERATE_30
-#define DC1394_FRAMERATE_60 FRAMERATE_60
-#define DC1394_FRAMERATE_120 FRAMERATE_120
-#define DC1394_FRAMERATE_240 FRAMERATE_240
-#endif
#undef free
#define OFFSET(x) offsetof(dc1394_data, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
-#if HAVE_LIBDC1394_1
- { "channel", "", offsetof(dc1394_data, channel), FF_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
-#endif
{ "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = "qvga"}, 0, 0, DEC },
+ { "pixel_format", "", OFFSET(pixel_format), FF_OPT_TYPE_STRING, {.str = "uyvy422"}, 0, 0, DEC },
{ NULL },
};
goto out;
}
- if ((ret = av_parse_video_size(&width, &height, dc1394->video_size)) < 0) {
- av_log(c, AV_LOG_ERROR, "Couldn't parse video size.\n");
- goto out;
+ /* FIXME: To select a specific camera I need to search in list its guid */
+ dc1394->camera = dc1394_camera_new (dc1394->d, list->ids[0].guid);
+ if (list->num > 1) {
+ av_log(c, AV_LOG_INFO, "Working with the first camera found\n");
}
-#if FF_API_FORMAT_PARAMETERS
- if (ap->width > 0)
- width = ap->width;
- if (ap->height > 0)
- height = ap->height;
- if (ap->pix_fmt)
- pix_fmt = ap->pix_fmt;
-#endif
-
- for (fmt = dc1394_frame_formats; fmt->width; fmt++)
- if (fmt->pix_fmt == pix_fmt && fmt->width == width && fmt->height == height)
- break;
-
- for (fps = dc1394_frame_rates; fps->frame_rate; fps++)
- if (fps->frame_rate == frame_rate)
- break;
-
- if (!fps->frame_rate || !fmt->width) {
- av_log(c, AV_LOG_ERROR, "Can't find matching camera format for %s, %dx%d@%d:1000fps\n", avcodec_get_pix_fmt_name(pix_fmt),
- width, height, frame_rate);
- ret = AVERROR(EINVAL);
- goto out;
+
+ /* Freeing list of cameras */
+ dc1394_camera_free_list (list);
+
+ /* Get the list of video modes supported by the camera. */
+ res = dc1394_video_get_supported_modes (dc1394->camera, &video_modes);
+ if (res != DC1394_SUCCESS) {
+ av_log(c, AV_LOG_ERROR, "Could not get video formats.\n");
+ goto out_camera;
+ }
+
++ if (dc1394->pixel_format) {
++ if ((ap->pix_fmt = av_get_pix_fmt(dc1394->pixel_format)) == PIX_FMT_NONE) {
++ av_log(c, AV_LOG_ERROR, "No such pixel format: %s.\n", dc1394->pixel_format);
++ ret = AVERROR(EINVAL);
++ goto out;
++ }
++ }
++
+ if (dc1394->video_size) {
+ if ((ret = av_parse_video_size(&ap->width, &ap->height, dc1394->video_size)) < 0) {
+ av_log(c, AV_LOG_ERROR, "Couldn't parse video size.\n");
+ goto out;
+ }
+ }
+
+ /* Choose the best mode. */
+ rate = (ap->time_base.num ? av_rescale(1000, ap->time_base.den, ap->time_base.num) : -1);
+ max_score = -1;
+ for (i = 0; i < video_modes.num; i++) {
+ if (video_modes.modes[i] == DC1394_VIDEO_MODE_EXIF
+ || (video_modes.modes[i] >= DC1394_VIDEO_MODE_FORMAT7_MIN
+ && video_modes.modes[i] <= DC1394_VIDEO_MODE_FORMAT7_MAX)) {
+ /* These modes are currently not supported as they would require
+ * much more work. For the remaining modes, the functions
+ * dc1394_get_image_size_from_video_mode and
+ * dc1394_get_color_coding_from_video_mode do not need to query the
+ * camera, and thus cannot fail. */
+ continue;
+ }
+ dc1394_get_color_coding_from_video_mode (NULL, video_modes.modes[i],
+ &dc1394_color_coding);
+ for (cc = dc1394_color_codings; cc->pix_fmt != PIX_FMT_NONE; cc++)
+ if (cc->coding == dc1394_color_coding)
+ break;
+ if (cc->pix_fmt == PIX_FMT_NONE) {
+ /* We currently cannot handle this color coding. */
+ continue;
+ }
+ /* Here we know that the mode is supported. Get its frame size and the list
+ * of frame rates supported by the camera for this mode. This list is sorted
+ * in ascending order according to libdc1394 example programs. */
+ dc1394_get_image_size_from_video_mode (NULL, video_modes.modes[i],
+ &dc1394_width, &dc1394_height);
+ res = dc1394_video_get_supported_framerates (dc1394->camera, video_modes.modes[i],
+ &frame_rates);
+ if (res != DC1394_SUCCESS || frame_rates.num == 0) {
+ av_log(c, AV_LOG_ERROR, "Cannot get frame rates for video mode.\n");
+ goto out_camera;
+ }
+ /* Choose the best frame rate. */
+ best_rate = -1;
+ for (j = 0; j < frame_rates.num; j++) {
+ for (fr = dc1394_frame_rates; fr->frame_rate; fr++) {
+ if (fr->frame_rate_id == frame_rates.framerates[j]) {
+ break;
+ }
+ }
+ if (!fr->frame_rate) {
+ /* This frame rate is not supported. */
+ continue;
+ }
+ best_rate = fr->frame_rate;
+ frame_rate = fr->frame_rate_id;
+ if (ap->time_base.num && rate == fr->frame_rate) {
+ /* This is the requested frame rate. */
+ break;
+ }
+ }
+ if (best_rate == -1) {
+ /* No supported rate found. */
+ continue;
+ }
+ /* Here we know that both the mode and the rate are supported. Compute score. */
+ if (ap->width && ap->height
+ && (dc1394_width == ap->width && dc1394_height == ap->height)) {
+ score = 110000;
+ } else {
+ score = dc1394_width * 10; // 1600 - 16000
+ }
+ if (ap->pix_fmt == cc->pix_fmt) {
+ score += 90000;
+ } else {
+ score += cc->score; // 1000 - 1500
+ }
+ if (ap->time_base.num && rate == best_rate) {
+ score += 70000;
+ } else {
+ score += best_rate / 1000; // 1 - 240
+ }
+ if (score > max_score) {
+ video_mode = video_modes.modes[i];
+ final_width = dc1394_width;
+ final_height = dc1394_height;
+ final_pix_fmt = cc->pix_fmt;
+ final_frame_rate = best_rate;
+ max_score = score;
+ }
+ }
+ if (max_score == -1) {
+ av_log(c, AV_LOG_ERROR, "No suitable video mode / frame rate available.\n");
+ goto out_camera;
+ }
+ if (ap->width && ap->height && !(ap->width == final_width && ap->height == final_height)) {
+ av_log(c, AV_LOG_WARNING, "Requested frame size is not available, using fallback.\n");
+ }
+ if (ap->pix_fmt != PIX_FMT_NONE && ap->pix_fmt != final_pix_fmt) {
+ av_log(c, AV_LOG_WARNING, "Requested pixel format is not supported, using fallback.\n");
+ }
+ if (ap->time_base.num && rate != final_frame_rate) {
+ av_log(c, AV_LOG_WARNING, "Requested frame rate is not available, using fallback.\n");
}
/* create a video stream */
dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);
dc1394_camera_free (dc1394->camera);
out:
++ av_freep(&dc1394->video_size);
++ av_freep(&dc1394->pixel_format);
dc1394_free(dc1394->d);
- return -1;
+ return ret;
}
-static int dc1394_v2_read_packet(AVFormatContext *c, AVPacket *pkt)
+static int dc1394_read_packet(AVFormatContext *c, AVPacket *pkt)
{
struct dc1394_data *dc1394 = c->priv_data;
int res;
#include "libavutil/imgutils.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
+#include "avdevice.h"
#include "libavutil/parseutils.h"
+ #include "libavutil/pixdesc.h"
static const int desired_video_buffers = 256;
#define OFFSET(x) offsetof(struct video_data, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
+
static const AVOption options[] = {
- { "standard", "", offsetof(struct video_data, standard), FF_OPT_TYPE_STRING, {.str = "NTSC" }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
- { "channel", "", offsetof(struct video_data, channel), FF_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
+ { "standard", "", OFFSET(standard), FF_OPT_TYPE_STRING, {.str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
+ { "channel", "", OFFSET(channel), FF_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
{ "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), FF_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
+ { "pixel_format", "", OFFSET(pixel_format), FF_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
{ NULL },
};
#ifndef AVUTIL_PIXDESC_H
#define AVUTIL_PIXDESC_H
+#include "pixfmt.h"
#include <inttypes.h>
+ #include "pixfmt.h"
typedef struct AVComponentDescriptor{
uint16_t plane :2; ///< which of the 4 planes contains the component
rgb2rgb_init_x86();
}
- void rgb32to24(const uint8_t *src, uint8_t *dst, long src_size)
+#if LIBSWSCALE_VERSION_MAJOR < 1
+void palette8topacked32(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
+{
+ sws_convertPalette8ToPacked32(src, dst, num_pixels, palette);
+}
+
+void palette8topacked24(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
+{
+ sws_convertPalette8ToPacked24(src, dst, num_pixels, palette);
+}
+
+/**
+ * Palette is assumed to contain BGR16, see rgb32to16 to convert the palette.
+ */
+void palette8torgb16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
+{
+ long i;
+ for (i=0; i<num_pixels; i++)
+ ((uint16_t *)dst)[i] = ((const uint16_t *)palette)[src[i]];
+}
+void palette8tobgr16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
+{
+ long i;
+ for (i=0; i<num_pixels; i++)
+ ((uint16_t *)dst)[i] = av_bswap16(((const uint16_t *)palette)[src[i]]);
+}
+#endif
+
+ void rgb32to24(const uint8_t *src, uint8_t *dst, int src_size)
{
- long i;
- long num_pixels = src_size >> 2;
+ int i;
+ int num_pixels = src_size >> 2;
for (i=0; i<num_pixels; i++) {
#if HAVE_BIGENDIAN
/* RGB32 (= A,B,G,R) -> BGR24 (= B,G,R) */
#include "libavutil/avutil.h"
/* A full collection of RGB to RGB(BGR) converters */
- extern void (*rgb24tobgr32)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb32to16) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb32to15) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb15to16) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb15to32) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb16to15) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb16to32) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb24to16) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb24to15) (const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, long src_size);
- extern void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, long src_size);
-
- void rgb24to32 (const uint8_t *src, uint8_t *dst, long src_size);
- void rgb32to24 (const uint8_t *src, uint8_t *dst, long src_size);
- void rgb16tobgr32(const uint8_t *src, uint8_t *dst, long src_size);
- void rgb16to24 (const uint8_t *src, uint8_t *dst, long src_size);
- void rgb16tobgr16(const uint8_t *src, uint8_t *dst, long src_size);
- void rgb16tobgr15(const uint8_t *src, uint8_t *dst, long src_size);
- void rgb15tobgr32(const uint8_t *src, uint8_t *dst, long src_size);
- void rgb15to24 (const uint8_t *src, uint8_t *dst, long src_size);
- void rgb15tobgr16(const uint8_t *src, uint8_t *dst, long src_size);
- void rgb15tobgr15(const uint8_t *src, uint8_t *dst, long src_size);
- void bgr8torgb8 (const uint8_t *src, uint8_t *dst, long src_size);
-
- void shuffle_bytes_0321(const uint8_t *src, uint8_t *dst, long src_size);
- void shuffle_bytes_1230(const uint8_t *src, uint8_t *dst, long src_size);
- void shuffle_bytes_3012(const uint8_t *src, uint8_t *dst, long src_size);
- void shuffle_bytes_3210(const uint8_t *src, uint8_t *dst, long src_size);
+ extern void (*rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb32to16) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb32to15) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb15to16) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb15to32) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb16to15) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb16to32) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb24to16) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb24to15) (const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size);
+ extern void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size);
+
+ void rgb24to32 (const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb32to24 (const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb16to24 (const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb16tobgr15(const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb15to24 (const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size);
+ void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size);
+ void bgr8torgb8 (const uint8_t *src, uint8_t *dst, int src_size);
+
+ void shuffle_bytes_0321(const uint8_t *src, uint8_t *dst, int src_size);
+ void shuffle_bytes_1230(const uint8_t *src, uint8_t *dst, int src_size);
+ void shuffle_bytes_3012(const uint8_t *src, uint8_t *dst, int src_size);
+ void shuffle_bytes_3210(const uint8_t *src, uint8_t *dst, int src_size);
+#if LIBSWSCALE_VERSION_MAJOR < 1
+/* deprecated, use the public versions in swscale.h */
+attribute_deprecated void palette8topacked32(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette);
+attribute_deprecated void palette8topacked24(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette);
+
+/* totally deprecated, please fix code that uses this */
+attribute_deprecated void palette8torgb16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette);
+attribute_deprecated void palette8tobgr16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette);
+#endif
+
+
void rgb24toyv12_c(const uint8_t *src, uint8_t *ydst, uint8_t *udst,
- uint8_t *vdst, long width, long height, long lumStride,
- long chromStride, long srcStride);
+ uint8_t *vdst, int width, int height, int lumStride,
+ int chromStride, int srcStride);
/**
* Height should be a multiple of 2 and width should be a multiple of 16.
}
}
-static inline void rgb48ToY(uint8_t *dst, const uint8_t *src, int width,
- uint32_t *unused)
-{
- int i;
- for (i = 0; i < width; i++) {
- int r = src[i*6+0];
- int g = src[i*6+2];
- int b = src[i*6+4];
-
- dst[i] = (RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
- }
-}
-
-static inline void rgb48ToUV(uint8_t *dstU, uint8_t *dstV,
- 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];
- int g = src1[6*i + 2];
- int b = src1[6*i + 4];
-
- dstU[i] = (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
- dstV[i] = (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
- }
-}
-
-static inline void rgb48ToUV_half(uint8_t *dstU, uint8_t *dstV,
- 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[12*i + 0] + src1[12*i + 6];
- int g= src1[12*i + 2] + src1[12*i + 8];
- int b= src1[12*i + 4] + src1[12*i + 10];
-
- 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 inline void bgr48ToY(uint8_t *dst, const uint8_t *src, int width,
- uint32_t *unused)
-{
- int i;
- for (i = 0; i < width; i++) {
- int b = src[i*6+0];
- int g = src[i*6+2];
- int r = src[i*6+4];
-
- dst[i] = (RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
- }
-}
-
-static inline void bgr48ToUV(uint8_t *dstU, uint8_t *dstV,
- 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];
- int g = src1[6*i + 2];
- int r = src1[6*i + 4];
-
- dstU[i] = (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
- dstV[i] = (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
- }
+#define RGB48(name, R, B, READ)\
- static inline void name ## ToY(int16_t *dst, const uint16_t *src, long width, uint32_t *unused)\
++static inline void name ## ToY(int16_t *dst, const uint16_t *src, int width, uint32_t *unused)\
+{\
+ int i;\
+ for (i = 0; i < width; i++) {\
+ int r = READ(&src[i*3+R]);\
+ int g = READ(&src[i*3+1]);\
+ int b = READ(&src[i*3+B]);\
+\
+ dst[i] = (RY*r + GY*g + BY*b + (32<<(RGB2YUV_SHIFT-1+8)) + (1<<(RGB2YUV_SHIFT-7+8))) >> (RGB2YUV_SHIFT-6+8);\
+ }\
+}\
+\
+static inline void name ## ToUV(int16_t *dstU, int16_t *dstV,\
+ const uint16_t *src1, const uint16_t *src2,\
- long width, uint32_t *unused)\
++ int width, uint32_t *unused)\
+{\
+ int i;\
+ assert(src1==src2);\
+ for (i = 0; i < width; i++) {\
+ int r = READ(&src1[3*i + R]);\
+ int g = READ(&src1[3*i + 1]);\
+ int b = READ(&src1[3*i + B]);\
+\
+ dstU[i] = (RU*r + GU*g + BU*b + (256<<(RGB2YUV_SHIFT-1+8)) + (1<<(RGB2YUV_SHIFT-7+8))) >> (RGB2YUV_SHIFT-6+8);\
+ dstV[i] = (RV*r + GV*g + BV*b + (256<<(RGB2YUV_SHIFT-1+8)) + (1<<(RGB2YUV_SHIFT-7+8))) >> (RGB2YUV_SHIFT-6+8);\
+ }\
+}\
+\
+static inline void name ## ToUV_half(int16_t *dstU, int16_t *dstV,\
+ const uint16_t *src1, const uint16_t *src2,\
- long width, uint32_t *unused)\
++ int width, uint32_t *unused)\
+{\
+ int i;\
+ assert(src1==src2);\
+ for (i = 0; i < width; i++) {\
+ int r= READ(&src1[6*i + R]) + READ(&src1[6*i + 3+R]);\
+ int g= READ(&src1[6*i + 1]) + READ(&src1[6*i + 4]);\
+ int b= READ(&src1[6*i + B]) + READ(&src1[6*i + 3+B]);\
+\
+ dstU[i]= (RU*r + GU*g + BU*b + (256U<<(RGB2YUV_SHIFT+8)) + (1<<(RGB2YUV_SHIFT-6+8))) >> (RGB2YUV_SHIFT-5+8);\
+ dstV[i]= (RV*r + GV*g + BV*b + (256U<<(RGB2YUV_SHIFT+8)) + (1<<(RGB2YUV_SHIFT-6+8))) >> (RGB2YUV_SHIFT-5+8);\
+ }\
}
-static inline void bgr48ToUV_half(uint8_t *dstU, uint8_t *dstV,
- const uint8_t *src1, const uint8_t *src2,
- int width, uint32_t *unused)
-{
- int i;
- for (i = 0; i < width; i++) {
- int b= src1[12*i + 0] + src1[12*i + 6];
- int g= src1[12*i + 2] + src1[12*i + 8];
- int r= src1[12*i + 4] + src1[12*i + 10];
-
- 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);
- }
-}
+RGB48(rgb48LE, 0, 2, AV_RL16)
+RGB48(rgb48BE, 0, 2, AV_RB16)
+RGB48(bgr48LE, 2, 0, AV_RL16)
+RGB48(bgr48BE, 2, 0, AV_RB16)
#define BGR2Y(type, name, shr, shg, shb, maskr, maskg, maskb, RY, GY, BY, S)\
- static inline void name(int16_t *dst, const uint8_t *src, long width, uint32_t *unused)\
-static inline void name(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)\
++static inline void name(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)\
{\
int i;\
for (i=0; i<width; i++) {\
BGR2Y(uint16_t, rgb16ToY, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RY , GY<<5, BY<<11, RGB2YUV_SHIFT+8)
BGR2Y(uint16_t, rgb15ToY, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RY , GY<<5, BY<<10, RGB2YUV_SHIFT+7)
- static inline void abgrToA(int16_t *dst, const uint8_t *src, long width, uint32_t *unused)
-static inline void abgrToA(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
++static inline void abgrToA(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
}
#define BGR2UV(type, name, shr, shg, shb, shp, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S) \
- static inline void name(int16_t *dstU, int16_t *dstV, const uint8_t *src, const uint8_t *dummy, long width, uint32_t *unused)\
-static inline void name(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, const uint8_t *dummy, int width, uint32_t *unused)\
++static inline void name(int16_t *dstU, int16_t *dstV, const uint8_t *src, const uint8_t *dummy, int width, uint32_t *unused)\
{\
int i;\
for (i=0; i<width; i++) {\
int g= ((((const type*)src)[i]>>shp)&maskg)>>shg;\
int r= ((((const type*)src)[i]>>shp)&maskr)>>shr;\
\
- dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<((S)-1)))>>(S);\
- dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<((S)-1)))>>(S);\
+ dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (256<<((S)-1)) + (1<<(S-7)))>>((S)-6);\
+ dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (256<<((S)-1)) + (1<<(S-7)))>>((S)-6);\
}\
}\
- static inline void name ## _half(int16_t *dstU, int16_t *dstV, const uint8_t *src, const uint8_t *dummy, long width, uint32_t *unused)\
-static inline void name ## _half(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, const uint8_t *dummy, int width, uint32_t *unused)\
++static inline void name ## _half(int16_t *dstU, int16_t *dstV, const uint8_t *src, const uint8_t *dummy, int width, uint32_t *unused)\
{\
int i;\
for (i=0; i<width; i++) {\
BGR2UV(uint16_t, rgb16ToUV, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RU , GU<<5, BU<<11, RV , GV<<5, BV<<11, RGB2YUV_SHIFT+8)
BGR2UV(uint16_t, rgb15ToUV, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RU , GU<<5, BU<<10, RV , GV<<5, BV<<10, RGB2YUV_SHIFT+7)
- static inline void palToA(int16_t *dst, const uint8_t *src, long width, uint32_t *pal)
-static inline void palToY(uint8_t *dst, const uint8_t *src, int width, uint32_t *pal)
++static inline void palToA(int16_t *dst, const uint8_t *src, int width, uint32_t *pal)
{
int i;
for (i=0; i<width; i++) {
}
}
-static inline void palToUV(uint8_t *dstU, uint8_t *dstV,
+static inline void palToY(int16_t *dst, const uint8_t *src, long width, uint32_t *pal)
+{
+ int i;
+ for (i=0; i<width; i++) {
+ int d= src[i];
+
+ dst[i]= (pal[d] & 0xFF)<<6;
+ }
+}
+
+static inline void palToUV(uint16_t *dstU, int16_t *dstV,
const uint8_t *src1, const uint8_t *src2,
- long width, uint32_t *pal)
+ int width, uint32_t *pal)
{
int i;
assert(src1 == src2);
}
}
- static inline void monowhite2Y(int16_t *dst, const uint8_t *src, long width, uint32_t *unused)
-static inline void monowhite2Y(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
++static inline void monowhite2Y(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
{
int i, j;
for (i=0; i<width/8; i++) {
}
}
- static inline void monoblack2Y(int16_t *dst, const uint8_t *src, long width, uint32_t *unused)
-static inline void monoblack2Y(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
++static inline void monoblack2Y(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
{
int i, j;
for (i=0; i<width/8; i++) {
}
}
+#if LIBSWSCALE_VERSION_MAJOR < 1
+int sws_scale_ordered(SwsContext *c, const uint8_t* const src[], int srcStride[], int srcSliceY,
+ int srcSliceH, uint8_t* dst[], int dstStride[])
+{
+ return sws_scale(c, src, srcStride, srcSliceY, srcSliceH, dst, dstStride);
+}
+#endif
+
/* Convert the palette to the same packed 32-bit format as the palette */
- void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
+ void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
{
- long i;
+ int i;
for (i=0; i<num_pixels; i++)
((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
void (*hScale)(int16_t *dst, int dstW, const uint8_t *src, int srcW,
int xInc, const int16_t *filter, const int16_t *filterPos,
- long filterSize);
+ int filterSize);
- void (*lumConvertRange)(uint16_t *dst, int width); ///< Color range conversion function for luma plane if needed.
- void (*chrConvertRange)(uint16_t *dst1, uint16_t *dst2, int width); ///< Color range conversion function for chroma planes if needed.
+ void (*hScale16)(int16_t *dst, int dstW, const uint16_t *src, int srcW,
+ int xInc, const int16_t *filter, const int16_t *filterPos,
+ long filterSize, int shift);
+
+ void (*lumConvertRange)(int16_t *dst, int width); ///< Color range conversion function for luma plane if needed.
+ void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width); ///< Color range conversion function for chroma planes if needed.
int lumSrcOffset; ///< Offset given to luma src pointers passed to horizontal input functions.
int chrSrcOffset; ///< Offset given to chroma src pointers passed to horizontal input functions.
}
}
-static inline void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
- const uint8_t *src1, const uint8_t *src2,
- int width, uint32_t *unused)
-{
- nvXXtoUV_c(dstU, dstV, src1, width);
-}
-
-static inline void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
- const uint8_t *src1, const uint8_t *src2,
- int width, uint32_t *unused)
-{
- nvXXtoUV_c(dstV, dstU, src1, width);
-}
-
// FIXME Maybe dither instead.
+#ifndef YUV_NBPS
#define YUV_NBPS(depth, endianness, rfunc) \
static inline void endianness ## depth ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
- const uint8_t *_srcU, const uint8_t *_srcV, \
+ const uint16_t *srcU, const uint16_t *srcV, \
- long width, uint32_t *unused) \
+ int width, uint32_t *unused) \
{ \
int i; \
- const uint16_t *srcU = (const uint16_t*)_srcU; \
- const uint16_t *srcV = (const uint16_t*)_srcV; \
for (i = 0; i < width; i++) { \
dstU[i] = rfunc(&srcU[i])>>(depth-8); \
dstV[i] = rfunc(&srcV[i])>>(depth-8); \
} \
} \
\
- static inline void endianness ## depth ## ToY_c(uint8_t *dstY, const uint16_t *srcY, long width, uint32_t *unused) \
-static inline void endianness ## depth ## ToY_c(uint8_t *dstY, const uint8_t *_srcY, int width, uint32_t *unused) \
++static inline void endianness ## depth ## ToY_c(uint8_t *dstY, const uint16_t *srcY, int width, uint32_t *unused) \
{ \
int i; \
- const uint16_t *srcY = (const uint16_t*)_srcY; \
for (i = 0; i < width; i++) \
dstY[i] = rfunc(&srcY[i])>>(depth-8); \
} \
YUV_NBPS( 9, BE, AV_RB16)
YUV_NBPS(10, LE, AV_RL16)
YUV_NBPS(10, BE, AV_RB16)
+#endif // YUV_NBPS
-static inline void bgr24ToY_c(uint8_t *dst, const uint8_t *src,
+static inline void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
+ const uint8_t *src1, const uint8_t *src2,
- long width, uint32_t *unused)
++ int width, uint32_t *unused)
+{
+ nvXXtoUV_c(dstU, dstV, src1, width);
+}
+
+static inline void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
+ const uint8_t *src1, const uint8_t *src2,
- long width, uint32_t *unused)
++ int width, uint32_t *unused)
+{
+ nvXXtoUV_c(dstV, dstU, src1, width);
+}
+
+static inline void bgr24ToY_c(int16_t *dst, const uint8_t *src,
- long width, uint32_t *unused)
+ int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
}
}
-static inline void bgr24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
+static inline void bgr24ToUV_c(int16_t *dstU, int16_t *dstV, const uint8_t *src1,
- const uint8_t *src2, long width, uint32_t *unused)
+ const uint8_t *src2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
assert(src1 == src2);
}
-static inline void bgr24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
+static inline void bgr24ToUV_half_c(int16_t *dstU, int16_t *dstV, const uint8_t *src1,
- const uint8_t *src2, long width, uint32_t *unused)
+ const uint8_t *src2, int width, uint32_t *unused)
{
int i;
for (i=0; i<width; i++) {
assert(src1 == src2);
}
- static inline void rgb24ToY_c(int16_t *dst, const uint8_t *src, long width,
-static inline void rgb24ToY_c(uint8_t *dst, const uint8_t *src, int width,
++static inline void rgb24ToY_c(int16_t *dst, const uint8_t *src, int width,
uint32_t *unused)
{
int i;
}
}
-static inline void rgb24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
+static inline void rgb24ToUV_c(int16_t *dstU, int16_t *dstV, const uint8_t *src1,
- const uint8_t *src2, long width, uint32_t *unused)
+ const uint8_t *src2, int width, uint32_t *unused)
{
int i;
assert(src1==src2);
}
}
-static inline void rgb24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
+static inline void rgb24ToUV_half_c(int16_t *dstU, int16_t *dstV, const uint8_t *src1,
- const uint8_t *src2, long width, uint32_t *unused)
+ const uint8_t *src2, int width, uint32_t *unused)
{
int i;
assert(src1==src2);
uint8_t *formatConvBuffer,
uint32_t *pal, int isAlpha)
{
- void (*toYV12)(uint8_t *, const uint8_t *, long, uint32_t *) = isAlpha ? c->alpToYV12 : c->lumToYV12;
+ void (*toYV12)(uint8_t *, const uint8_t *, int, uint32_t *) = isAlpha ? c->alpToYV12 : c->lumToYV12;
- void (*convertRange)(uint16_t *, int) = isAlpha ? NULL : c->lumConvertRange;
+ void (*convertRange)(int16_t *, int) = isAlpha ? NULL : c->lumConvertRange;
src += isAlpha ? c->alpSrcOffset : c->lumSrcOffset;
const int16_t *chrUSrc, const int16_t *chrVSrc,
const int16_t *alpSrc,
uint8_t *dest, uint8_t *uDest, uint8_t *vDest,
- uint8_t *aDest, long dstW, long chrDstW)
+ uint8_t *aDest, int dstW, int chrDstW)
{
- long p= 4;
+ int p= 4;
- const uint8_t *src[4]= { alpSrc + dstW, lumSrc + dstW, chrUSrc + chrDstW, chrVSrc + chrDstW };
+ const int16_t *src[4]= { alpSrc + dstW, lumSrc + dstW, chrUSrc + chrDstW, chrVSrc + chrDstW };
uint8_t *dst[4]= { aDest, dest, uDest, vDest };
x86_reg counter[4]= { dstW, dstW, chrDstW, chrDstW };
const int16_t *chrUSrc, const int16_t *chrVSrc,
const int16_t *alpSrc,
uint8_t *dest, uint8_t *uDest, uint8_t *vDest,
- uint8_t *aDest, long dstW, long chrDstW)
+ uint8_t *aDest, int dstW, int chrDstW)
{
- long p= 4;
+ int p= 4;
- const uint8_t *src[4]= { alpSrc + dstW, lumSrc + dstW, chrUSrc + chrDstW, chrVSrc + chrDstW };
+ const int16_t *src[4]= { alpSrc + dstW, lumSrc + dstW, chrUSrc + chrDstW, chrVSrc + chrDstW };
uint8_t *dst[4]= { aDest, dest, uDest, vDest };
x86_reg counter[4]= { dstW, dstW, chrDstW, chrDstW };
}
#endif /* !COMPILE_TEMPLATE_MMX2 */
- static inline void RENAME(bgr24ToY_mmx)(int16_t *dst, const uint8_t *src, long width, enum PixelFormat srcFormat)
-static inline void RENAME(bgr24ToY_mmx)(uint8_t *dst, const uint8_t *src, int width, enum PixelFormat srcFormat)
++static inline void RENAME(bgr24ToY_mmx)(int16_t *dst, const uint8_t *src, int width, enum PixelFormat srcFormat)
{
if(srcFormat == PIX_FMT_BGR24) {
);
}
- static inline void RENAME(bgr24ToUV_mmx)(int16_t *dstU, int16_t *dstV, const uint8_t *src, long width, enum PixelFormat srcFormat)
-static inline void RENAME(bgr24ToUV_mmx)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width, enum PixelFormat srcFormat)
++static inline void RENAME(bgr24ToUV_mmx)(int16_t *dstU, int16_t *dstV, const uint8_t *src, int width, enum PixelFormat srcFormat)
{
__asm__ volatile(
"movq 24(%4), %%mm6 \n\t"
);
}
- static inline void RENAME(bgr24ToY)(int16_t *dst, const uint8_t *src, long width, uint32_t *unused)
-static inline void RENAME(bgr24ToY)(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
++static inline void RENAME(bgr24ToY)(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
{
RENAME(bgr24ToY_mmx)(dst, src, width, PIX_FMT_BGR24);
}
- static inline void RENAME(bgr24ToUV)(int16_t *dstU, int16_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)
-static inline void RENAME(bgr24ToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
++static inline void RENAME(bgr24ToUV)(int16_t *dstU, int16_t *dstV, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
{
RENAME(bgr24ToUV_mmx)(dstU, dstV, src1, width, PIX_FMT_BGR24);
assert(src1 == src2);
}
- static inline void RENAME(rgb24ToY)(int16_t *dst, const uint8_t *src, long width, uint32_t *unused)
-static inline void RENAME(rgb24ToY)(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
++static inline void RENAME(rgb24ToY)(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
{
RENAME(bgr24ToY_mmx)(dst, src, width, PIX_FMT_RGB24);
}
- static inline void RENAME(rgb24ToUV)(int16_t *dstU, int16_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)
-static inline void RENAME(rgb24ToUV)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
++static inline void RENAME(rgb24ToUV)(int16_t *dstU, int16_t *dstV, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
{
assert(src1==src2);
RENAME(bgr24ToUV_mmx)(dstU, dstV, src1, width, PIX_FMT_RGB24);
}
#endif /* !COMPILE_TEMPLATE_MMX2 */
+static inline void RENAME(hScale16)(int16_t *dst, int dstW, const uint16_t *src, int srcW, int xInc,
+ const int16_t *filter, const int16_t *filterPos, long filterSize, int shift)
+{
+ int i, j;
+
+ assert(filterSize % 4 == 0 && filterSize>0);
+ if (filterSize==4 && shift<15) { // Always true for upscaling, sometimes for down, too.
+ x86_reg counter= -2*dstW;
+ filter-= counter*2;
+ filterPos-= counter/2;
+ dst-= counter/2;
+ __asm__ volatile(
+ "movd %5, %%mm7 \n\t"
+#if defined(PIC)
+ "push %%"REG_b" \n\t"
+#endif
+ "push %%"REG_BP" \n\t" // we use 7 regs here ...
+ "mov %%"REG_a", %%"REG_BP" \n\t"
+ ".p2align 4 \n\t"
+ "1: \n\t"
+ "movzwl (%2, %%"REG_BP"), %%eax \n\t"
+ "movzwl 2(%2, %%"REG_BP"), %%ebx \n\t"
+ "movq (%1, %%"REG_BP", 4), %%mm1 \n\t"
+ "movq 8(%1, %%"REG_BP", 4), %%mm3 \n\t"
+ "movq (%3, %%"REG_a", 2), %%mm0 \n\t"
+ "movq (%3, %%"REG_b", 2), %%mm2 \n\t"
+ "pmaddwd %%mm1, %%mm0 \n\t"
+ "pmaddwd %%mm2, %%mm3 \n\t"
+ "movq %%mm0, %%mm4 \n\t"
+ "punpckldq %%mm3, %%mm0 \n\t"
+ "punpckhdq %%mm3, %%mm4 \n\t"
+ "paddd %%mm4, %%mm0 \n\t"
+ "psrad %%mm7, %%mm0 \n\t"
+ "packssdw %%mm0, %%mm0 \n\t"
+ "movd %%mm0, (%4, %%"REG_BP") \n\t"
+ "add $4, %%"REG_BP" \n\t"
+ " jnc 1b \n\t"
+
+ "pop %%"REG_BP" \n\t"
+#if defined(PIC)
+ "pop %%"REG_b" \n\t"
+#endif
+ : "+a" (counter)
+ : "c" (filter), "d" (filterPos), "S" (src), "D" (dst), "m"(shift)
+#if !defined(PIC)
+ : "%"REG_b
+#endif
+ );
+ } else if (filterSize==8 && shift<15) {
+ x86_reg counter= -2*dstW;
+ filter-= counter*4;
+ filterPos-= counter/2;
+ dst-= counter/2;
+ __asm__ volatile(
+ "movd %5, %%mm7 \n\t"
+#if defined(PIC)
+ "push %%"REG_b" \n\t"
+#endif
+ "push %%"REG_BP" \n\t" // we use 7 regs here ...
+ "mov %%"REG_a", %%"REG_BP" \n\t"
+ ".p2align 4 \n\t"
+ "1: \n\t"
+ "movzwl (%2, %%"REG_BP"), %%eax \n\t"
+ "movzwl 2(%2, %%"REG_BP"), %%ebx \n\t"
+ "movq (%1, %%"REG_BP", 8), %%mm1 \n\t"
+ "movq 16(%1, %%"REG_BP", 8), %%mm3 \n\t"
+ "movq (%3, %%"REG_a", 2), %%mm0 \n\t"
+ "movq (%3, %%"REG_b", 2), %%mm2 \n\t"
+ "pmaddwd %%mm1, %%mm0 \n\t"
+ "pmaddwd %%mm2, %%mm3 \n\t"
+
+ "movq 8(%1, %%"REG_BP", 8), %%mm1 \n\t"
+ "movq 24(%1, %%"REG_BP", 8), %%mm5 \n\t"
+ "movq 8(%3, %%"REG_a", 2), %%mm4 \n\t"
+ "movq 8(%3, %%"REG_b", 2), %%mm2 \n\t"
+ "pmaddwd %%mm1, %%mm4 \n\t"
+ "pmaddwd %%mm2, %%mm5 \n\t"
+ "paddd %%mm4, %%mm0 \n\t"
+ "paddd %%mm5, %%mm3 \n\t"
+ "movq %%mm0, %%mm4 \n\t"
+ "punpckldq %%mm3, %%mm0 \n\t"
+ "punpckhdq %%mm3, %%mm4 \n\t"
+ "paddd %%mm4, %%mm0 \n\t"
+ "psrad %%mm7, %%mm0 \n\t"
+ "packssdw %%mm0, %%mm0 \n\t"
+ "movd %%mm0, (%4, %%"REG_BP") \n\t"
+ "add $4, %%"REG_BP" \n\t"
+ " jnc 1b \n\t"
+
+ "pop %%"REG_BP" \n\t"
+#if defined(PIC)
+ "pop %%"REG_b" \n\t"
+#endif
+ : "+a" (counter)
+ : "c" (filter), "d" (filterPos), "S" (src), "D" (dst), "m"(shift)
+#if !defined(PIC)
+ : "%"REG_b
+#endif
+ );
+ } else if (shift<15){
+ const uint16_t *offset = src+filterSize;
+ x86_reg counter= -2*dstW;
+ //filter-= counter*filterSize/2;
+ filterPos-= counter/2;
+ dst-= counter/2;
+ __asm__ volatile(
+ "movd %7, %%mm7 \n\t"
+ ".p2align 4 \n\t"
+ "1: \n\t"
+ "mov %2, %%"REG_c" \n\t"
+ "movzwl (%%"REG_c", %0), %%eax \n\t"
+ "movzwl 2(%%"REG_c", %0), %%edx \n\t"
+ "mov %5, %%"REG_c" \n\t"
+ "pxor %%mm4, %%mm4 \n\t"
+ "pxor %%mm5, %%mm5 \n\t"
+ "2: \n\t"
+ "movq (%1), %%mm1 \n\t"
+ "movq (%1, %6), %%mm3 \n\t"
+ "movq (%%"REG_c", %%"REG_a", 2), %%mm0 \n\t"
+ "movq (%%"REG_c", %%"REG_d", 2), %%mm2 \n\t"
+ "pmaddwd %%mm1, %%mm0 \n\t"
+ "pmaddwd %%mm2, %%mm3 \n\t"
+ "paddd %%mm3, %%mm5 \n\t"
+ "paddd %%mm0, %%mm4 \n\t"
+ "add $8, %1 \n\t"
+ "add $8, %%"REG_c" \n\t"
+ "cmp %4, %%"REG_c" \n\t"
+ " jb 2b \n\t"
+ "add %6, %1 \n\t"
+ "movq %%mm4, %%mm0 \n\t"
+ "punpckldq %%mm5, %%mm4 \n\t"
+ "punpckhdq %%mm5, %%mm0 \n\t"
+ "paddd %%mm0, %%mm4 \n\t"
+ "psrad %%mm7, %%mm4 \n\t"
+ "packssdw %%mm4, %%mm4 \n\t"
+ "mov %3, %%"REG_a" \n\t"
+ "movd %%mm4, (%%"REG_a", %0) \n\t"
+ "add $4, %0 \n\t"
+ " jnc 1b \n\t"
+
+ : "+r" (counter), "+r" (filter)
+ : "m" (filterPos), "m" (dst), "m"(offset),
+ "m" (src), "r" ((x86_reg)filterSize*2), "m"(shift)
+ : "%"REG_a, "%"REG_c, "%"REG_d
+ );
+ } else
+ for (i=0; i<dstW; i++) {
+ int srcPos= filterPos[i];
+ int val=0;
+ for (j=0; j<filterSize; j++) {
+ val += ((int)src[srcPos + j])*filter[filterSize*i + j];
+ }
+ dst[i] = FFMIN(val>>shift, (1<<15)-1); // the cubic equation does overflow ...
+ }
+}
+
+
#if COMPILE_TEMPLATE_MMX2
static inline void RENAME(hyscale_fast)(SwsContext *c, int16_t *dst,
- long dstWidth, const uint8_t *src, int srcW,
+ int dstWidth, const uint8_t *src, int srcW,
int xInc)
{
int32_t *filterPos = c->hLumFilterPos;