~ubuntu-branches/ubuntu/hardy/avidemux/hardy

int sws_setColorspaceDetails(SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation){

1783

int64_t crv = inv_table[0];

1784

int64_t cbu = inv_table[1];

1785

int64_t cgu = -inv_table[2];

1786

int64_t cgv = -inv_table[3];

1787

int64_t cy = 1<<16;

1788

int64_t oy = 0;

1789

1790

if(isYUV(c->dstFormat) || isGray(c->dstFormat)) return -1;

1791

memcpy(c->srcColorspaceTable, inv_table, sizeof(int)*4);

1792

memcpy(c->dstColorspaceTable, table, sizeof(int)*4);

1793

1794

c->brightness= brightness;

1795

c->contrast = contrast;

1796

c->saturation= saturation;

1797

c->srcRange = srcRange;

1798

c->dstRange = dstRange;

1799

1800

c->uOffset= 0x0400040004000400LL;

1801

c->vOffset= 0x0400040004000400LL;

1802

1803

if(!srcRange){

1804

cy= (cy*255) / 219;

1805

oy= 16<<16;

1806

}

1807

1808

cy = (cy *contrast )>>16;

1809

crv= (crv*contrast * saturation)>>32;

1810

cbu= (cbu*contrast * saturation)>>32;

1811

cgu= (cgu*contrast * saturation)>>32;

1812

cgv= (cgv*contrast * saturation)>>32;

1813

1814

oy -= 256*brightness;

1815

1816

c->yCoeff= roundToInt16(cy *8192) * 0x0001000100010001ULL;

1817

c->vrCoeff= roundToInt16(crv*8192) * 0x0001000100010001ULL;

1818

c->ubCoeff= roundToInt16(cbu*8192) * 0x0001000100010001ULL;

1819

c->vgCoeff= roundToInt16(cgv*8192) * 0x0001000100010001ULL;

1820

c->ugCoeff= roundToInt16(cgu*8192) * 0x0001000100010001ULL;

1821

c->yOffset= roundToInt16(oy * 8) * 0x0001000100010001ULL;

1822

1823

yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, contrast, saturation);

1824

//FIXME factorize

1825

1826

#ifdef COMPILE_ALTIVEC

1827

if (c->flags & SWS_CPU_CAPS_ALTIVEC)

1828

yuv2rgb_altivec_init_tables (c, inv_table, brightness, contrast, saturation);

1829

#endif

1830

return 0;

1831

}

1832

1833

/**

1834

* @return -1 if not supported

1835

1836

int sws_getColorspaceDetails(SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation){

1837

if(isYUV(c->dstFormat) || isGray(c->dstFormat)) return -1;

1838

1839

*inv_table = c->srcColorspaceTable;

1840

*table = c->dstColorspaceTable;

1841

*srcRange = c->srcRange;

1842

*dstRange = c->dstRange;

1843

*brightness= c->brightness;

1844

*contrast = c->contrast;

1845

*saturation= c->saturation;

1846

1847

return 0;

1848

}

1849

1850

static int handle_jpeg(int *format)

1851

{

1852

switch (*format) {

1853

case PIX_FMT_YUVJ420P:

1854

*format = PIX_FMT_YUV420P;

1855

return 1;

1856

case PIX_FMT_YUVJ422P:

1857

*format = PIX_FMT_YUV422P;

1858

return 1;

1859

case PIX_FMT_YUVJ444P:

1860

*format = PIX_FMT_YUV444P;

1861

return 1;

1862

default:

1863

return 0;

1864

}

1865

}

1866

1867

SwsContext *sws_getContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags,

1868

SwsFilter *srcFilter, SwsFilter *dstFilter, double *param){

1869

1870

SwsContext *c;

1871

int i;

1872

int usesVFilter, usesHFilter;

1873

int unscaled, needsDither;

1874

int srcRange, dstRange;

1875

SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};

1876

#if defined(ARCH_X86) || defined(ARCH_X86_64)

1877

if(flags & SWS_CPU_CAPS_MMX)

1878

asm volatile("emms\n\t"::: "memory");

1879

#endif

1880

1881

#ifndef RUNTIME_CPUDETECT //ensure that the flags match the compiled variant if cpudetect is off

1882

flags &= ~(SWS_CPU_CAPS_MMX|SWS_CPU_CAPS_MMX2|SWS_CPU_CAPS_3DNOW|SWS_CPU_CAPS_ALTIVEC);

1883

#ifdef HAVE_MMX2

1884

flags |= SWS_CPU_CAPS_MMX|SWS_CPU_CAPS_MMX2;

1885

#elif defined (HAVE_3DNOW)

1886

flags |= SWS_CPU_CAPS_MMX|SWS_CPU_CAPS_3DNOW;

1887

#elif defined (HAVE_MMX)

1888

flags |= SWS_CPU_CAPS_MMX;

1889

#elif defined (HAVE_ALTIVEC)

1890

flags |= SWS_CPU_CAPS_ALTIVEC;

1891

#endif

1892

#endif /* RUNTIME_CPUDETECT */

1893

if(clip_table[512] != 255) globalInit();

1894

if(rgb15to16 == NULL) sws_rgb2rgb_init(flags);

1895

1896

unscaled = (srcW == dstW && srcH == dstH);

1897

needsDither= (isBGR(dstFormat) || isRGB(dstFormat))

1898

&& (fmt_depth(dstFormat))<24

1899

&& ((fmt_depth(dstFormat))<(fmt_depth(srcFormat)) || (!(isRGB(srcFormat) || isBGR(srcFormat))));

1900

1901

srcRange = handle_jpeg(&srcFormat);

1902

