SwsContext *GetSwsContext(int SrcW, int SrcH, AVPixelFormat SrcFormat, int SrcColorSpace, int SrcColorRange, int DstW, int DstH, AVPixelFormat DstFormat, int DstColorSpace, int DstColorRange, int64_t Flags) {
Flags |= SWS_FULL_CHR_H_INT | SWS_FULL_CHR_H_INP | SWS_ACCURATE_RND;
SwsContext *Context = sws_alloc_context();
if (!Context) return nullptr;
// 0 = limited range, 1 = full range
int SrcRange = SrcColorRange == AVCOL_RANGE_JPEG;
int DstRange = DstColorRange == AVCOL_RANGE_JPEG;
av_opt_set_int(Context, "sws_flags", Flags, 0);
av_opt_set_int(Context, "srcw", SrcW, 0);
av_opt_set_int(Context, "srch", SrcH, 0);
av_opt_set_int(Context, "dstw", DstW, 0);
av_opt_set_int(Context, "dsth", DstH, 0);
av_opt_set_int(Context, "src_range", SrcRange, 0);
av_opt_set_int(Context, "dst_range", DstRange, 0);
av_opt_set_int(Context, "src_format", SrcFormat, 0);
av_opt_set_int(Context, "dst_format", DstFormat, 0);
sws_setColorspaceDetails(Context,
sws_getCoefficients(SrcColorSpace), SrcRange,
sws_getCoefficients(DstColorSpace), DstRange,
0, 1<<16, 1<<16);
if(sws_init_context(Context, nullptr, nullptr) < 0){
sws_freeContext(Context);
return nullptr;
}
return Context;
}
static bool mp_media_init_scaling(mp_media_t *m)
{
int space = get_sws_colorspace(m->v.decoder->colorspace);
int range = get_sws_range(m->v.decoder->color_range);
const int *coeff = sws_getCoefficients(space);
m->swscale = sws_getCachedContext(NULL,
m->v.decoder->width, m->v.decoder->height,
m->v.decoder->pix_fmt,
m->v.decoder->width, m->v.decoder->height,
m->scale_format,
SWS_FAST_BILINEAR, NULL, NULL, NULL);
if (!m->swscale) {
blog(LOG_WARNING, "MP: Failed to initialize scaler");
return false;
}
sws_setColorspaceDetails(m->swscale, coeff, range, coeff, range, 0,
FIXED_1_0, FIXED_1_0);
int ret = av_image_alloc(m->scale_pic, m->scale_linesizes,
m->v.decoder->width, m->v.decoder->height,
m->scale_format, 1);
if (ret < 0) {
blog(LOG_WARNING, "MP: Failed to create scale pic data");
return false;
}
return true;
}
bool ImageConverterFFPrivate::setupColorspaceDetails(bool force)
{
if (!sws_ctx) {
update_eq = true;
return false;
}
if (force)
update_eq = true;
if (!update_eq) {
return true;
}
const int srcRange = range_in == ColorRange_Limited ? 0 : 1;
int dstRange = range_out == ColorRange_Limited ? 0 : 1;
// TODO: color space
bool supported = sws_setColorspaceDetails(sws_ctx, sws_getCoefficients(SWS_CS_DEFAULT)
, srcRange, sws_getCoefficients(SWS_CS_DEFAULT)
, dstRange
, ((brightness << 16) + 50)/100
, (((contrast + 100) << 16) + 50)/100
, (((saturation + 100) << 16) + 50)/100
) >= 0;
//sws_init_context(d.sws_ctx, NULL, NULL);
update_eq = false;
return supported;
}
bool ImageConverterFF::setupColorspaceDetails()
{
DPTR_D(ImageConverterFF);
if (!d.sws_ctx) {
d.update_eq = true;
return false;
}
//if (!d.update_eq)
// return true;
// FIXME: how to fill the ranges?
const int srcRange = 1;
const int dstRange = 0;
// TODO: SWS_CS_DEFAULT?
sws_setColorspaceDetails(d.sws_ctx, sws_getCoefficients(SWS_CS_DEFAULT)
, srcRange, sws_getCoefficients(SWS_CS_DEFAULT)
, dstRange
, ((d.brightness << 16) + 50)/100
, (((d.contrast + 100) << 16) + 50)/100
, (((d.saturation + 100) << 16) + 50)/100
);
// TODO: b, c, s map function?
//sws_init_context(d.sws_ctx, NULL, NULL);
d.update_eq = false;
return true;
}
static void set_luma_transfer( struct SwsContext *context, int colorspace, int use_full_range )
{
int *coefficients;
const int *new_coefficients;
int full_range;
int brightness, contrast, saturation;
if ( sws_getColorspaceDetails( context, &coefficients, &full_range, &coefficients, &full_range,
&brightness, &contrast, &saturation ) != -1 )
{
// Don't change these from defaults unless explicitly told to.
if ( use_full_range >= 0 )
full_range = use_full_range;
switch ( colorspace )
{
case 170:
case 470:
case 601:
case 624:
new_coefficients = sws_getCoefficients( SWS_CS_ITU601 );
break;
case 240:
new_coefficients = sws_getCoefficients( SWS_CS_SMPTE240M );
break;
case 709:
new_coefficients = sws_getCoefficients( SWS_CS_ITU709 );
break;
default:
new_coefficients = coefficients;
break;
}
sws_setColorspaceDetails( context, new_coefficients, full_range, new_coefficients, full_range,
brightness, contrast, saturation );
}
}
bool ImageConverterFFPrivate::setupColorspaceDetails(bool force)
{
if (!sws_ctx) {
update_eq = true;
return false;
}
if (force)
update_eq = true;
if (!update_eq) {
return true;
}
// FIXME: how to fill the ranges?
const int srcRange = 1;
const int dstRange = 0;
// TODO: SWS_CS_DEFAULT?
bool supported = sws_setColorspaceDetails(sws_ctx, sws_getCoefficients(SWS_CS_DEFAULT)
, srcRange, sws_getCoefficients(SWS_CS_DEFAULT)
, dstRange
, ((brightness << 16) + 50)/100
, (((contrast + 100) << 16) + 50)/100
, (((saturation + 100) << 16) + 50)/100
) >= 0;
//sws_init_context(d.sws_ctx, NULL, NULL);
update_eq = false;
return supported;
}
void MovieDecoder::convertAndScaleFrame(PixelFormat format, int scaledSize, bool maintainAspectRatio, int& scaledWidth, int& scaledHeight)
{
calculateDimensions(scaledSize, maintainAspectRatio, scaledWidth, scaledHeight);
#ifdef LATEST_GREATEST_FFMPEG
// Enable this when it hits the released ffmpeg version
SwsContext* scaleContext = sws_alloc_context();
if (scaleContext == nullptr)
{
throw std::logic_error("Failed to allocate scale context");
}
av_set_int(scaleContext, "srcw", m_pVideoCodecContext->width);
av_set_int(scaleContext, "srch", m_pVideoCodecContext->height);
av_set_int(scaleContext, "src_format", m_pVideoCodecContext->pix_fmt);
av_set_int(scaleContext, "dstw", scaledWidth);
av_set_int(scaleContext, "dsth", scaledHeight);
av_set_int(scaleContext, "dst_format", format);
av_set_int(scaleContext, "sws_flags", SWS_BICUBIC);
const int* coeff = sws_getCoefficients(SWS_CS_DEFAULT);
if (sws_setColorspaceDetails(scaleContext, coeff, m_pVideoCodecContext->pix_fmt, coeff, format, 0, 1<<16, 1<<16) < 0)
{
sws_freeContext(scaleContext);
throw std::logic_error("Failed to set colorspace details");
}
if (sws_init_context(scaleContext, nullptr, nullptr) < 0)
{
sws_freeContext(scaleContext);
throw std::logic_error("Failed to initialise scale context");
}
#endif
SwsContext* scaleContext = sws_getContext(m_pVideoCodecContext->width, m_pVideoCodecContext->height,
m_pVideoCodecContext->pix_fmt, scaledWidth, scaledHeight,
format, SWS_BICUBIC, nullptr, nullptr, nullptr);
if (nullptr == scaleContext)
{
throw logic_error("Failed to create resize context");
}
AVFrame* convertedFrame = nullptr;
uint8_t* convertedFrameBuffer = nullptr;
createAVFrame(&convertedFrame, &convertedFrameBuffer, scaledWidth, scaledHeight, format);
sws_scale(scaleContext, m_pFrame->data, m_pFrame->linesize, 0, m_pVideoCodecContext->height,
convertedFrame->data, convertedFrame->linesize);
sws_freeContext(scaleContext);
av_free(m_pFrame);
av_free(m_pFrameBuffer);
m_pFrame = convertedFrame;
m_pFrameBuffer = convertedFrameBuffer;
}
int video_scaler_create(video_scaler_t **scaler_out,
const struct video_scale_info *dst,
const struct video_scale_info *src,
enum video_scale_type type)
{
enum AVPixelFormat format_src = get_ffmpeg_video_format(src->format);
enum AVPixelFormat format_dst = get_ffmpeg_video_format(dst->format);
int scale_type = get_ffmpeg_scale_type(type);
const int *coeff_src = get_ffmpeg_coeffs(src->colorspace);
const int *coeff_dst = get_ffmpeg_coeffs(dst->colorspace);
int range_src = get_ffmpeg_range_type(src->range);
int range_dst = get_ffmpeg_range_type(dst->range);
struct video_scaler *scaler;
int ret;
if (!scaler_out)
return VIDEO_SCALER_FAILED;
if (format_src == AV_PIX_FMT_NONE ||
format_dst == AV_PIX_FMT_NONE)
return VIDEO_SCALER_BAD_CONVERSION;
scaler = bzalloc(sizeof(struct video_scaler));
scaler->src_height = src->height;
scaler->swscale = sws_getCachedContext(NULL,
src->width, src->height, format_src,
dst->width, dst->height, format_dst,
scale_type, NULL, NULL, NULL);
if (!scaler->swscale) {
blog(LOG_ERROR, "video_scaler_create: Could not create "
"swscale");
goto fail;
}
ret = sws_setColorspaceDetails(scaler->swscale,
coeff_src, range_src,
coeff_dst, range_dst,
0, FIXED_1_0, FIXED_1_0);
if (ret < 0) {
blog(LOG_DEBUG, "video_scaler_create: "
"sws_setColorspaceDetails failed, ignoring");
}
*scaler_out = scaler;
return VIDEO_SCALER_SUCCESS;
fail:
video_scaler_destroy(scaler);
return VIDEO_SCALER_FAILED;
}
int mlt_set_luma_transfer( struct SwsContext *context, int src_colorspace,
int dst_colorspace, int src_full_range, int dst_full_range )
{
const int *src_coefficients = sws_getCoefficients( SWS_CS_DEFAULT );
const int *dst_coefficients = sws_getCoefficients( SWS_CS_DEFAULT );
int brightness = 0;
int contrast = 1 << 16;
int saturation = 1 << 16;
int src_range = src_full_range ? 1 : 0;
int dst_range = dst_full_range ? 1 : 0;
switch ( src_colorspace )
{
case 170:
case 470:
case 601:
case 624:
src_coefficients = sws_getCoefficients( SWS_CS_ITU601 );
break;
case 240:
src_coefficients = sws_getCoefficients( SWS_CS_SMPTE240M );
break;
case 709:
src_coefficients = sws_getCoefficients( SWS_CS_ITU709 );
break;
default:
break;
}
switch ( dst_colorspace )
{
case 170:
case 470:
case 601:
case 624:
dst_coefficients = sws_getCoefficients( SWS_CS_ITU601 );
break;
case 240:
dst_coefficients = sws_getCoefficients( SWS_CS_SMPTE240M );
break;
case 709:
dst_coefficients = sws_getCoefficients( SWS_CS_ITU709 );
break;
default:
break;
}
return sws_setColorspaceDetails( context, src_coefficients, src_range, dst_coefficients, dst_range,
brightness, contrast, saturation );
}
struct SwsContext *update_scaler_configuration
(
struct SwsContext *sws_ctx,
int flags,
int width,
int height,
enum AVPixelFormat input_pixel_format,
enum AVPixelFormat output_pixel_format,
enum AVColorSpace colorspace,
int yuv_range
)
{
if( sws_ctx )
sws_freeContext( sws_ctx );
sws_ctx = sws_alloc_context();
if( !sws_ctx )
return NULL;
av_opt_set_int( sws_ctx, "sws_flags", flags, 0 );
av_opt_set_int( sws_ctx, "srcw", width, 0 );
av_opt_set_int( sws_ctx, "srch", height, 0 );
av_opt_set_int( sws_ctx, "dstw", width, 0 );
av_opt_set_int( sws_ctx, "dsth", height, 0 );
av_opt_set_int( sws_ctx, "src_format", input_pixel_format, 0 );
av_opt_set_int( sws_ctx, "dst_format", output_pixel_format, 0 );
const int *yuv2rgb_coeffs = sws_getCoefficients( colorspace );
sws_setColorspaceDetails( sws_ctx,
yuv2rgb_coeffs, yuv_range,
yuv2rgb_coeffs, yuv_range,
0, 1 << 16, 1 << 16 );
if( sws_init_context( sws_ctx, NULL, NULL ) < 0 )
{
sws_freeContext( sws_ctx );
return NULL;
}
return sws_ctx;
}
SwsContext *FFGetSwsContext(int SrcW, int SrcH, PixelFormat SrcFormat, int DstW, int DstH, PixelFormat DstFormat, int64_t Flags, int ColorSpace, int ColorRange) {
Flags |= SWS_FULL_CHR_H_INT | SWS_FULL_CHR_H_INP;
#if LIBSWSCALE_VERSION_INT < AV_VERSION_INT(0, 12, 0)
return sws_getContext(SrcW, SrcH, SrcFormat, DstW, DstH, DstFormat, Flags, 0, 0, 0);
#else
SwsContext *Context = sws_alloc_context();
if (!Context) return 0;
// The intention here is to never change the color range.
int Range; // 0 = limited range, 1 = full range
if (ColorRange == AVCOL_RANGE_JPEG)
Range = 1;
else // explicit limited range, or unspecified
Range = 0;
av_opt_set_int(Context, "sws_flags", Flags, 0);
av_opt_set_int(Context, "srcw", SrcW, 0);
av_opt_set_int(Context, "srch", SrcH, 0);
av_opt_set_int(Context, "dstw", DstW, 0);
av_opt_set_int(Context, "dsth", DstH, 0);
av_opt_set_int(Context, "src_range", Range, 0);
av_opt_set_int(Context, "dst_range", Range, 0);
av_opt_set_int(Context, "src_format", SrcFormat, 0);
av_opt_set_int(Context, "dst_format", DstFormat, 0);
sws_setColorspaceDetails(Context, sws_getCoefficients(ColorSpace), Range, sws_getCoefficients(ColorSpace), Range, 0, 1<<16, 1<<16);
if(sws_init_context(Context, 0, 0) < 0){
sws_freeContext(Context);
return 0;
}
return Context;
#endif
}
SwsContext *GetSwsContext(int SrcW, int SrcH, PixelFormat SrcFormat, int SrcColorSpace, int SrcColorRange, int DstW, int DstH, PixelFormat DstFormat, int DstColorSpace, int DstColorRange, int64_t Flags) {
Flags |= SWS_FULL_CHR_H_INT | SWS_FULL_CHR_H_INP;
#if LIBSWSCALE_VERSION_INT < AV_VERSION_INT(0, 12, 0)
return sws_getContext(SrcW, SrcH, SrcFormat, DstW, DstH, DstFormat, Flags, 0, 0, 0);
#else
SwsContext *Context = sws_alloc_context();
if (!Context) return 0;
// 0 = limited range, 1 = full range
int SrcRange = SrcColorRange == AVCOL_RANGE_JPEG;
int DstRange = DstColorRange == AVCOL_RANGE_JPEG;
av_opt_set_int(Context, "sws_flags", Flags, 0);
av_opt_set_int(Context, "srcw", SrcW, 0);
av_opt_set_int(Context, "srch", SrcH, 0);
av_opt_set_int(Context, "dstw", DstW, 0);
av_opt_set_int(Context, "dsth", DstH, 0);
av_opt_set_int(Context, "src_range", SrcRange, 0);
av_opt_set_int(Context, "dst_range", DstRange, 0);
av_opt_set_int(Context, "src_format", SrcFormat, 0);
av_opt_set_int(Context, "dst_format", DstFormat, 0);
sws_setColorspaceDetails(Context,
sws_getCoefficients(SrcColorSpace), SrcRange,
sws_getCoefficients(DstColorSpace), DstRange,
0, 1<<16, 1<<16);
if(sws_init_context(Context, 0, 0) < 0) {
sws_freeContext(Context);
return 0;
}
return Context;
#endif
}
void MediaEngine::updateSwsFormat(int videoPixelMode) {
#ifdef USE_FFMPEG
auto codecIter = m_pCodecCtxs.find(m_videoStream);
AVCodecContext *m_pCodecCtx = codecIter == m_pCodecCtxs.end() ? 0 : codecIter->second;
AVPixelFormat swsDesired = getSwsFormat(videoPixelMode);
if (swsDesired != m_sws_fmt && m_pCodecCtx != 0) {
m_sws_fmt = swsDesired;
m_sws_ctx = sws_getCachedContext
(
m_sws_ctx,
m_pCodecCtx->width,
m_pCodecCtx->height,
m_pCodecCtx->pix_fmt,
m_desWidth,
m_desHeight,
(AVPixelFormat)m_sws_fmt,
SWS_BILINEAR,
NULL,
NULL,
NULL
);
int *inv_coefficients;
int *coefficients;
int srcRange, dstRange;
int brightness, contrast, saturation;
if (sws_getColorspaceDetails(m_sws_ctx, &inv_coefficients, &srcRange, &coefficients, &dstRange, &brightness, &contrast, &saturation) != -1) {
srcRange = 0;
dstRange = 0;
sws_setColorspaceDetails(m_sws_ctx, inv_coefficients, srcRange, coefficients, dstRange, brightness, contrast, saturation);
}
}
#endif
}
void BenchmarkScale(unsigned int in_w, unsigned int in_h, unsigned int out_w, unsigned int out_h) {
std::mt19937 rng(12345);
#if SSR_USE_X86_ASM
bool use_ssse3 = (CPUFeatures::HasMMX() && CPUFeatures::HasSSE() && CPUFeatures::HasSSE2() && CPUFeatures::HasSSE3() && CPUFeatures::HasSSSE3());
#endif
// the queue needs to use enough memory to make sure that the CPU cache is flushed
unsigned int pixels = std::max(in_w * in_h, out_w * out_h);
unsigned int queue_size = 1 + 20000000 / pixels;
unsigned int run_size = queue_size * 20;
// create queue
std::vector<std::unique_ptr<ImageGeneric> > queue_in(queue_size);
std::vector<std::unique_ptr<ImageGeneric> > queue_out(queue_size);
for(unsigned int i = 0; i < queue_size; ++i) {
queue_in[i] = NewImageBGRA(in_w, in_h, rng);
queue_out[i] = NewImageBGRA(out_w, out_h, rng);
}
// run test
unsigned int time_swscale = 0, time_fallback = 0, time_ssse3 = 0;
{
SwsContext *sws = sws_getCachedContext(NULL,
in_w, in_h, AV_PIX_FMT_BGRA,
out_w, out_h, AV_PIX_FMT_BGRA,
SWS_BILINEAR, NULL, NULL, NULL);
if(sws == NULL) {
Logger::LogError("[BenchmarkScale] " + Logger::tr("Error: Can't get swscale context!", "Don't translate 'swscale'"));
throw LibavException();
}
sws_setColorspaceDetails(sws,
sws_getCoefficients(SWS_CS_ITU709), 0,
sws_getCoefficients(SWS_CS_DEFAULT), 0,
0, 1 << 16, 1 << 16);
int64_t t1 = hrt_time_micro();
for(unsigned int i = 0; i < run_size / 2; ++i) {
unsigned int ii = i % queue_size;
sws_scale(sws, queue_in[ii]->m_data.data(), queue_in[ii]->m_stride.data(), 0, in_h, queue_out[ii]->m_data.data(), queue_out[ii]->m_stride.data());
}
int64_t t2 = hrt_time_micro();
time_swscale = (t2 - t1) / (run_size / 2);
}
{
int64_t t1 = hrt_time_micro();
for(unsigned int i = 0; i < run_size; ++i) {
unsigned int ii = i % queue_size;
Scale_BGRA_Fallback(in_w, in_h, queue_in[ii]->m_data[0], queue_in[ii]->m_stride[0],
out_w, out_h, queue_out[ii]->m_data[0], queue_out[ii]->m_stride[0]);
}
int64_t t2 = hrt_time_micro();
time_fallback = (t2 - t1) / run_size;
}
#if SSR_USE_X86_ASM
if(use_ssse3) {
int64_t t1 = hrt_time_micro();
for(unsigned int i = 0; i < run_size; ++i) {
unsigned int ii = i % queue_size;
Scale_BGRA_SSSE3(in_w, in_h, queue_in[ii]->m_data[0], queue_in[ii]->m_stride[0],
out_w, out_h, queue_out[ii]->m_data[0], queue_out[ii]->m_stride[0]);
}
int64_t t2 = hrt_time_micro();
time_ssse3 = (t2 - t1) / run_size;
}
#endif
// print result
QString in_size = QString("%1x%2").arg(in_w).arg(in_h);
QString out_size = QString("%1x%2").arg(out_w).arg(out_h);
Logger::LogInfo("[BenchmarkScale] " + Logger::tr("BGRA %1 to BGRA %2 | SWScale %3 us | Fallback %4 us (%5%) | SSSE3 %6 us (%7%)")
.arg(in_size, 9).arg(out_size, 9)
.arg(time_swscale, 6)
.arg(time_fallback, 6).arg(100 * time_fallback / time_swscale, 3)
.arg(time_ssse3, 6).arg(100 * time_ssse3 / time_fallback, 3));
}
void BenchmarkConvert(unsigned int w, unsigned int h, PixelFormat in_format, PixelFormat out_format, const QString& in_format_name, const QString& out_format_name, NewImageFunc in_image, NewImageFunc out_image, ConvertFunc fallback
#if SSR_USE_X86_ASM
, ConvertFunc ssse3
#endif
) {
std::mt19937 rng(12345);
#if SSR_USE_X86_ASM
bool use_ssse3 = (CPUFeatures::HasMMX() && CPUFeatures::HasSSE() && CPUFeatures::HasSSE2() && CPUFeatures::HasSSE3() && CPUFeatures::HasSSSE3());
#endif
// the queue needs to use enough memory to make sure that the CPU cache is flushed
unsigned int pixels = w * h;
unsigned int queue_size = 1 + 20000000 / pixels;
unsigned int run_size = queue_size * 20;
// create queue
std::vector<std::unique_ptr<ImageGeneric> > queue_in(queue_size);
std::vector<std::unique_ptr<ImageGeneric> > queue_out(queue_size);
for(unsigned int i = 0; i < queue_size; ++i) {
queue_in[i] = in_image(w, h, rng);
queue_out[i] = out_image(w, h, rng);
}
// run test
unsigned int time_swscale = 0, time_fallback = 0, time_ssse3 = 0;
{
SwsContext *sws = sws_getCachedContext(NULL,
w, h, in_format,
w, h, out_format,
SWS_BILINEAR, NULL, NULL, NULL);
if(sws == NULL) {
Logger::LogError("[BenchmarkScale] " + Logger::tr("Error: Can't get swscale context!", "Don't translate 'swscale'"));
throw LibavException();
}
sws_setColorspaceDetails(sws,
sws_getCoefficients(SWS_CS_ITU709), 0,
sws_getCoefficients(SWS_CS_DEFAULT), 0,
0, 1 << 16, 1 << 16);
int64_t t1 = hrt_time_micro();
for(unsigned int i = 0; i < run_size / 2; ++i) {
unsigned int ii = i % queue_size;
sws_scale(sws, queue_in[ii]->m_data.data(), queue_in[ii]->m_stride.data(), 0, h, queue_out[ii]->m_data.data(), queue_out[ii]->m_stride.data());
}
int64_t t2 = hrt_time_micro();
time_swscale = (t2 - t1) / (run_size / 2);
}
{
int64_t t1 = hrt_time_micro();
for(unsigned int i = 0; i < run_size; ++i) {
unsigned int ii = i % queue_size;
fallback(w, h, queue_in[ii]->m_data[0], queue_in[ii]->m_stride[0], queue_out[ii]->m_data.data(), queue_out[ii]->m_stride.data());
}
int64_t t2 = hrt_time_micro();
time_fallback = (t2 - t1) / run_size;
}
#if SSR_USE_X86_ASM
if(use_ssse3) {
int64_t t1 = hrt_time_micro();
for(unsigned int i = 0; i < run_size; ++i) {
unsigned int ii = i % queue_size;
ssse3(w, h, queue_in[ii]->m_data[0], queue_in[ii]->m_stride[0], queue_out[ii]->m_data.data(), queue_out[ii]->m_stride.data());
}
int64_t t2 = hrt_time_micro();
time_ssse3 = (t2 - t1) / run_size;
}
#endif
// print result
QString size = QString("%1x%2").arg(w).arg(h);
Logger::LogInfo("[BenchmarkConvert] " + Logger::tr("%1 %2 to %3 %4 | SWScale %5 us | Fallback %6 us (%7%) | SSSE3 %8 us (%9%)")
.arg(in_format_name, 6).arg(size, 9).arg(out_format_name, 6).arg(size, 9)
.arg(time_swscale, 6)
.arg(time_fallback, 6).arg(100 * time_fallback / time_swscale, 3)
.arg(time_ssse3, 6).arg(100 * time_ssse3 / time_fallback, 3));
}
bool CFFmpegImage::CreateThumbnailFromSurface(unsigned char* bufferin, unsigned int width,
unsigned int height, unsigned int format,
unsigned int pitch,
const std::string& destFile,
unsigned char* &bufferout,
unsigned int &bufferoutSize)
{
// It seems XB_FMT_A8R8G8B8 mean RGBA and not ARGB
if (format != XB_FMT_A8R8G8B8)
{
CLog::Log(LOGERROR, "Supplied format: %d is not supported.", format);
return false;
}
bool jpg_output = false;
if (m_strMimeType == "image/jpeg" || m_strMimeType == "image/jpg")
jpg_output = true;
else if (m_strMimeType == "image/png")
jpg_output = false;
else
{
CLog::Log(LOGERROR, "Output Format is not supported: %s is not supported.", destFile.c_str());
return false;
}
ThumbDataManagement tdm;
tdm.codec = avcodec_find_encoder(jpg_output ? AV_CODEC_ID_MJPEG : AV_CODEC_ID_PNG);
if (!tdm.codec)
{
CLog::Log(LOGERROR, "Your are missing a working encoder for format: %d", jpg_output ? AV_CODEC_ID_MJPEG : AV_CODEC_ID_PNG);
return false;
}
tdm.avOutctx = avcodec_alloc_context3(tdm.codec);
if (!tdm.avOutctx)
{
CLog::Log(LOGERROR, "Could not allocate context for thumbnail: %s", destFile.c_str());
return false;
}
tdm.avOutctx->height = height;
tdm.avOutctx->width = width;
tdm.avOutctx->time_base.num = 1;
tdm.avOutctx->time_base.den = 1;
tdm.avOutctx->pix_fmt = jpg_output ? AV_PIX_FMT_YUVJ420P : AV_PIX_FMT_RGBA;
tdm.avOutctx->flags = CODEC_FLAG_QSCALE;
tdm.avOutctx->mb_lmin = tdm.avOutctx->qmin * FF_QP2LAMBDA;
tdm.avOutctx->mb_lmax = tdm.avOutctx->qmax * FF_QP2LAMBDA;
tdm.avOutctx->global_quality = tdm.avOutctx->qmin * FF_QP2LAMBDA;
unsigned int internalBufOutSize = 0;
int size = avpicture_get_size(tdm.avOutctx->pix_fmt, tdm.avOutctx->width, tdm.avOutctx->height);
if (size < 0)
{
CLog::Log(LOGERROR, "Could not compute picture size for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
internalBufOutSize = (unsigned int) size;
m_outputBuffer = (uint8_t*) av_malloc(internalBufOutSize);
if (!m_outputBuffer)
{
CLog::Log(LOGERROR, "Could not generate allocate memory for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
tdm.intermediateBuffer = (uint8_t*) av_malloc(internalBufOutSize);
if (!tdm.intermediateBuffer)
{
CLog::Log(LOGERROR, "Could not allocate memory for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
if (avcodec_open2(tdm.avOutctx, tdm.codec, NULL) < 0)
{
CLog::Log(LOGERROR, "Could not open avcodec context thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
tdm.frame_input = av_frame_alloc();
if (!tdm.frame_input)
{
CLog::Log(LOGERROR, "Could not allocate frame for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
// convert the RGB32 frame to AV_PIX_FMT_YUV420P - we use this later on as AV_PIX_FMT_YUVJ420P
tdm.frame_temporary = av_frame_alloc();
if (!tdm.frame_temporary)
{
CLog::Log(LOGERROR, "Could not allocate frame for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
if (avpicture_fill((AVPicture*)tdm.frame_temporary, tdm.intermediateBuffer, jpg_output ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_RGBA, width, height) < 0)
{
CLog::Log(LOGERROR, "Could not fill picture for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
uint8_t* src[] = { bufferin, NULL, NULL, NULL };
int srcStride[] = { (int) pitch, 0, 0, 0};
//input size == output size which means only pix_fmt conversion
tdm.sws = sws_getContext(width, height, AV_PIX_FMT_RGB32, width, height, jpg_output ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_RGBA, 0, 0, 0, 0);
if (!tdm.sws)
{
CLog::Log(LOGERROR, "Could not setup scaling context for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
// Setup jpeg range for sws
if (jpg_output)
{
int* inv_table = nullptr;
int* table = nullptr;
int srcRange, dstRange, brightness, contrast, saturation;
if (sws_getColorspaceDetails(tdm.sws, &inv_table, &srcRange, &table, &dstRange, &brightness, &contrast, &saturation) < 0)
{
CLog::Log(LOGERROR, "SWS_SCALE failed to get ColorSpaceDetails for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
dstRange = 1; // jpeg full range yuv420p output
srcRange = 0; // full range RGB32 input
if (sws_setColorspaceDetails(tdm.sws, inv_table, srcRange, table, dstRange, brightness, contrast, saturation) < 0)
{
CLog::Log(LOGERROR, "SWS_SCALE failed to set ColorSpace Details for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
}
if (sws_scale(tdm.sws, src, srcStride, 0, height, tdm.frame_temporary->data, tdm.frame_temporary->linesize) < 0)
{
CLog::Log(LOGERROR, "SWS_SCALE failed for thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
tdm.frame_input->pts = 1;
tdm.frame_input->quality = tdm.avOutctx->global_quality;
tdm.frame_input->data[0] = (uint8_t*) tdm.frame_temporary->data[0];
tdm.frame_input->data[1] = (uint8_t*) tdm.frame_temporary->data[1];
tdm.frame_input->data[2] = (uint8_t*) tdm.frame_temporary->data[2];
tdm.frame_input->height = height;
tdm.frame_input->width = width;
tdm.frame_input->linesize[0] = tdm.frame_temporary->linesize[0];
tdm.frame_input->linesize[1] = tdm.frame_temporary->linesize[1];
tdm.frame_input->linesize[2] = tdm.frame_temporary->linesize[2];
// this is deprecated but mjpeg is not yet transitioned
tdm.frame_input->format = jpg_output ? AV_PIX_FMT_YUVJ420P : AV_PIX_FMT_RGBA;
int got_package = 0;
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = m_outputBuffer;
avpkt.size = internalBufOutSize;
if ((avcodec_encode_video2(tdm.avOutctx, &avpkt, tdm.frame_input, &got_package) < 0) || (got_package == 0))
{
CLog::Log(LOGERROR, "Could not encode thumbnail: %s", destFile.c_str());
CleanupLocalOutputBuffer();
return false;
}
bufferoutSize = avpkt.size;
bufferout = m_outputBuffer;
return true;
}
bool CFFmpegImage::Decode(unsigned char * const pixels, unsigned int width, unsigned int height,
unsigned int pitch, unsigned int format)
{
if (m_width == 0 || m_height == 0 || format != XB_FMT_A8R8G8B8)
return false;
if (!m_pFrame || !m_pFrame->data[0])
{
CLog::LogFunction(LOGERROR, __FUNCTION__, "AVFrame member not allocated");
return false;
}
AVPicture* pictureRGB = static_cast<AVPicture*>(av_mallocz(sizeof(AVPicture)));
if (!pictureRGB)
{
CLog::LogFunction(LOGERROR, __FUNCTION__, "AVPicture could not be allocated");
return false;
}
int size = avpicture_fill(pictureRGB, NULL, AV_PIX_FMT_RGB32, width, height);
if (size < 0)
{
CLog::LogFunction(LOGERROR, __FUNCTION__, "Could not allocate AVPicture member with %i x %i pixes", width, height);
av_free(pictureRGB);
return false;
}
bool needsCopy = false;
int pixelsSize = pitch * height;
if (size == pixelsSize && (int) pitch == pictureRGB->linesize[0])
{
// We can use the pixels buffer directly
pictureRGB->data[0] = pixels;
}
else
{
// We need an extra buffer and copy it manually afterwards
if (avpicture_alloc(pictureRGB, AV_PIX_FMT_RGB32, width, height) < 0)
{
CLog::LogFunction(LOGERROR, __FUNCTION__, "Could not allocate temp buffer of size %i bytes", size);
av_free(pictureRGB);
return false;
}
needsCopy = true;
}
// Especially jpeg formats are full range this we need to take care here
// Input Formats like RGBA are handled correctly automatically
AVColorRange range = av_frame_get_color_range(m_pFrame);
AVPixelFormat pixFormat = ConvertFormats(m_pFrame);
// assumption quadratic maximums e.g. 2048x2048
float ratio = m_width / (float) m_height;
unsigned int nHeight = m_originalHeight;
unsigned int nWidth = m_originalWidth;
if (nHeight > height)
{
nHeight = height;
nWidth = (unsigned int) (nHeight * ratio + 0.5f);
}
if (nWidth > width)
{
nWidth = width;
nHeight = (unsigned int) (nWidth / ratio + 0.5f);
}
struct SwsContext* context = sws_getContext(m_originalWidth, m_originalHeight, pixFormat,
nWidth, nHeight, AV_PIX_FMT_RGB32, SWS_BICUBIC, NULL, NULL, NULL);
if (range == AVCOL_RANGE_JPEG)
{
int* inv_table = nullptr;
int* table = nullptr;
int srcRange, dstRange, brightness, contrast, saturation;
sws_getColorspaceDetails(context, &inv_table, &srcRange, &table, &dstRange, &brightness, &contrast, &saturation);
srcRange = 1;
sws_setColorspaceDetails(context, inv_table, srcRange, table, dstRange, brightness, contrast, saturation);
}
sws_scale(context, m_pFrame->data, m_pFrame->linesize, 0, m_originalHeight,
pictureRGB->data, pictureRGB->linesize);
sws_freeContext(context);
if (needsCopy)
{
int minPitch = std::min((int)pitch, pictureRGB->linesize[0]);
if (minPitch < 0)
{
CLog::LogFunction(LOGERROR, __FUNCTION__, "negative pitch or height");
av_free(pictureRGB);
return false;
}
const unsigned char *src = pictureRGB->data[0];
unsigned char* dst = pixels;
for (unsigned int y = 0; y < nHeight; y++)
{
memcpy(dst, src, minPitch);
src += pictureRGB->linesize[0];
dst += pitch;
}
avpicture_free(pictureRGB);
}
pictureRGB->data[0] = nullptr;
avpicture_free(pictureRGB);
// update width and height original dimensions are kept
m_height = nHeight;
m_width = nWidth;
return true;
}
bool CFFmpegImage::DecodeFrame(AVFrame* frame, unsigned int width, unsigned int height, unsigned int pitch, unsigned char * const pixels)
{
if (pixels == nullptr)
{
CLog::Log(LOGERROR, "%s - No valid buffer pointer (nullptr) passed", __FUNCTION__);
return false;
}
AVFrame* pictureRGB = av_frame_alloc();
if (!pictureRGB)
{
CLog::LogF(LOGERROR, "AVFrame could not be allocated");
return false;
}
// we align on 16 as the input provided by the Texture also aligns the buffer size to 16
int size = av_image_fill_arrays(pictureRGB->data, pictureRGB->linesize, NULL, AV_PIX_FMT_RGB32, width, height, 16);
if (size < 0)
{
CLog::LogF(LOGERROR, "Could not allocate AVFrame member with %i x %i pixes", width, height);
av_frame_free(&pictureRGB);
return false;
}
bool needsCopy = false;
int pixelsSize = pitch * height;
bool aligned = (((uintptr_t)(const void *)(pixels)) % (32) == 0);
if (!aligned)
CLog::Log(LOGDEBUG, "Alignment of external buffer is not suitable for ffmpeg intrinsics - please fix your malloc");
if (aligned && size == pixelsSize && (int)pitch == pictureRGB->linesize[0])
{
// We can use the pixels buffer directly
pictureRGB->data[0] = pixels;
}
else
{
// We need an extra buffer and copy it manually afterwards
pictureRGB->format = AV_PIX_FMT_RGB32;
pictureRGB->width = width;
pictureRGB->height = height;
// we copy the data manually later so give a chance to intrinsics (e.g. mmx, neon)
if (av_frame_get_buffer(pictureRGB, 32) < 0)
{
CLog::LogF(LOGERROR, "Could not allocate temp buffer of size %i bytes", size);
av_frame_free(&pictureRGB);
return false;
}
needsCopy = true;
}
// Especially jpeg formats are full range this we need to take care here
// Input Formats like RGBA are handled correctly automatically
AVColorRange range = frame->color_range;
AVPixelFormat pixFormat = ConvertFormats(frame);
// assumption quadratic maximums e.g. 2048x2048
float ratio = m_width / (float)m_height;
unsigned int nHeight = m_originalHeight;
unsigned int nWidth = m_originalWidth;
if (nHeight > height)
{
nHeight = height;
nWidth = (unsigned int)(nHeight * ratio + 0.5f);
}
if (nWidth > width)
{
nWidth = width;
nHeight = (unsigned int)(nWidth / ratio + 0.5f);
}
struct SwsContext* context = sws_getContext(m_originalWidth, m_originalHeight, pixFormat,
nWidth, nHeight, AV_PIX_FMT_RGB32, SWS_BICUBIC, NULL, NULL, NULL);
if (range == AVCOL_RANGE_JPEG)
{
int* inv_table = nullptr;
int* table = nullptr;
int srcRange, dstRange, brightness, contrast, saturation;
sws_getColorspaceDetails(context, &inv_table, &srcRange, &table, &dstRange, &brightness, &contrast, &saturation);
srcRange = 1;
sws_setColorspaceDetails(context, inv_table, srcRange, table, dstRange, brightness, contrast, saturation);
}
sws_scale(context, frame->data, frame->linesize, 0, m_originalHeight,
pictureRGB->data, pictureRGB->linesize);
sws_freeContext(context);
if (needsCopy)
{
int minPitch = std::min((int)pitch, pictureRGB->linesize[0]);
if (minPitch < 0)
{
CLog::LogF(LOGERROR, "negative pitch or height");
av_frame_free(&pictureRGB);
return false;
}
const unsigned char *src = pictureRGB->data[0];
unsigned char* dst = pixels;
for (unsigned int y = 0; y < nHeight; y++)
{
memcpy(dst, src, minPitch);
src += pictureRGB->linesize[0];
dst += pitch;
}
av_frame_free(&pictureRGB);
}
else
{
// we only lended the data so don't get it deleted
pictureRGB->data[0] = nullptr;
av_frame_free(&pictureRGB);
}
// update width and height original dimensions are kept
m_height = nHeight;
m_width = nWidth;
return true;
}
// UCI格式图像解码,目前只支持输出24位BGR和32位的BGRA,返回0表示调用成功,负数表示错误,不支持多线程同时访问
__declspec(dllexport) int __stdcall UCIDecode(
const void* src, // 输入UCI数据指针(不能传入null,其它指针参数可以传入null表示不需要输出)
int srclen, // 输入UCI数据长度
void** dst, // 输出RAW数据的指针(BGR或BGRA格式)
int* stride, // 输出RAW数据的行间字节跨度(dst不为null时,stride不能传入null)
int* width, // 输出图像的宽度值
int* height, // 输出图像的高度值
int* bit) // 输出图像的bpp值(每像素位数)
{
extern AVCodec ff_h264_decoder;
int ret = 0;
U8* frame0 = 0;
U8* frame1 = 0;
U8* frame_data[4];
int frame_size[4];
int w, h, b, m;
int ww, hh;
int size, hasimg, bit10;
U8* psrc, *pdst;
const U8* srcend = (const U8*)src + srclen;
if(dst ) *dst = 0;
if(stride) *stride = 0;
if(width ) *width = 0;
if(height) *height = 0;
if(bit ) *bit = 0;
if(!src || srclen < 0 || dst && !stride) return -1;
if(srclen < 12) return -2;
if((*(U32*)src & 0xffffff) != *(U32*)"UCI") return -3;
switch(*((U8*)src + 3))
{
case '3': b = 24; m = 0; break; // part range, YUV420
case '4': b = 32; m = 0; break; // part range, YUV420+A
case 'T': b = 24; m = 1; break; // part range, Y+U+V(420)
case 'Q': b = 32; m = 1; break; // part range, Y+U+V(420)+A
case 0x20: b = 24; m = 2; break; // full range, YUV420
case 0x21: b = 32; m = 2; break; // full range, YUV420+A
case 0x40: b = 24; m = 3; break; // full range, YUV444
case 0x41: b = 32; m = 3; break; // full range, YUV444+A
default: return -4;
}
w = *(int*)((U8*)src + 4);
h = *(int*)((U8*)src + 8);
if(width ) *width = w;
if(height) *height = h;
if(bit ) *bit = b;
if(stride) *stride = (m == 1 ? w : (w+7)&0xfffffff8) * (b/8);
if(!dst) return 0;
if(srclen < 12 + 4) return -5;
ww = w + (w & ((m & 1) ^ 1));
hh = h + (h & ((m & 1) ^ 1));
frame_data[0] = (U8*)src + 12 + 4;
frame_size[0] = *(int*)((U8*)src + 12);
if(m != 1)
{
if(b == 24)
{
if(frame_size[0] < 0 || frame_data[0] + frame_size[0] > srcend) return -10;
}
else
{
if(frame_size[0] < 0 || frame_data[0] + frame_size[0] + 4 > srcend) return -11;
frame_data[3] = frame_data[0] + frame_size[0] + 4;
frame_size[3] = *(int*)(frame_data[0] + frame_size[0]);
if(frame_size[3] < 0 || frame_data[3] + frame_size[3] > srcend) return -12;
}
}
else
{
if(frame_size[0] < 0 || frame_data[0] + frame_size[0] + 4 > srcend) return -13;
frame_data[1] = frame_data[0] + frame_size[0] + 4;
frame_size[1] = *(int*)(frame_data[0] + frame_size[0]);
if(frame_size[1] < 0 || frame_data[1] + frame_size[1] + 4 > srcend) return -14;
frame_data[2] = frame_data[1] + frame_size[1] + 4;
frame_size[2] = *(int*)(frame_data[1] + frame_size[1]);
if(b == 24)
{
if(frame_size[2] < 0 || frame_data[2] + frame_size[2] > srcend) return -15;
}
else
{
if(frame_size[2] < 0 || frame_data[2] + frame_size[2] + 4 > srcend) return -16;
frame_data[3] = frame_data[2] + frame_size[2] + 4;
frame_size[3] = *(int*)(frame_data[2] + frame_size[2]);
if(frame_size[3] < 0 || frame_data[3] + frame_size[3] > srcend) return -17;
}
}
EnterCriticalSection(&g_cs);
if(!g_frame && !(g_frame = avcodec_alloc_frame())) { ret = -20; goto end_; }
if(!g_context && !(g_context = avcodec_alloc_context3(&ff_h264_decoder))) { ret = -21; goto end_; }
g_context->flags &= ~CODEC_FLAG_EMU_EDGE;
if(av_log_get_level() >= AV_LOG_DEBUG) g_context->debug = -1;
if(avcodec_open2(g_context, &ff_h264_decoder, 0) < 0) { ret = -22; goto end_; }
g_context->flags &= ~CODEC_FLAG_EMU_EDGE;
g_packet.data = frame_data[0];
g_packet.size = frame_size[0];
size = avcodec_decode_video2(g_context, g_frame, &hasimg, &g_packet);
if(size <= 0) { ret = -100 + size; goto end_; }
if(!hasimg) { ret = -23; goto end_; }
if(g_context->width < ww || g_context->height < hh) { ret = -24; goto end_; }
if(!g_frame->data[0] || m != 1 && (!g_frame->data[1] || !g_frame->data[2])) { ret = -25; goto end_; }
if(g_frame->linesize[1] != g_frame->linesize[2]) { ret = -26; goto end_; }
bit10 = ((H264Context*)g_context->priv_data)->sps.bit_depth_luma;
if(bit10 == 8) bit10 = 0; else if(bit10 != 10) { ret = -27; goto end_; }
if(m != 1)
{
enum AVPixelFormat pfsrc, pfdst = (b == 24 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGRA);
if(m != 3) pfsrc = (bit10 ? AV_PIX_FMT_YUV420P10LE : AV_PIX_FMT_YUV420P);
else pfsrc = (bit10 ? AV_PIX_FMT_YUV444P10LE : AV_PIX_FMT_YUV444P);
if(!(*dst = malloc(*stride * hh))) { ret = -28; goto end_; }
g_swsctx = sws_getCachedContext(g_swsctx, ww, hh, pfsrc, ww, hh, pfdst, SWS_LANCZOS, 0, 0, 0);
if(!g_swsctx) { ret = -29; goto end_; }
sws_setColorspaceDetails(g_swsctx, g_cs_table, m != 0, g_cs_table, m != 0, 0, 1 << 16, 1 << 16);
if(sws_scale(g_swsctx, g_frame->data, g_frame->linesize, 0, hh, dst, stride) != hh) { ret = -30; goto end_; }
}
else
{
if(!(frame0 = (U8*)malloc(g_frame->linesize[0] * h))) { ret = -31; goto end_; }
memcpy(frame0, g_frame->data[0], g_frame->linesize[0] * h);
frame_data[0] = frame0;
frame_size[0] = g_frame->linesize[0];
g_packet.data = frame_data[1];
g_packet.size = frame_size[1];
size = avcodec_decode_video2(g_context, g_frame, &hasimg, &g_packet);
if(size <= 0) { ret = -200 + size; goto end_; }
if(!hasimg) { ret = -32; goto end_; }
if(g_context->width < ww || g_context->height < hh) { ret = -33; goto end_; }
if(!g_frame->data[0]) { ret = -34; goto end_; }
if(!(frame1 = (U8*)malloc(g_frame->linesize[0] * h))) { ret = -35; goto end_; }
memcpy(frame1, g_frame->data[0], g_frame->linesize[0] * h);
frame_data[1] = frame1;
frame_size[1] = g_frame->linesize[0];
g_packet.data = frame_data[2];
g_packet.size = frame_size[2];
size = avcodec_decode_video2(g_context, g_frame, &hasimg, &g_packet);
if(size <= 0) { ret = -300 + size; goto end_; }
if(!hasimg) { ret = -36; goto end_; }
if(g_context->width < ww || g_context->height < hh) { ret = -37; goto end_; }
if(!g_frame->data[0]) { ret = -38; goto end_; }
frame_data[2] = g_frame->data[0];
frame_size[2] = g_frame->linesize[0];
if(!(*dst = malloc(*stride * h))) { ret = -39; goto end_; }
if(b == 24) YUV444_BGR (*dst, w * 3, frame_data, frame_size, w, h);
else YUV444_BGRA(*dst, w * 4, frame_data, frame_size, w, h);
}
if(b == 32)
{
avcodec_close(g_context);
if(!(g_context = avcodec_alloc_context3(&ff_h264_decoder))) { ret = -40; goto end_; }
if(av_log_get_level() >= AV_LOG_DEBUG) g_context->debug = -1;
if(avcodec_open2(g_context, &ff_h264_decoder, 0) < 0) { ret = -41; goto end_; }
g_packet.data = frame_data[3];
g_packet.size = frame_size[3];
size = avcodec_decode_video2(g_context, g_frame, &hasimg, &g_packet);
if(size <= 0) { ret = -400 + size; goto end_; }
if(!hasimg) { ret = -42; goto end_; }
if(g_context->width < ww || g_context->height < hh) { ret = -43; goto end_; }
if(!g_frame->data[0]) { ret = -44; goto end_; }
psrc = g_frame->data[0];
pdst = (U8*)*dst + 3;
if(!bit10)
for(; h; --h)
{
for(m = 0; m < w; ++m)
pdst[m * 4] = psrc[m];
psrc += g_frame->linesize[0];
pdst += *stride;
}
else
for(; h; --h)
{
for(m = 0; m < w; ++m)
pdst[m * 4] = ((U16*)psrc)[m] >> 2;
psrc += g_frame->linesize[0];
pdst += *stride;
}
}
static int startffmpeg(struct anim *anim)
{
int i, videoStream;
AVCodec *pCodec;
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pCodecCtx;
int frs_num;
double frs_den;
int streamcount;
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* The following for color space determination */
int srcRange, dstRange, brightness, contrast, saturation;
int *table;
const int *inv_table;
#endif
if (anim == 0) return(-1);
streamcount = anim->streamindex;
if (avformat_open_input(&pFormatCtx, anim->name, NULL, NULL) != 0) {
return -1;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
av_dump_format(pFormatCtx, 0, anim->name, 0);
/* Find the video stream */
videoStream = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++)
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (streamcount > 0) {
streamcount--;
continue;
}
videoStream = i;
break;
}
if (videoStream == -1) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
/* Find the decoder for the video stream */
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx->workaround_bugs = 1;
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
anim->duration = ceil(pFormatCtx->duration *
av_q2d(pFormatCtx->streams[videoStream]->r_frame_rate) /
AV_TIME_BASE);
frs_num = pFormatCtx->streams[videoStream]->r_frame_rate.num;
frs_den = pFormatCtx->streams[videoStream]->r_frame_rate.den;
frs_den *= AV_TIME_BASE;
while (frs_num % 10 == 0 && frs_den >= 2.0 && frs_num > 10) {
frs_num /= 10;
frs_den /= 10;
}
anim->frs_sec = frs_num;
anim->frs_sec_base = frs_den;
anim->params = 0;
anim->x = pCodecCtx->width;
anim->y = av_get_cropped_height_from_codec(pCodecCtx);
anim->pFormatCtx = pFormatCtx;
anim->pCodecCtx = pCodecCtx;
anim->pCodec = pCodec;
anim->videoStream = videoStream;
anim->interlacing = 0;
anim->orientation = 0;
anim->framesize = anim->x * anim->y * 4;
anim->curposition = -1;
anim->last_frame = 0;
anim->last_pts = -1;
anim->next_pts = -1;
anim->next_packet.stream_index = -1;
anim->pFrame = avcodec_alloc_frame();
anim->pFrameComplete = FALSE;
anim->pFrameDeinterlaced = avcodec_alloc_frame();
anim->pFrameRGB = avcodec_alloc_frame();
if (avpicture_get_size(PIX_FMT_RGBA, anim->x, anim->y) !=
anim->x * anim->y * 4)
{
fprintf(stderr,
"ffmpeg has changed alloc scheme ... ARGHHH!\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
if (anim->ib_flags & IB_animdeinterlace) {
avpicture_fill((AVPicture *) anim->pFrameDeinterlaced,
MEM_callocN(avpicture_get_size(
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height),
"ffmpeg deinterlace"),
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height);
}
if (pCodecCtx->has_b_frames) {
anim->preseek = 25; /* FIXME: detect gopsize ... */
}
else {
anim->preseek = 0;
}
anim->img_convert_ctx = sws_getContext(
anim->x,
anim->y,
anim->pCodecCtx->pix_fmt,
anim->x,
anim->y,
PIX_FMT_RGBA,
SWS_FAST_BILINEAR | SWS_PRINT_INFO | SWS_FULL_CHR_H_INT,
NULL, NULL, NULL);
if (!anim->img_convert_ctx) {
fprintf(stderr,
"Can't transform color space??? Bailing out...\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* Try do detect if input has 0-255 YCbCR range (JFIF Jpeg MotionJpeg) */
if (!sws_getColorspaceDetails(anim->img_convert_ctx, (int **)&inv_table, &srcRange,
&table, &dstRange, &brightness, &contrast, &saturation))
{
srcRange = srcRange || anim->pCodecCtx->color_range == AVCOL_RANGE_JPEG;
inv_table = sws_getCoefficients(anim->pCodecCtx->colorspace);
if (sws_setColorspaceDetails(anim->img_convert_ctx, (int *)inv_table, srcRange,
table, dstRange, brightness, contrast, saturation))
{
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
}
else {
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
#endif
return (0);
}
static ImBuf *avi_fetchibuf(struct anim *anim, int position)
{
ImBuf *ibuf = NULL;
int *tmp;
int y;
if (anim == NULL) {
return NULL;
}
#if defined(_WIN32) && !defined(FREE_WINDOWS)
if (anim->avistreams) {
LPBITMAPINFOHEADER lpbi;
if (anim->pgf) {
lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
if (lpbi) {
ibuf = IMB_ibImageFromMemory((unsigned char *) lpbi, 100, IB_rect, anim->colorspace, "<avi_fetchibuf>");
//Oh brother...
}
}
}
else {
#else
if (1) {
#endif
ibuf = IMB_allocImBuf(anim->x, anim->y, 24, IB_rect);
tmp = AVI_read_frame(anim->avi, AVI_FORMAT_RGB32, position,
AVI_get_stream(anim->avi, AVIST_VIDEO, 0));
if (tmp == NULL) {
printf("Error reading frame from AVI: '%s'\n", anim->name);
IMB_freeImBuf(ibuf);
return NULL;
}
for (y = 0; y < anim->y; y++) {
memcpy(&(ibuf->rect)[((anim->y - y) - 1) * anim->x], &tmp[y * anim->x],
anim->x * 4);
}
MEM_freeN(tmp);
}
ibuf->rect_colorspace = colormanage_colorspace_get_named(anim->colorspace);
return ibuf;
}
#endif /* WITH_AVI */
#ifdef WITH_FFMPEG
static int startffmpeg(struct anim *anim)
{
int i, videoStream;
AVCodec *pCodec;
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pCodecCtx;
int frs_num;
double frs_den;
int streamcount;
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* The following for color space determination */
int srcRange, dstRange, brightness, contrast, saturation;
int *table;
const int *inv_table;
#endif
if (anim == 0) return(-1);
streamcount = anim->streamindex;
if (avformat_open_input(&pFormatCtx, anim->name, NULL, NULL) != 0) {
return -1;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
av_dump_format(pFormatCtx, 0, anim->name, 0);
/* Find the video stream */
videoStream = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++)
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (streamcount > 0) {
streamcount--;
continue;
}
videoStream = i;
break;
}
if (videoStream == -1) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
/* Find the decoder for the video stream */
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx->workaround_bugs = 1;
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
anim->duration = ceil(pFormatCtx->duration *
av_q2d(pFormatCtx->streams[videoStream]->r_frame_rate) /
AV_TIME_BASE);
frs_num = pFormatCtx->streams[videoStream]->r_frame_rate.num;
frs_den = pFormatCtx->streams[videoStream]->r_frame_rate.den;
frs_den *= AV_TIME_BASE;
while (frs_num % 10 == 0 && frs_den >= 2.0 && frs_num > 10) {
frs_num /= 10;
frs_den /= 10;
}
anim->frs_sec = frs_num;
anim->frs_sec_base = frs_den;
anim->params = 0;
anim->x = pCodecCtx->width;
anim->y = av_get_cropped_height_from_codec(pCodecCtx);
anim->pFormatCtx = pFormatCtx;
anim->pCodecCtx = pCodecCtx;
anim->pCodec = pCodec;
anim->videoStream = videoStream;
anim->interlacing = 0;
anim->orientation = 0;
anim->framesize = anim->x * anim->y * 4;
anim->curposition = -1;
anim->last_frame = 0;
anim->last_pts = -1;
anim->next_pts = -1;
anim->next_packet.stream_index = -1;
anim->pFrame = avcodec_alloc_frame();
anim->pFrameComplete = FALSE;
anim->pFrameDeinterlaced = avcodec_alloc_frame();
anim->pFrameRGB = avcodec_alloc_frame();
if (avpicture_get_size(PIX_FMT_RGBA, anim->x, anim->y) !=
anim->x * anim->y * 4)
{
fprintf(stderr,
"ffmpeg has changed alloc scheme ... ARGHHH!\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
if (anim->ib_flags & IB_animdeinterlace) {
avpicture_fill((AVPicture *) anim->pFrameDeinterlaced,
MEM_callocN(avpicture_get_size(
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height),
"ffmpeg deinterlace"),
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height);
}
if (pCodecCtx->has_b_frames) {
anim->preseek = 25; /* FIXME: detect gopsize ... */
}
else {
anim->preseek = 0;
}
anim->img_convert_ctx = sws_getContext(
anim->x,
anim->y,
anim->pCodecCtx->pix_fmt,
anim->x,
anim->y,
PIX_FMT_RGBA,
SWS_FAST_BILINEAR | SWS_PRINT_INFO | SWS_FULL_CHR_H_INT,
NULL, NULL, NULL);
if (!anim->img_convert_ctx) {
fprintf(stderr,
"Can't transform color space??? Bailing out...\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* Try do detect if input has 0-255 YCbCR range (JFIF Jpeg MotionJpeg) */
if (!sws_getColorspaceDetails(anim->img_convert_ctx, (int **)&inv_table, &srcRange,
&table, &dstRange, &brightness, &contrast, &saturation))
{
srcRange = srcRange || anim->pCodecCtx->color_range == AVCOL_RANGE_JPEG;
inv_table = sws_getCoefficients(anim->pCodecCtx->colorspace);
if (sws_setColorspaceDetails(anim->img_convert_ctx, (int *)inv_table, srcRange,
table, dstRange, brightness, contrast, saturation))
{
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
}
else {
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
#endif
return (0);
}