dstRange = handle_jpeg(&dstFormat);

1903

1904

if(!isSupportedIn(srcFormat))

1905

{

1906

MSG_ERR("swScaler: %s is not supported as input format\n", sws_format_name(srcFormat));

1907

return NULL;

1908

}

1909

if(!isSupportedOut(dstFormat))

1910

{

1911

MSG_ERR("swScaler: %s is not supported as output format\n", sws_format_name(dstFormat));

1912

return NULL;

1913

}

1914

1915

/* sanity check */

1916

if(srcW<4 || srcH<1 || dstW<8 || dstH<1) //FIXME check if these are enough and try to lowwer them after fixing the relevant parts of the code

1917

{

1918

MSG_ERR("swScaler: %dx%d -> %dx%d is invalid scaling dimension\n",

1919

srcW, srcH, dstW, dstH);

1920

return NULL;

1921

}

1922

1923

if(!dstFilter) dstFilter= &dummyFilter;

1924

if(!srcFilter) srcFilter= &dummyFilter;

1925

1926

c= av_malloc(sizeof(SwsContext));

1927

memset(c, 0, sizeof(SwsContext));

1928

1929

c->srcW= srcW;

1930

c->srcH= srcH;

1931

c->dstW= dstW;

1932

c->dstH= dstH;

1933

c->lumXInc= ((srcW<<16) + (dstW>>1))/dstW;

1934

c->lumYInc= ((srcH<<16) + (dstH>>1))/dstH;

1935

c->flags= flags;

1936

c->dstFormat= dstFormat;

1937

c->srcFormat= srcFormat;

1938

c->vRounder= 4* 0x0001000100010001ULL;

1939

1940

usesHFilter= usesVFilter= 0;

1941

if(dstFilter->lumV!=NULL && dstFilter->lumV->length>1) usesVFilter=1;

1942

if(dstFilter->lumH!=NULL && dstFilter->lumH->length>1) usesHFilter=1;

1943

if(dstFilter->chrV!=NULL && dstFilter->chrV->length>1) usesVFilter=1;

1944

if(dstFilter->chrH!=NULL && dstFilter->chrH->length>1) usesHFilter=1;

1945

if(srcFilter->lumV!=NULL && srcFilter->lumV->length>1) usesVFilter=1;

1946

if(srcFilter->lumH!=NULL && srcFilter->lumH->length>1) usesHFilter=1;

1947

if(srcFilter->chrV!=NULL && srcFilter->chrV->length>1) usesVFilter=1;

1948

if(srcFilter->chrH!=NULL && srcFilter->chrH->length>1) usesHFilter=1;

1949

1950

getSubSampleFactors(&c->chrSrcHSubSample, &c->chrSrcVSubSample, srcFormat);

1951

getSubSampleFactors(&c->chrDstHSubSample, &c->chrDstVSubSample, dstFormat);

1952

1953

// reuse chroma for 2 pixles rgb/bgr unless user wants full chroma interpolation

1954

if((isBGR(dstFormat) || isRGB(dstFormat)) && !(flags&SWS_FULL_CHR_H_INT)) c->chrDstHSubSample=1;

1955

1956

// drop some chroma lines if the user wants it

1957

c->vChrDrop= (flags&SWS_SRC_V_CHR_DROP_MASK)>>SWS_SRC_V_CHR_DROP_SHIFT;

1958

c->chrSrcVSubSample+= c->vChrDrop;

1959

1960

// drop every 2. pixel for chroma calculation unless user wants full chroma

1961

if((isBGR(srcFormat) || isRGB(srcFormat)) && !(flags&SWS_FULL_CHR_H_INP))

1962

c->chrSrcHSubSample=1;

1963

1964

if(param){

1965

c->param[0] = param[0];

1966

c->param[1] = param[1];

1967

}else{

1968

c->param[0] =

1969

c->param[1] = SWS_PARAM_DEFAULT;

1970

}

1971

1972

c->chrIntHSubSample= c->chrDstHSubSample;

1973

c->chrIntVSubSample= c->chrSrcVSubSample;

1974

1975

// note the -((-x)>>y) is so that we allways round toward +inf

1976

c->chrSrcW= -((-srcW) >> c->chrSrcHSubSample);

1977

c->chrSrcH= -((-srcH) >> c->chrSrcVSubSample);

1978

c->chrDstW= -((-dstW) >> c->chrDstHSubSample);

1979

c->chrDstH= -((-dstH) >> c->chrDstVSubSample);

1980

1981

sws_setColorspaceDetails(c, Inverse_Table_6_9[SWS_CS_DEFAULT], srcRange, Inverse_Table_6_9[SWS_CS_DEFAULT] /* FIXME*/, dstRange, 0, 1<<16, 1<<16);

1982

1983

/* unscaled special Cases */

1984

if(unscaled && !usesHFilter && !usesVFilter)

1985

{

1986

/* yv12_to_nv12 */

1987

if(srcFormat == PIX_FMT_YUV420P && (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21))

1988

{

1989

c->swScale= PlanarToNV12Wrapper;

1990

}

1991

/* yuv2bgr */

1992

if((srcFormat==PIX_FMT_YUV420P || srcFormat==PIX_FMT_YUV422P) && (isBGR(dstFormat) || isRGB(dstFormat)))

1993

{

1994

c->swScale= yuv2rgb_get_func_ptr(c);

1995

}

1996

1997

if( srcFormat==PIX_FMT_YUV410P && dstFormat==PIX_FMT_YUV420P )

1998

{

1999

c->swScale= yvu9toyv12Wrapper;

2000

}

2001

2002

/* bgr24toYV12 */

2003

if(srcFormat==PIX_FMT_BGR24 && dstFormat==PIX_FMT_YUV420P)

2004

c->swScale= bgr24toyv12Wrapper;

2005

2006

/* rgb/bgr -> rgb/bgr (no dither needed forms) */

2007

if( (isBGR(srcFormat) || isRGB(srcFormat))

2008

&& (isBGR(dstFormat) || isRGB(dstFormat))

2009

&& !needsDither)

2010

c->swScale= rgb2rgbWrapper;

2011

2012

/* LQ converters if -sws 0 or -sws 4*/

2013

if(c->flags&(SWS_FAST_BILINEAR|SWS_POINT)){

2014

/* rgb/bgr -> rgb/bgr (dither needed forms) */

2015

if( (isBGR(srcFormat) || isRGB(srcFormat))

2016

&& (isBGR(dstFormat) || isRGB(dstFormat))

2017

&& needsDither)

2018

c->swScale= rgb2rgbWrapper;

2019

2020

/* yv12_to_yuy2 */

2021

if(srcFormat == PIX_FMT_YUV420P &&

2022

(dstFormat == PIX_FMT_YUYV422 || dstFormat == PIX_FMT_UYVY422))

2023

{

2024

if (dstFormat == PIX_FMT_YUYV422)

2025

c->swScale= PlanarToYuy2Wrapper;

2026

else

2027

c->swScale= PlanarToUyvyWrapper;

2028

}

2029

}

2030

2031

#ifdef COMPILE_ALTIVEC

2032

if ((c->flags & SWS_CPU_CAPS_ALTIVEC) &&

2033

((srcFormat == PIX_FMT_YUV420P &&

2034

(dstFormat == PIX_FMT_YUYV422 || dstFormat == PIX_FMT_UYVY422)))) {

2035

// unscaled YV12 -> packed YUV, we want speed

2036

if (dstFormat == PIX_FMT_YUYV422)

2037

c->swScale= yv12toyuy2_unscaled_altivec;

2038

else

2039

c->swScale= yv12touyvy_unscaled_altivec;

2040

}

2041

#endif

2042

2043

/* simple copy */

2044

if( srcFormat == dstFormat

2045

|| (isPlanarYUV(srcFormat) && isGray(dstFormat))

2046

|| (isPlanarYUV(dstFormat) && isGray(srcFormat))

2047

)

2048

{

2049

c->swScale= simpleCopy;

2050

}

2051

2052

if(c->swScale){

2053

if(flags&SWS_PRINT_INFO)

2054

MSG_INFO("SwScaler: using unscaled %s -> %s special converter\n",

2055

sws_format_name(srcFormat), sws_format_name(dstFormat));

2056

return c;

2057

}

2058

}

2059

2060

if(flags & SWS_CPU_CAPS_MMX2)

2061

{

2062

c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;

2063

if(!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR))

2064

{

2065

if(flags&SWS_PRINT_INFO)

2066

MSG_INFO("SwScaler: output Width is not a multiple of 32 -> no MMX2 scaler\n");

2067

}

2068

if(usesHFilter) c->canMMX2BeUsed=0;

2069

}

2070

else

2071

c->canMMX2BeUsed=0;

2072

2073

c->chrXInc= ((c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;

2074

c->chrYInc= ((c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;

2075

2076

// match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst

2077

// but only for the FAST_BILINEAR mode otherwise do correct scaling

2078

// n-2 is the last chrominance sample available

2079

// this is not perfect, but noone shuld notice the difference, the more correct variant

2080

// would be like the vertical one, but that would require some special code for the

2081

// first and last pixel

2082

if(flags&SWS_FAST_BILINEAR)

2083

{

2084

if(c->canMMX2BeUsed)

2085

{

2086

c->lumXInc+= 20;

2087

c->chrXInc+= 20;

2088

}

2089

//we don't use the x86asm scaler if mmx is available

2090

else if(flags & SWS_CPU_CAPS_MMX)

2091

{

2092

c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;

2093

c->chrXInc = ((c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;

2094

}

2095

}

2096

2097

/* precalculate horizontal scaler filter coefficients */

2098

{

2099

const int filterAlign=

2100

(flags & SWS_CPU_CAPS_MMX) ? 4 :

2101

(flags & SWS_CPU_CAPS_ALTIVEC) ? 8 :

2102

2103

2104

initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,

2105

srcW , dstW, filterAlign, 1<<14,

2106

(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags,

2107

srcFilter->lumH, dstFilter->lumH, c->param);

2108

initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,

2109

c->chrSrcW, c->chrDstW, filterAlign, 1<<14,

2110

(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags,

2111

srcFilter->chrH, dstFilter->chrH, c->param);

2112

2113

#define MAX_FUNNY_CODE_SIZE 10000

2114

#if defined(COMPILE_MMX2)

2115

// can't downscale !!!

2116

if(c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR))

2117

{

2118

#ifdef MAP_ANONYMOUS

2119

c->funnyYCode = (uint8_t*)mmap(NULL, MAX_FUNNY_CODE_SIZE, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);

2120

c->funnyUVCode = (uint8_t*)mmap(NULL, MAX_FUNNY_CODE_SIZE, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);

2121

#else

2122

c->funnyYCode = av_malloc(MAX_FUNNY_CODE_SIZE);

2123

c->funnyUVCode = av_malloc(MAX_FUNNY_CODE_SIZE);

2124

#endif

2125

2126

c->lumMmx2Filter = av_malloc((dstW /8+8)*sizeof(int16_t));

2127

c->chrMmx2Filter = av_malloc((c->chrDstW /4+8)*sizeof(int16_t));

2128

c->lumMmx2FilterPos= av_malloc((dstW /2/8+8)*sizeof(int32_t));

2129

c->chrMmx2FilterPos= av_malloc((c->chrDstW/2/4+8)*sizeof(int32_t));

2130

2131

initMMX2HScaler( dstW, c->lumXInc, c->funnyYCode , c->lumMmx2Filter, c->lumMmx2FilterPos, 8);

2132

initMMX2HScaler(c->chrDstW, c->chrXInc, c->funnyUVCode, c->chrMmx2Filter, c->chrMmx2FilterPos, 4);

2133

}

2134

#endif /* defined(COMPILE_MMX2) */

2135

} // Init Horizontal stuff

2136

2137

2138

2139

/* precalculate vertical scaler filter coefficients */

2140

{

2141

const int filterAlign=

2142

(flags & SWS_CPU_CAPS_MMX) && (flags & SWS_ACCURATE_RND) ? 2 :

2143

(flags & SWS_CPU_CAPS_ALTIVEC) ? 8 :

2144

2145

2146

initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,

2147

srcH , dstH, filterAlign, (1<<12)-4,

2148

(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags,

2149

srcFilter->lumV, dstFilter->lumV, c->param);

2150

initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,

2151

c->chrSrcH, c->chrDstH, filterAlign, (1<<12)-4,

2152

(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags,

2153

srcFilter->chrV, dstFilter->chrV, c->param);

2154

2155

#ifdef HAVE_ALTIVEC

2156

c->vYCoeffsBank = av_malloc(sizeof (vector signed short)*c->vLumFilterSize*c->dstH);

2157

c->vCCoeffsBank = av_malloc(sizeof (vector signed short)*c->vChrFilterSize*c->chrDstH);

2158

2159

for (i=0;i<c->vLumFilterSize*c->dstH;i++) {

2160

int j;

2161

short *p = (short *)&c->vYCoeffsBank[i];

2162

for (j=0;j<8;j++)

2163

p[j] = c->vLumFilter[i];

2164

}

2165

2166

for (i=0;i<c->vChrFilterSize*c->chrDstH;i++) {

2167

int j;

2168

short *p = (short *)&c->vCCoeffsBank[i];

2169

for (j=0;j<8;j++)

2170

p[j] = c->vChrFilter[i];

2171

}

2172

#endif

2173

}

2174

2175

// Calculate Buffer Sizes so that they won't run out while handling these damn slices

2176

c->vLumBufSize= c->vLumFilterSize;

2177

c->vChrBufSize= c->vChrFilterSize;

2178

for(i=0; i<dstH; i++)

2179

{

2180

int chrI= i*c->chrDstH / dstH;

2181

int nextSlice= FFMAX(c->vLumFilterPos[i ] + c->vLumFilterSize - 1,

2182

((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<c->chrSrcVSubSample));

2183

2184

nextSlice>>= c->chrSrcVSubSample;

2185

nextSlice<<= c->chrSrcVSubSample;

2186

if(c->vLumFilterPos[i ] + c->vLumBufSize < nextSlice)

2187

c->vLumBufSize= nextSlice - c->vLumFilterPos[i ];

2188

if(c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>c->chrSrcVSubSample))

2189

c->vChrBufSize= (nextSlice>>c->chrSrcVSubSample) - c->vChrFilterPos[chrI];

2190

}

2191

2192

// allocate pixbufs (we use dynamic allocation because otherwise we would need to

2193

c->lumPixBuf= av_malloc(c->vLumBufSize*2*sizeof(int16_t*));

2194

c->chrPixBuf= av_malloc(c->vChrBufSize*2*sizeof(int16_t*));

2195

//Note we need at least one pixel more at the end because of the mmx code (just in case someone wanna replace the 4000/8000)

2196

/* align at 16 bytes for AltiVec */

2197

for(i=0; i<c->vLumBufSize; i++)

2198

c->lumPixBuf[i]= c->lumPixBuf[i+c->vLumBufSize]= av_malloc(4000);

2199

for(i=0; i<c->vChrBufSize; i++)

2200

c->chrPixBuf[i]= c->chrPixBuf[i+c->vChrBufSize]= av_malloc(8000);

2201

2202

//try to avoid drawing green stuff between the right end and the stride end

2203

for(i=0; i<c->vLumBufSize; i++) memset(c->lumPixBuf[i], 0, 4000);

2204

for(i=0; i<c->vChrBufSize; i++) memset(c->chrPixBuf[i], 64, 8000);

2205

2206

ASSERT(c->chrDstH <= dstH)

2207

2208

if(flags&SWS_PRINT_INFO)

2209

{

2210

#ifdef DITHER1XBPP

2211

char *dither= " dithered";

2212

#else

2213

char *dither= "";

2214

#endif

2215

if(flags&SWS_FAST_BILINEAR)

2216

MSG_INFO("\nSwScaler: FAST_BILINEAR scaler, ");

2217

else if(flags&SWS_BILINEAR)

2218

MSG_INFO("\nSwScaler: BILINEAR scaler, ");

2219

else if(flags&SWS_BICUBIC)

2220

MSG_INFO("\nSwScaler: BICUBIC scaler, ");

2221

else if(flags&SWS_X)

2222

MSG_INFO("\nSwScaler: Experimental scaler, ");

2223

else if(flags&SWS_POINT)

2224

MSG_INFO("\nSwScaler: Nearest Neighbor / POINT scaler, ");

2225

else if(flags&SWS_AREA)

2226

MSG_INFO("\nSwScaler: Area Averageing scaler, ");

2227

else if(flags&SWS_BICUBLIN)

2228

MSG_INFO("\nSwScaler: luma BICUBIC / chroma BILINEAR scaler, ");

2229

else if(flags&SWS_GAUSS)

2230

MSG_INFO("\nSwScaler: Gaussian scaler, ");

2231

else if(flags&SWS_SINC)

2232

MSG_INFO("\nSwScaler: Sinc scaler, ");

2233

else if(flags&SWS_LANCZOS)

2234

MSG_INFO("\nSwScaler: Lanczos scaler, ");

2235

else if(flags&SWS_SPLINE)

2236

MSG_INFO("\nSwScaler: Bicubic spline scaler, ");

2237

else

2238

MSG_INFO("\nSwScaler: ehh flags invalid?! ");

2239

2240

if(dstFormat==PIX_FMT_BGR555 || dstFormat==PIX_FMT_BGR565)

2241

MSG_INFO("from %s to%s %s ",

2242

sws_format_name(srcFormat), dither, sws_format_name(dstFormat));

2243

else

2244

MSG_INFO("from %s to %s ",

2245

sws_format_name(srcFormat), sws_format_name(dstFormat));

2246

2247

if(flags & SWS_CPU_CAPS_MMX2)

2248

MSG_INFO("using MMX2\n");

2249

else if(flags & SWS_CPU_CAPS_3DNOW)

2250

MSG_INFO("using 3DNOW\n");

2251

else if(flags & SWS_CPU_CAPS_MMX)

2252

MSG_INFO("using MMX\n");

2253

else if(flags & SWS_CPU_CAPS_ALTIVEC)

2254

MSG_INFO("using AltiVec\n");

2255

else

2256

MSG_INFO("using C\n");

2257

}

2258

2259

if(flags & SWS_PRINT_INFO)

2260

{

2261

if(flags & SWS_CPU_CAPS_MMX)

2262

{

2263

if(c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))

2264

MSG_V("SwScaler: using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");

2265

else

2266

{

2267

if(c->hLumFilterSize==4)

2268

MSG_V("SwScaler: using 4-tap MMX scaler for horizontal luminance scaling\n");

2269

else if(c->hLumFilterSize==8)

2270

MSG_V("SwScaler: using 8-tap MMX scaler for horizontal luminance scaling\n");

2271

else

2272

MSG_V("SwScaler: using n-tap MMX scaler for horizontal luminance scaling\n");

2273

2274

if(c->hChrFilterSize==4)

2275

MSG_V("SwScaler: using 4-tap MMX scaler for horizontal chrominance scaling\n");

2276

else if(c->hChrFilterSize==8)

2277

MSG_V("SwScaler: using 8-tap MMX scaler for horizontal chrominance scaling\n");

2278

else

2279

MSG_V("SwScaler: using n-tap MMX scaler for horizontal chrominance scaling\n");

2280

}

2281

}

2282

else

2283

{

2284

#if defined(ARCH_X86) || defined(ARCH_X86_64)

2285

MSG_V("SwScaler: using X86-Asm scaler for horizontal scaling\n");

2286

#else

2287

if(flags & SWS_FAST_BILINEAR)

2288

MSG_V("SwScaler: using FAST_BILINEAR C scaler for horizontal scaling\n");

2289

else

2290

MSG_V("SwScaler: using C scaler for horizontal scaling\n");

2291

#endif

2292

}

2293

if(isPlanarYUV(dstFormat))

2294

{

2295

if(c->vLumFilterSize==1)

2296

MSG_V("SwScaler: using 1-tap %s \"scaler\" for vertical scaling (YV12 like)\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2297

else

2298

MSG_V("SwScaler: using n-tap %s scaler for vertical scaling (YV12 like)\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2299

}

2300

else

2301

{

2302

if(c->vLumFilterSize==1 && c->vChrFilterSize==2)

2303

MSG_V("SwScaler: using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"

2304

"SwScaler: 2-tap scaler for vertical chrominance scaling (BGR)\n",(flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2305

else if(c->vLumFilterSize==2 && c->vChrFilterSize==2)

2306

MSG_V("SwScaler: using 2-tap linear %s scaler for vertical scaling (BGR)\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2307

else

2308

MSG_V("SwScaler: using n-tap %s scaler for vertical scaling (BGR)\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2309

}

2310

2311

if(dstFormat==PIX_FMT_BGR24)

2312

MSG_V("SwScaler: using %s YV12->BGR24 Converter\n",

2313

(flags & SWS_CPU_CAPS_MMX2) ? "MMX2" : ((flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C"));

2314

else if(dstFormat==PIX_FMT_RGB32)

2315

MSG_V("SwScaler: using %s YV12->BGR32 Converter\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2316

else if(dstFormat==PIX_FMT_BGR565)

2317

MSG_V("SwScaler: using %s YV12->BGR16 Converter\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2318

else if(dstFormat==PIX_FMT_BGR555)

2319

MSG_V("SwScaler: using %s YV12->BGR15 Converter\n", (flags & SWS_CPU_CAPS_MMX) ? "MMX" : "C");

2320

2321

MSG_V("SwScaler: %dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);

2322

}

2323

if(flags & SWS_PRINT_INFO)

2324

{

2325

MSG_DBG2("SwScaler:Lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",

2326

c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);

2327

MSG_DBG2("SwScaler:Chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",

2328

c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);

2329

}

2330

2331

c->swScale= getSwsFunc(flags);

2332

return c;

2333

}

2334

2335

/**

2336

* swscale warper, so we don't need to export the SwsContext.

2337

* assumes planar YUV to be in YUV order instead of YVU

2338

2339

int sws_scale_ordered(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,

2340

int srcSliceH, uint8_t* dst[], int dstStride[]){

2341

if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {

2342

MSG_ERR("swScaler: slices start in the middle!\n");

2343

return 0;

2344

}

2345

if (c->sliceDir == 0) {

2346

if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;

2347

}

2348

2349

// copy strides, so they can safely be modified

2350

if (c->sliceDir == 1) {

2351

// slices go from top to bottom

2352

int srcStride2[3]= {srcStride[0], srcStride[1], srcStride[2]};

2353

int dstStride2[3]= {dstStride[0], dstStride[1], dstStride[2]};

2354

return c->swScale(c, src, srcStride2, srcSliceY, srcSliceH, dst, dstStride2);

2355

} else {

2356

// slices go from bottom to top => we flip the image internally

2357

uint8_t* src2[3]= {src[0] + (srcSliceH-1)*srcStride[0],

2358

src[1] + ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[1],

2359

src[2] + ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[2]

2360

};

2361

uint8_t* dst2[3]= {dst[0] + (c->dstH-1)*dstStride[0],

2362

dst[1] + ((c->dstH>>c->chrDstVSubSample)-1)*dstStride[1],

2363

dst[2] + ((c->dstH>>c->chrDstVSubSample)-1)*dstStride[2]};

2364

int srcStride2[3]= {-srcStride[0], -srcStride[1], -srcStride[2]};

2365

int dstStride2[3]= {-dstStride[0], -dstStride[1], -dstStride[2]};

2366

2367

return c->swScale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH, srcSliceH, dst2, dstStride2);

2368

}

2369

}

2370

2371

/**

2372

* swscale warper, so we don't need to export the SwsContext

2373

2374

int sws_scale(SwsContext *c, uint8_t* srcParam[], int srcStride[], int srcSliceY,

2375

int srcSliceH, uint8_t* dstParam[], int dstStride[]){

2376

uint8_t *src[3];

2377

uint8_t *dst[3];

2378

src[0] = srcParam[0]; src[1] = srcParam[1]; src[2] = srcParam[2];

2379

dst[0] = dstParam[0]; dst[1] = dstParam[1]; dst[2] = dstParam[2];

2380

//printf("sws: slice %d %d\n", srcSliceY, srcSliceH);

2381

2382

return c->swScale(c, src, srcStride, srcSliceY, srcSliceH, dst, dstStride);

2383

}

2384

2385

SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,

2386

float lumaSharpen, float chromaSharpen,

2387

float chromaHShift, float chromaVShift,

2388

int verbose)

2389

{

2390

SwsFilter *filter= av_malloc(sizeof(SwsFilter));

2391

2392

if(lumaGBlur!=0.0){

2393

filter->lumH= sws_getGaussianVec(lumaGBlur, 3.0);

2394

filter->lumV= sws_getGaussianVec(lumaGBlur, 3.0);

2395

}else{

2396

filter->lumH= sws_getIdentityVec();

2397

filter->lumV= sws_getIdentityVec();

2398

}

2399

2400

if(chromaGBlur!=0.0){

2401

filter->chrH= sws_getGaussianVec(chromaGBlur, 3.0);

2402

filter->chrV= sws_getGaussianVec(chromaGBlur, 3.0);

2403

}else{

2404

filter->chrH= sws_getIdentityVec();

2405

filter->chrV= sws_getIdentityVec();

2406

}

2407

2408

if(chromaSharpen!=0.0){

2409

SwsVector *id= sws_getIdentityVec();

2410

sws_scaleVec(filter->chrH, -chromaSharpen);

2411

sws_scaleVec(filter->chrV, -chromaSharpen);

2412

sws_addVec(filter->chrH, id);

2413

sws_addVec(filter->chrV, id);

2414

sws_freeVec(id);

2415

}

2416

2417

if(lumaSharpen!=0.0){

2418

SwsVector *id= sws_getIdentityVec();

2419

sws_scaleVec(filter->lumH, -lumaSharpen);

2420

sws_scaleVec(filter->lumV, -lumaSharpen);

2421

sws_addVec(filter->lumH, id);

2422

sws_addVec(filter->lumV, id);

2423

sws_freeVec(id);

2424

}

2425

2426

if(chromaHShift != 0.0)

2427

sws_shiftVec(filter->chrH, (int)(chromaHShift+0.5));

2428

2429

if(chromaVShift != 0.0)

2430

sws_shiftVec(filter->chrV, (int)(chromaVShift+0.5));

2431

2432

sws_normalizeVec(filter->chrH, 1.0);

2433

sws_normalizeVec(filter->chrV, 1.0);

2434

sws_normalizeVec(filter->lumH, 1.0);

2435

sws_normalizeVec(filter->lumV, 1.0);

2436

2437

if(verbose) sws_printVec(filter->chrH);

2438

if(verbose) sws_printVec(filter->lumH);

2439

2440

return filter;

2441

}

2442

2443

/**

2444

* returns a normalized gaussian curve used to filter stuff

2445

* quality=3 is high quality, lowwer is lowwer quality

2446

2447

SwsVector *sws_getGaussianVec(double variance, double quality){

2448

const int length= (int)(variance*quality + 0.5) | 1;

2449

int i;

2450

double *coeff= av_malloc(length*sizeof(double));

2451

double middle= (length-1)*0.5;

2452

SwsVector *vec= av_malloc(sizeof(SwsVector));

2453

2454

vec->coeff= coeff;

2455

vec->length= length;

2456

2457

for(i=0; i<length; i++)

2458

{

2459

double dist= i-middle;

2460

coeff[i]= exp( -dist*dist/(2*variance*variance) ) / sqrt(2*variance*PI);

2461

}

2462

2463

sws_normalizeVec(vec, 1.0);

2464

2465

return vec;

2466

}

2467

2468

SwsVector *sws_getConstVec(double c, int length){

2469

int i;

2470

double *coeff= av_malloc(length*sizeof(double));

2471

SwsVector *vec= av_malloc(sizeof(SwsVector));

2472

2473

vec->coeff= coeff;

2474

vec->length= length;

2475

2476

for(i=0; i<length; i++)

2477

coeff[i]= c;

2478

2479

return vec;

2480

}

2481

2482

2483

SwsVector *sws_getIdentityVec(void){

2484

return sws_getConstVec(1.0, 1);

2485

}

2486

2487

double sws_dcVec(SwsVector *a){

2488

int i;

2489

double sum=0;

2490

2491

for(i=0; i<a->length; i++)

2492

sum+= a->coeff[i];

2493

2494

return sum;

2495

}

2496

2497

void sws_scaleVec(SwsVector *a, double scalar){

2498

int i;

2499

2500

for(i=0; i<a->length; i++)

2501

a->coeff[i]*= scalar;

2502

}

2503

2504

void sws_normalizeVec(SwsVector *a, double height){

2505

sws_scaleVec(a, height/sws_dcVec(a));

2506

}

2507

2508

static SwsVector *sws_getConvVec(SwsVector *a, SwsVector *b){

2509

int length= a->length + b->length - 1;

2510

double *coeff= av_malloc(length*sizeof(double));

2511

int i, j;

2512

SwsVector *vec= av_malloc(sizeof(SwsVector));

2513

2514

vec->coeff= coeff;

2515

vec->length= length;

2516

2517

for(i=0; i<length; i++) coeff[i]= 0.0;

2518

2519

for(i=0; i<a->length; i++)

2520

{

2521

for(j=0; j<b->length; j++)

2522

{

2523

coeff[i+j]+= a->coeff[i]*b->coeff[j];

2524

}

2525

}

2526

2527

return vec;

2528

}

2529

2530

static SwsVector *sws_sumVec(SwsVector *a, SwsVector *b){

2531

int length= FFMAX(a->length, b->length);

2532

double *coeff= av_malloc(length*sizeof(double));

2533

int i;

2534

SwsVector *vec= av_malloc(sizeof(SwsVector));

2535

2536

vec->coeff= coeff;

2537

vec->length= length;

2538

2539

for(i=0; i<length; i++) coeff[i]= 0.0;

2540

2541

for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];

2542

for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]+= b->coeff[i];

2543

2544

return vec;

2545

}

2546

2547

static SwsVector *sws_diffVec(SwsVector *a, SwsVector *b){

2548

int length= FFMAX(a->length, b->length);

2549

double *coeff= av_malloc(length*sizeof(double));

2550

int i;

2551

SwsVector *vec= av_malloc(sizeof(SwsVector));

2552

2553

vec->coeff= coeff;

2554

vec->length= length;

2555

2556

for(i=0; i<length; i++) coeff[i]= 0.0;

2557

2558

for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];

2559

for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]-= b->coeff[i];

2560

2561

return vec;

2562

}

2563

2564

/* shift left / or right if "shift" is negative */

2565

static SwsVector *sws_getShiftedVec(SwsVector *a, int shift){

2566

int length= a->length + ABS(shift)*2;

2567

double *coeff= av_malloc(length*sizeof(double));

2568

int i;

2569

SwsVector *vec= av_malloc(sizeof(SwsVector));

2570

2571

vec->coeff= coeff;

2572

vec->length= length;

2573

2574

for(i=0; i<length; i++) coeff[i]= 0.0;

2575

2576

for(i=0; i<a->length; i++)

2577

{

2578

coeff[i + (length-1)/2 - (a->length-1)/2 - shift]= a->coeff[i];

2579

}

2580

2581

return vec;

2582

}

2583

2584

void sws_shiftVec(SwsVector *a, int shift){

2585

SwsVector *shifted= sws_getShiftedVec(a, shift);

2586

av_free(a->coeff);

2587

a->coeff= shifted->coeff;

2588

a->length= shifted->length;

2589

av_free(shifted);

2590

}

2591

2592

void sws_addVec(SwsVector *a, SwsVector *b){

2593

SwsVector *sum= sws_sumVec(a, b);

2594

av_free(a->coeff);

2595

a->coeff= sum->coeff;

2596

a->length= sum->length;

2597

av_free(sum);

2598

}

2599

2600

void sws_subVec(SwsVector *a, SwsVector *b){

2601

SwsVector *diff= sws_diffVec(a, b);

2602

av_free(a->coeff);

2603

a->coeff= diff->coeff;

2604

a->length= diff->length;

2605

av_free(diff);

2606

}

2607

2608

void sws_convVec(SwsVector *a, SwsVector *b){

2609

SwsVector *conv= sws_getConvVec(a, b);

2610

av_free(a->coeff);

2611

a->coeff= conv->coeff;

2612

a->length= conv->length;

2613

av_free(conv);

2614

}

2615

2616

SwsVector *sws_cloneVec(SwsVector *a){

2617

double *coeff= av_malloc(a->length*sizeof(double));

2618

int i;

2619

SwsVector *vec= av_malloc(sizeof(SwsVector));

2620

2621

vec->coeff= coeff;

2622

vec->length= a->length;

2623

2624

for(i=0; i<a->length; i++) coeff[i]= a->coeff[i];

2625

2626

return vec;

2627

}

2628

2629

void sws_printVec(SwsVector *a){

2630

int i;

2631

double max=0;

2632

double min=0;

2633

double range;

2634

2635

for(i=0; i<a->length; i++)

2636

if(a->coeff[i]>max) max= a->coeff[i];

2637

2638

for(i=0; i<a->length; i++)

2639

if(a->coeff[i]<min) min= a->coeff[i];

2640

2641

range= max - min;

2642

2643

for(i=0; i<a->length; i++)

2644

{

2645

int x= (int)((a->coeff[i]-min)*60.0/range +0.5);

2646

MSG_DBG2("%1.3f ", a->coeff[i]);

2647

for(;x>0; x--) MSG_DBG2(" ");

2648

MSG_DBG2("|\n");

2649

}

2650

}

2651

2652

void sws_freeVec(SwsVector *a){

2653

if(!a) return;

2654

av_free(a->coeff);

2655

a->coeff=NULL;

2656

a->length=0;

2657

av_free(a);

2658

}

2659

2660

void sws_freeFilter(SwsFilter *filter){

2661

if(!filter) return;

2662

2663

if(filter->lumH) sws_freeVec(filter->lumH);

2664

if(filter->lumV) sws_freeVec(filter->lumV);

2665

if(filter->chrH) sws_freeVec(filter->chrH);

2666

if(filter->chrV) sws_freeVec(filter->chrV);

2667

av_free(filter);

2668

}

2669

2670

2671

void sws_freeContext(SwsContext *c){

2672

int i;

2673

if(!c) return;

2674

2675

if(c->lumPixBuf)

2676

{

2677

for(i=0; i<c->vLumBufSize; i++)

2678

{

2679

av_free(c->lumPixBuf[i]);

2680

c->lumPixBuf[i]=NULL;

2681

}

2682

av_free(c->lumPixBuf);

2683

c->lumPixBuf=NULL;

2684

}

2685

2686

if(c->chrPixBuf)

2687

{

2688

for(i=0; i<c->vChrBufSize; i++)

2689

{

2690

av_free(c->chrPixBuf[i]);

2691

c->chrPixBuf[i]=NULL;

2692

}

2693

av_free(c->chrPixBuf);

2694

c->chrPixBuf=NULL;

2695

}

2696

2697

av_free(c->vLumFilter);

2698

c->vLumFilter = NULL;

2699

av_free(c->vChrFilter);

2700

c->vChrFilter = NULL;

2701

av_free(c->hLumFilter);

2702

c->hLumFilter = NULL;

2703

av_free(c->hChrFilter);

2704

c->hChrFilter = NULL;

2705

#ifdef HAVE_ALTIVEC

2706

av_free(c->vYCoeffsBank);

2707

c->vYCoeffsBank = NULL;

2708

av_free(c->vCCoeffsBank);

2709

c->vCCoeffsBank = NULL;

2710

#endif

2711

2712

av_free(c->vLumFilterPos);

2713

c->vLumFilterPos = NULL;

2714

av_free(c->vChrFilterPos);

2715

c->vChrFilterPos = NULL;

2716

av_free(c->hLumFilterPos);

2717

c->hLumFilterPos = NULL;

2718

av_free(c->hChrFilterPos);

2719

c->hChrFilterPos = NULL;

2720

2721

#if defined(ARCH_X86) || defined(ARCH_X86_64)

2722

#ifdef MAP_ANONYMOUS

2723

if(c->funnyYCode) munmap(c->funnyYCode, MAX_FUNNY_CODE_SIZE);

2724

if(c->funnyUVCode) munmap(c->funnyUVCode, MAX_FUNNY_CODE_SIZE);

2725

#else

2726

av_free(c->funnyYCode);

2727

av_free(c->funnyUVCode);

2728

#endif

2729

c->funnyYCode=NULL;

2730

c->funnyUVCode=NULL;

2731

#endif /* defined(ARCH_X86) || defined(ARCH_X86_64) */

2732

2733

av_free(c->lumMmx2Filter);

2734

c->lumMmx2Filter=NULL;

2735

av_free(c->chrMmx2Filter);

2736

c->chrMmx2Filter=NULL;

2737

av_free(c->lumMmx2FilterPos);

2738

c->lumMmx2FilterPos=NULL;

2739

av_free(c->chrMmx2FilterPos);

2740

c->chrMmx2FilterPos=NULL;

2741

av_free(c->yuvTable);

2742

c->yuvTable=NULL;

2743

2744

av_free(c);

2745

}

2746

2747

/**

2748

* Checks if context is valid or reallocs a new one instead.

2749

* If context is NULL, just calls sws_getContext() to get a new one.

2750

* Otherwise, checks if the parameters are the same already saved in context.

2751

* If that is the case, returns the current context.

2752

* Otherwise, frees context and gets a new one.

2753

2754

* Be warned that srcFilter, dstFilter are not checked, they are

2755

* asumed to remain valid.

2756

2757

struct SwsContext *sws_getCachedContext(struct SwsContext *context,

2758

int srcW, int srcH, int srcFormat,

2759

int dstW, int dstH, int dstFormat, int flags,

2760

SwsFilter *srcFilter, SwsFilter *dstFilter, double *param)

2761

{

2762

if (context != NULL) {

2763

if ((context->srcW != srcW) || (context->srcH != srcH) ||

2764

(context->srcFormat != srcFormat) ||

2765

(context->dstW != dstW) || (context->dstH != dstH) ||

2766

(context->dstFormat != dstFormat) || (context->flags != flags) ||

2767

(context->param != param))

2768

{

2769

sws_freeContext(context);

2770

context = NULL;

2771

}

2772

}

2773

if (context == NULL) {

2774

return sws_getContext(srcW, srcH, srcFormat,

2775

dstW, dstH, dstFormat, flags,

2776

srcFilter, dstFilter, param);

2777

}

2778

return context;

2779

}

2780

Older »