~diresu/blender/blender-command-port

else if (srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)

2540

{

2541

RENAME(palToY)(formatConvBuffer, src, srcW, pal);

2542

src= formatConvBuffer;

2543

}

2544

2545

#ifdef HAVE_MMX

2546

// use the new MMX scaler if the mmx2 can't be used (it is faster than the x86 ASM one)

2547

if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))

2548

#else

2549

if (!(flags&SWS_FAST_BILINEAR))

2550

#endif

2551

{

2552

RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);

2553

}

2554

else // Fast Bilinear upscale / crap downscale

2555

{

2556

#if defined(ARCH_X86)

2557

#ifdef HAVE_MMX2

2558

int i;

2559

#if defined(PIC)

2560

uint64_t ebxsave __attribute__((aligned(8)));

2561

#endif

2562

if (canMMX2BeUsed)

2563

{

2564

asm volatile(

2565

#if defined(PIC)

2566

"mov %%"REG_b", %5 \n\t"

2567

#endif

2568

"pxor %%mm7, %%mm7 \n\t"

2569

"mov %0, %%"REG_c" \n\t"

2570

"mov %1, %%"REG_D" \n\t"

2571

"mov %2, %%"REG_d" \n\t"

2572

"mov %3, %%"REG_b" \n\t"

2573

"xor %%"REG_a", %%"REG_a" \n\t" // i

2574

PREFETCH" (%%"REG_c") \n\t"

2575

PREFETCH" 32(%%"REG_c") \n\t"

2576

PREFETCH" 64(%%"REG_c") \n\t"

2577

2578

#ifdef ARCH_X86_64

2579

2580

#define FUNNY_Y_CODE \

2581

"movl (%%"REG_b"), %%esi \n\t"\

2582

"call *%4 \n\t"\

2583

"movl (%%"REG_b", %%"REG_a"), %%esi \n\t"\

2584

"add %%"REG_S", %%"REG_c" \n\t"\

2585

"add %%"REG_a", %%"REG_D" \n\t"\

2586

"xor %%"REG_a", %%"REG_a" \n\t"\

2587

2588

#else

2589

2590

#define FUNNY_Y_CODE \

2591

"movl (%%"REG_b"), %%esi \n\t"\

2592

"call *%4 \n\t"\

2593

"addl (%%"REG_b", %%"REG_a"), %%"REG_c" \n\t"\

2594

"add %%"REG_a", %%"REG_D" \n\t"\

2595

"xor %%"REG_a", %%"REG_a" \n\t"\

2596

2597

#endif

2598

2599

FUNNY_Y_CODE

2600

FUNNY_Y_CODE

2601

FUNNY_Y_CODE

2602

FUNNY_Y_CODE

2603

FUNNY_Y_CODE

2604

FUNNY_Y_CODE

2605

FUNNY_Y_CODE

2606

FUNNY_Y_CODE

2607

2608

#if defined(PIC)

2609

"mov %5, %%"REG_b" \n\t"

2610

#endif

2611

:: "m" (src), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),

2612

"m" (funnyYCode)

2613

#if defined(PIC)

2614

,"m" (ebxsave)

2615

#endif

2616

: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D

2617

#if !defined(PIC)

2618

,"%"REG_b

2619

#endif

2620

);

2621

for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;

2622

}

2623

else

2624

{

2625

#endif

2626

long xInc_shr16 = xInc >> 16;

2627

uint16_t xInc_mask = xInc & 0xffff;

2628

//NO MMX just normal asm ...

2629

asm volatile(

2630

"xor %%"REG_a", %%"REG_a" \n\t" // i

2631

"xor %%"REG_d", %%"REG_d" \n\t" // xx

2632

"xorl %%ecx, %%ecx \n\t" // 2*xalpha

2633

ASMALIGN(4)

2634

"1: \n\t"

2635

"movzbl (%0, %%"REG_d"), %%edi \n\t" //src[xx]

2636

"movzbl 1(%0, %%"REG_d"), %%esi \n\t" //src[xx+1]

2637

"subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]

2638

"imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha

2639

"shll $16, %%edi \n\t"

2640

"addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

2641

"mov %1, %%"REG_D" \n\t"

2642

"shrl $9, %%esi \n\t"

2643

"movw %%si, (%%"REG_D", %%"REG_a", 2) \n\t"

2644

"addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF

2645

"adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry

2646

2647

"movzbl (%0, %%"REG_d"), %%edi \n\t" //src[xx]

2648

"movzbl 1(%0, %%"REG_d"), %%esi \n\t" //src[xx+1]

2649

"subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]

2650

"imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha

2651

"shll $16, %%edi \n\t"

2652

"addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

2653

"mov %1, %%"REG_D" \n\t"

2654

"shrl $9, %%esi \n\t"

2655

"movw %%si, 2(%%"REG_D", %%"REG_a", 2) \n\t"

2656

"addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF

2657

"adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry

2658

2659

2660

"add $2, %%"REG_a" \n\t"

2661

"cmp %2, %%"REG_a" \n\t"

2662

" jb 1b \n\t"

2663

2664

2665

:: "r" (src), "m" (dst), "m" (dstWidth), "m" (xInc_shr16), "m" (xInc_mask)

2666

: "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"

2667

);

2668

#ifdef HAVE_MMX2

2669

} //if MMX2 can't be used

2670

#endif

2671

#else

2672

int i;

2673

unsigned int xpos=0;

2674

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

2675

{

2676

2677

2678

dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;

2679

xpos+=xInc;

2680

}

2681

#endif

2682

}

2683

}

2684

2685

inline static void RENAME(hcscale)(uint16_t *dst, long dstWidth, uint8_t *src1, uint8_t *src2,

2686

int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,

2687

int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode,

2688

int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,

2689

int32_t *mmx2FilterPos, uint8_t *pal)

2690

{

2691

if (srcFormat==PIX_FMT_YUYV422)

2692

{

2693

RENAME(yuy2ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2694

src1= formatConvBuffer;

2695

src2= formatConvBuffer+2048;

2696

}

2697

else if (srcFormat==PIX_FMT_UYVY422)

2698

{

2699

RENAME(uyvyToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2700

src1= formatConvBuffer;

2701

src2= formatConvBuffer+2048;

2702

}

2703

else if (srcFormat==PIX_FMT_RGB32)

2704

{

2705

RENAME(bgr32ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2706

src1= formatConvBuffer;

2707

src2= formatConvBuffer+2048;

2708

}

2709

else if (srcFormat==PIX_FMT_BGR24)

2710

{

2711

RENAME(bgr24ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2712

src1= formatConvBuffer;

2713

src2= formatConvBuffer+2048;

2714

}

2715

else if (srcFormat==PIX_FMT_BGR565)

2716

{

2717

RENAME(bgr16ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2718

src1= formatConvBuffer;

2719

src2= formatConvBuffer+2048;

2720

}

2721

else if (srcFormat==PIX_FMT_BGR555)

2722

{

2723

RENAME(bgr15ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2724

src1= formatConvBuffer;

2725

src2= formatConvBuffer+2048;

2726

}

2727

else if (srcFormat==PIX_FMT_BGR32)

2728

{

2729

RENAME(rgb32ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2730

src1= formatConvBuffer;

2731

src2= formatConvBuffer+2048;

2732

}

2733

else if (srcFormat==PIX_FMT_RGB24)

2734

{

2735

RENAME(rgb24ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2736

src1= formatConvBuffer;

2737

src2= formatConvBuffer+2048;

2738

}

2739

else if (srcFormat==PIX_FMT_RGB565)

2740

{

2741

RENAME(rgb16ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2742

src1= formatConvBuffer;

2743

src2= formatConvBuffer+2048;

2744

}

2745

else if (srcFormat==PIX_FMT_RGB555)

2746

{

2747

RENAME(rgb15ToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW);

2748

src1= formatConvBuffer;

2749

src2= formatConvBuffer+2048;

2750

}

2751

else if (isGray(srcFormat))

2752

{

2753

return;

2754

}

2755

else if (srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)

2756

{

2757

RENAME(palToUV)(formatConvBuffer, formatConvBuffer+2048, src1, src2, srcW, pal);

2758

src1= formatConvBuffer;

2759

src2= formatConvBuffer+2048;

2760

}

2761

2762

#ifdef HAVE_MMX

2763

// use the new MMX scaler if the mmx2 can't be used (it is faster than the x86 ASM one)

2764

if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))

2765

#else

2766

if (!(flags&SWS_FAST_BILINEAR))

2767

#endif

2768

{

2769

RENAME(hScale)(dst , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);

2770

RENAME(hScale)(dst+2048, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);

2771

}

2772

else // Fast Bilinear upscale / crap downscale

2773

{

2774

#if defined(ARCH_X86)

2775

#ifdef HAVE_MMX2

2776

int i;

2777

#if defined(PIC)

2778

uint64_t ebxsave __attribute__((aligned(8)));

2779

#endif

2780

if (canMMX2BeUsed)

2781

{

2782

asm volatile(

2783

#if defined(PIC)

2784

"mov %%"REG_b", %6 \n\t"

2785

#endif

2786

"pxor %%mm7, %%mm7 \n\t"

2787

"mov %0, %%"REG_c" \n\t"

2788

"mov %1, %%"REG_D" \n\t"

2789

"mov %2, %%"REG_d" \n\t"

2790

"mov %3, %%"REG_b" \n\t"

2791

"xor %%"REG_a", %%"REG_a" \n\t" // i

2792

PREFETCH" (%%"REG_c") \n\t"

2793

PREFETCH" 32(%%"REG_c") \n\t"

2794

PREFETCH" 64(%%"REG_c") \n\t"

2795

2796

#ifdef ARCH_X86_64

2797

2798

#define FUNNY_UV_CODE \

2799

"movl (%%"REG_b"), %%esi \n\t"\

2800

"call *%4 \n\t"\

2801

"movl (%%"REG_b", %%"REG_a"), %%esi \n\t"\

2802

"add %%"REG_S", %%"REG_c" \n\t"\

2803

"add %%"REG_a", %%"REG_D" \n\t"\

2804

"xor %%"REG_a", %%"REG_a" \n\t"\

2805

2806

#else

2807

2808

#define FUNNY_UV_CODE \

2809

"movl (%%"REG_b"), %%esi \n\t"\

2810

"call *%4 \n\t"\

2811

"addl (%%"REG_b", %%"REG_a"), %%"REG_c" \n\t"\

2812

"add %%"REG_a", %%"REG_D" \n\t"\

2813

"xor %%"REG_a", %%"REG_a" \n\t"\

2814

2815

#endif

2816

2817

FUNNY_UV_CODE

2818

FUNNY_UV_CODE

2819

FUNNY_UV_CODE

2820

FUNNY_UV_CODE

2821

"xor %%"REG_a", %%"REG_a" \n\t" // i

2822

"mov %5, %%"REG_c" \n\t" // src

2823

"mov %1, %%"REG_D" \n\t" // buf1

2824

"add $4096, %%"REG_D" \n\t"

2825

PREFETCH" (%%"REG_c") \n\t"

2826

PREFETCH" 32(%%"REG_c") \n\t"

2827

PREFETCH" 64(%%"REG_c") \n\t"

2828

2829

FUNNY_UV_CODE

2830

FUNNY_UV_CODE

2831

FUNNY_UV_CODE

2832

FUNNY_UV_CODE

2833

2834

#if defined(PIC)

2835

"mov %6, %%"REG_b" \n\t"

2836

#endif

2837

:: "m" (src1), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),

2838

"m" (funnyUVCode), "m" (src2)

2839

#if defined(PIC)

2840

,"m" (ebxsave)

2841

#endif

2842

: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D

2843

#if !defined(PIC)

2844

,"%"REG_b

2845

#endif

2846

);

2847

for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--)

2848

{

2849

//printf("%d %d %d\n", dstWidth, i, srcW);

2850

dst[i] = src1[srcW-1]*128;

2851

dst[i+2048] = src2[srcW-1]*128;

2852

}

2853

}

2854

else

2855

{

2856

#endif

2857

long xInc_shr16 = (long) (xInc >> 16);

2858

uint16_t xInc_mask = xInc & 0xffff;

2859

asm volatile(

2860

"xor %%"REG_a", %%"REG_a" \n\t" // i

2861

"xor %%"REG_d", %%"REG_d" \n\t" // xx

2862

"xorl %%ecx, %%ecx \n\t" // 2*xalpha

2863

ASMALIGN(4)

2864

"1: \n\t"

2865

"mov %0, %%"REG_S" \n\t"

2866

"movzbl (%%"REG_S", %%"REG_d"), %%edi \n\t" //src[xx]

2867

"movzbl 1(%%"REG_S", %%"REG_d"), %%esi \n\t" //src[xx+1]

2868

"subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]

2869

"imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha

2870

"shll $16, %%edi \n\t"

2871

"addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

2872

"mov %1, %%"REG_D" \n\t"

2873

"shrl $9, %%esi \n\t"

2874

"movw %%si, (%%"REG_D", %%"REG_a", 2) \n\t"

2875

2876

"movzbl (%5, %%"REG_d"), %%edi \n\t" //src[xx]

2877

"movzbl 1(%5, %%"REG_d"), %%esi \n\t" //src[xx+1]

2878

"subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]

2879

"imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha

2880

"shll $16, %%edi \n\t"

2881

"addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

2882

"mov %1, %%"REG_D" \n\t"

2883

"shrl $9, %%esi \n\t"

2884

"movw %%si, 4096(%%"REG_D", %%"REG_a", 2) \n\t"

2885

2886

"addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF

2887

"adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry

2888

"add $1, %%"REG_a" \n\t"

2889

"cmp %2, %%"REG_a" \n\t"

2890

" jb 1b \n\t"

2891

2892

/* GCC-3.3 makes MPlayer crash on IA-32 machines when using "g" operand here,

2893

which is needed to support GCC-4.0 */

2894

#if defined(ARCH_X86_64) && ((__GNUC__ > 3) || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 4))

2895

:: "m" (src1), "m" (dst), "g" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),

2896

#else

2897

:: "m" (src1), "m" (dst), "m" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),

2898

#endif

2899

"r" (src2)

2900

: "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"

2901

);

2902

#ifdef HAVE_MMX2

2903

} //if MMX2 can't be used

2904

#endif

2905

#else

2906

int i;

2907

unsigned int xpos=0;

2908

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

2909

{

2910

2911

2912

dst[i]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);

2913

dst[i+2048]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);

2914

/* slower

2915

dst[i]= (src1[xx]<<7) + (src1[xx+1] - src1[xx])*xalpha;

2916

dst[i+2048]=(src2[xx]<<7) + (src2[xx+1] - src2[xx])*xalpha;

2917

2918

xpos+=xInc;

2919

}

2920

#endif

2921

}

2922

}

2923

2924

static int RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,

2925

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

2926

2927

/* load a few things into local vars to make the code more readable? and faster */

2928

const int srcW= c->srcW;

2929

const int dstW= c->dstW;

2930

const int dstH= c->dstH;

2931

const int chrDstW= c->chrDstW;

2932

const int chrSrcW= c->chrSrcW;

2933

const int lumXInc= c->lumXInc;

2934

const int chrXInc= c->chrXInc;

2935

const int dstFormat= c->dstFormat;

2936

const int srcFormat= c->srcFormat;

2937

const int flags= c->flags;

2938

const int canMMX2BeUsed= c->canMMX2BeUsed;

2939

int16_t *vLumFilterPos= c->vLumFilterPos;

2940

int16_t *vChrFilterPos= c->vChrFilterPos;

2941

int16_t *hLumFilterPos= c->hLumFilterPos;

2942

int16_t *hChrFilterPos= c->hChrFilterPos;

2943

int16_t *vLumFilter= c->vLumFilter;

2944

int16_t *vChrFilter= c->vChrFilter;

2945

int16_t *hLumFilter= c->hLumFilter;

2946

int16_t *hChrFilter= c->hChrFilter;

2947

int32_t *lumMmxFilter= c->lumMmxFilter;

2948

int32_t *chrMmxFilter= c->chrMmxFilter;

2949

const int vLumFilterSize= c->vLumFilterSize;

2950

const int vChrFilterSize= c->vChrFilterSize;

2951

const int hLumFilterSize= c->hLumFilterSize;

2952

const int hChrFilterSize= c->hChrFilterSize;

2953

int16_t **lumPixBuf= c->lumPixBuf;

2954

int16_t **chrPixBuf= c->chrPixBuf;

2955

const int vLumBufSize= c->vLumBufSize;

2956

const int vChrBufSize= c->vChrBufSize;

2957

uint8_t *funnyYCode= c->funnyYCode;

2958

uint8_t *funnyUVCode= c->funnyUVCode;

2959

uint8_t *formatConvBuffer= c->formatConvBuffer;

2960

const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;

2961

const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);

2962

int lastDstY;

2963

uint8_t *pal=NULL;

2964

2965

/* vars whch will change and which we need to storw back in the context */

2966

int dstY= c->dstY;

2967

int lumBufIndex= c->lumBufIndex;

2968

int chrBufIndex= c->chrBufIndex;

2969

int lastInLumBuf= c->lastInLumBuf;

2970

int lastInChrBuf= c->lastInChrBuf;

2971

2972

if (isPacked(c->srcFormat)){

2973

pal= src[1];

2974

src[0]=

2975

src[1]=

2976

src[2]= src[0];

2977

srcStride[0]=

2978

srcStride[1]=

2979

srcStride[2]= srcStride[0];

2980

}

2981

srcStride[1]<<= c->vChrDrop;

2982

srcStride[2]<<= c->vChrDrop;

2983

2984

//printf("swscale %X %X %X -> %X %X %X\n", (int)src[0], (int)src[1], (int)src[2],

2985

// (int)dst[0], (int)dst[1], (int)dst[2]);

2986

2987

#if 0 //self test FIXME move to a vfilter or something

2988

{

2989

static volatile int i=0;

2990

i++;

2991

if (srcFormat==PIX_FMT_YUV420P && i==1 && srcSliceH>= c->srcH)

2992

selfTest(src, srcStride, c->srcW, c->srcH);

2993

i--;

2994

}

2995

#endif

2996

2997

//printf("sws Strides:%d %d %d -> %d %d %d\n", srcStride[0],srcStride[1],srcStride[2],

2998

//dstStride[0],dstStride[1],dstStride[2]);

2999

3000

if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0)

3001

{

3002

static int firstTime=1; //FIXME move this into the context perhaps

3003

if (flags & SWS_PRINT_INFO && firstTime)

3004

{

3005

av_log(c, AV_LOG_WARNING, "SwScaler: Warning: dstStride is not aligned!\n"

3006

"SwScaler: ->cannot do aligned memory acesses anymore\n");

3007

firstTime=0;

3008

}

3009

}

3010

3011

/* Note the user might start scaling the picture in the middle so this will not get executed

3012

this is not really intended but works currently, so ppl might do it */

3013

if (srcSliceY ==0){

3014

lumBufIndex=0;

3015

chrBufIndex=0;

3016

dstY=0;

3017

lastInLumBuf= -1;

3018

lastInChrBuf= -1;

3019

}

3020

3021

lastDstY= dstY;

3022

3023

for (;dstY < dstH; dstY++){

3024

unsigned char *dest =dst[0]+dstStride[0]*dstY;

3025

const int chrDstY= dstY>>c->chrDstVSubSample;

3026

unsigned char *uDest=dst[1]+dstStride[1]*chrDstY;

3027

unsigned char *vDest=dst[2]+dstStride[2]*chrDstY;

3028

3029

const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input

3030

const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input

3031

const int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input

3032

const int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input

3033

3034

//printf("dstY:%d dstH:%d firstLumSrcY:%d lastInLumBuf:%d vLumBufSize: %d vChrBufSize: %d slice: %d %d vLumFilterSize: %d firstChrSrcY: %d vChrFilterSize: %d c->chrSrcVSubSample: %d\n",

3035

// dstY, dstH, firstLumSrcY, lastInLumBuf, vLumBufSize, vChrBufSize, srcSliceY, srcSliceH, vLumFilterSize, firstChrSrcY, vChrFilterSize, c->chrSrcVSubSample);

3036

//handle holes (FAST_BILINEAR & weird filters)

3037

if (firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;

3038

if (firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;

3039

//printf("%d %d %d\n", firstChrSrcY, lastInChrBuf, vChrBufSize);

3040

ASSERT(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1)

3041

ASSERT(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1)

3042

3043

// Do we have enough lines in this slice to output the dstY line

3044

if (lastLumSrcY < srcSliceY + srcSliceH && lastChrSrcY < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample))

3045

{

3046

//Do horizontal scaling

3047

while(lastInLumBuf < lastLumSrcY)

3048

{

3049

uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

3050

lumBufIndex++;

3051

//printf("%d %d %d %d\n", lumBufIndex, vLumBufSize, lastInLumBuf, lastLumSrcY);

3052

ASSERT(lumBufIndex < 2*vLumBufSize)

3053

ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)

3054

ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)

3055

//printf("%d %d\n", lumBufIndex, vLumBufSize);

3056

RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,

3057

flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,

3058

funnyYCode, c->srcFormat, formatConvBuffer,

3059

c->lumMmx2Filter, c->lumMmx2FilterPos, pal);

3060

lastInLumBuf++;

3061

}

3062

while(lastInChrBuf < lastChrSrcY)

3063

{

3064

uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];

3065

uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];

3066

chrBufIndex++;

3067

ASSERT(chrBufIndex < 2*vChrBufSize)

3068

ASSERT(lastInChrBuf + 1 - chrSrcSliceY < (chrSrcSliceH))

3069

ASSERT(lastInChrBuf + 1 - chrSrcSliceY >= 0)

3070

//FIXME replace parameters through context struct (some at least)

3071

3072

if (!(isGray(srcFormat) || isGray(dstFormat)))

3073

RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,

3074

flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,

3075

funnyUVCode, c->srcFormat, formatConvBuffer,

3076

c->chrMmx2Filter, c->chrMmx2FilterPos, pal);

3077

lastInChrBuf++;

3078

}

3079

//wrap buf index around to stay inside the ring buffer

3080

if (lumBufIndex >= vLumBufSize ) lumBufIndex-= vLumBufSize;

3081

if (chrBufIndex >= vChrBufSize ) chrBufIndex-= vChrBufSize;

3082

}

3083

else // not enough lines left in this slice -> load the rest in the buffer

3084

{

3085

/* printf("%d %d Last:%d %d LastInBuf:%d %d Index:%d %d Y:%d FSize: %d %d BSize: %d %d\n",

3086

firstChrSrcY,firstLumSrcY,lastChrSrcY,lastLumSrcY,

3087

lastInChrBuf,lastInLumBuf,chrBufIndex,lumBufIndex,dstY,vChrFilterSize,vLumFilterSize,

3088

vChrBufSize, vLumBufSize);*/

3089

3090

//Do horizontal scaling

3091

while(lastInLumBuf+1 < srcSliceY + srcSliceH)

3092

{

3093

uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

3094

lumBufIndex++;

3095

ASSERT(lumBufIndex < 2*vLumBufSize)

3096

ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)

3097

ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)

3098

RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,

3099

flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,

3100

funnyYCode, c->srcFormat, formatConvBuffer,

3101

c->lumMmx2Filter, c->lumMmx2FilterPos, pal);

3102

lastInLumBuf++;

3103

}

3104

while(lastInChrBuf+1 < (chrSrcSliceY + chrSrcSliceH))

3105

{

3106

uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];

3107

uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];

3108

chrBufIndex++;

3109

ASSERT(chrBufIndex < 2*vChrBufSize)

3110

ASSERT(lastInChrBuf + 1 - chrSrcSliceY < chrSrcSliceH)

3111

ASSERT(lastInChrBuf + 1 - chrSrcSliceY >= 0)

3112

3113

if (!(isGray(srcFormat) || isGray(dstFormat)))

3114

RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,

3115

flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,

3116

funnyUVCode, c->srcFormat, formatConvBuffer,

3117

c->chrMmx2Filter, c->chrMmx2FilterPos, pal);

3118

lastInChrBuf++;

3119

}

3120

//wrap buf index around to stay inside the ring buffer

3121

if (lumBufIndex >= vLumBufSize ) lumBufIndex-= vLumBufSize;

3122

if (chrBufIndex >= vChrBufSize ) chrBufIndex-= vChrBufSize;

3123

break; //we can't output a dstY line so let's try with the next slice

3124

}

3125

3126

#ifdef HAVE_MMX

3127

b5Dither= dither8[dstY&1];

3128

g6Dither= dither4[dstY&1];

3129

g5Dither= dither8[dstY&1];

3130

r5Dither= dither8[(dstY+1)&1];

3131

#endif

3132

if (dstY < dstH-2)

3133

{

3134

int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

3135

int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

3136

#ifdef HAVE_MMX

3137

int i;

3138

if (flags & SWS_ACCURATE_RND){

3139

for (i=0; i<vLumFilterSize; i+=2){

3140

lumMmxFilter[2*i+0]= (int32_t)lumSrcPtr[i ];

3141

lumMmxFilter[2*i+1]= (int32_t)lumSrcPtr[i+(vLumFilterSize>1)];

3142

lumMmxFilter[2*i+2]=

3143

lumMmxFilter[2*i+3]= vLumFilter[dstY*vLumFilterSize + i ]

3144

+ (vLumFilterSize>1 ? vLumFilter[dstY*vLumFilterSize + i + 1]<<16 : 0);

3145

}

3146

for (i=0; i<vChrFilterSize; i+=2){

3147

chrMmxFilter[2*i+0]= (int32_t)chrSrcPtr[i ];

3148

chrMmxFilter[2*i+1]= (int32_t)chrSrcPtr[i+(vChrFilterSize>1)];

3149

chrMmxFilter[2*i+2]=

3150

chrMmxFilter[2*i+3]= vChrFilter[chrDstY*vChrFilterSize + i ]

3151

+ (vChrFilterSize>1 ? vChrFilter[chrDstY*vChrFilterSize + i + 1]<<16 : 0);

3152

}

3153

}else{

3154

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

3155

{

3156

lumMmxFilter[4*i+0]= (int32_t)lumSrcPtr[i];

3157

lumMmxFilter[4*i+1]= (uint64_t)lumSrcPtr[i] >> 32;

3158

lumMmxFilter[4*i+2]=

3159

lumMmxFilter[4*i+3]=

3160

((uint16_t)vLumFilter[dstY*vLumFilterSize + i])*0x10001;

3161

}

3162

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

3163

{

3164

chrMmxFilter[4*i+0]= (int32_t)chrSrcPtr[i];

3165

chrMmxFilter[4*i+1]= (uint64_t)chrSrcPtr[i] >> 32;

3166

chrMmxFilter[4*i+2]=

3167

chrMmxFilter[4*i+3]=

3168

((uint16_t)vChrFilter[chrDstY*vChrFilterSize + i])*0x10001;

3169

}

3170

}

3171

#endif

3172

if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21){

3173

const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

3174

if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi

3175

RENAME(yuv2nv12X)(c,

3176

vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,

3177

vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

3178

dest, uDest, dstW, chrDstW, dstFormat);

3179

}

3180

else if (isPlanarYUV(dstFormat) || isGray(dstFormat)) //YV12 like

3181

{

3182

const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

3183

if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

3184

if (vLumFilterSize == 1 && vChrFilterSize == 1) // Unscaled YV12

3185

{

3186

int16_t *lumBuf = lumPixBuf[0];

3187

int16_t *chrBuf= chrPixBuf[0];

3188

RENAME(yuv2yuv1)(lumBuf, chrBuf, dest, uDest, vDest, dstW, chrDstW);

3189

}

3190

else //General YV12

3191

{

3192

RENAME(yuv2yuvX)(c,

3193

vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,

3194

vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

3195

dest, uDest, vDest, dstW, chrDstW);

3196

}

3197

}

3198

else

3199

{

3200

ASSERT(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

3201

ASSERT(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

3202

if (vLumFilterSize == 1 && vChrFilterSize == 2) //Unscaled RGB

3203

{

3204

int chrAlpha= vChrFilter[2*dstY+1];

3205

RENAME(yuv2packed1)(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),

3206

dest, dstW, chrAlpha, dstFormat, flags, dstY);

3207

}

3208

else if (vLumFilterSize == 2 && vChrFilterSize == 2) //BiLinear Upscale RGB

3209

{

3210

int lumAlpha= vLumFilter[2*dstY+1];

3211

int chrAlpha= vChrFilter[2*dstY+1];

3212

lumMmxFilter[2]=

3213

lumMmxFilter[3]= vLumFilter[2*dstY ]*0x10001;

3214

chrMmxFilter[2]=

3215

chrMmxFilter[3]= vChrFilter[2*chrDstY]*0x10001;

3216

RENAME(yuv2packed2)(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),

3217

dest, dstW, lumAlpha, chrAlpha, dstY);

3218

}

3219

else //General RGB

3220

{

3221

RENAME(yuv2packedX)(c,

3222

vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

3223

vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

3224

dest, dstW, dstY);

3225

}

3226

}

3227

}

3228

else // hmm looks like we can't use MMX here without overwriting this array's tail

3229

{

3230

int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

3231

int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

3232

if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21){

3233

const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

3234

if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi

3235

yuv2nv12XinC(

3236

vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,

3237

vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

3238

dest, uDest, dstW, chrDstW, dstFormat);

3239

}

3240

else if (isPlanarYUV(dstFormat) || isGray(dstFormat)) //YV12

3241

{

3242

const int chrSkipMask= (1<<c->chrDstVSubSample)-1;

3243

if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

3244

yuv2yuvXinC(

3245

vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,

3246

vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

3247

dest, uDest, vDest, dstW, chrDstW);

3248

}

3249

else

3250

{

3251

ASSERT(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

3252

ASSERT(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

3253

yuv2packedXinC(c,

3254

vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

3255

vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

3256

dest, dstW, dstY);

3257

}

3258

}

3259

}

3260

3261

#ifdef HAVE_MMX

3262

__asm __volatile(SFENCE:::"memory");

3263

__asm __volatile(EMMS:::"memory");

3264

#endif

3265

/* store changed local vars back in the context */

3266

c->dstY= dstY;

3267

c->lumBufIndex= lumBufIndex;

3268

c->chrBufIndex= chrBufIndex;

3269

c->lastInLumBuf= lastInLumBuf;

3270

c->lastInChrBuf= lastInChrBuf;

3271

3272

return dstY - lastDstY;

3273

}

Older »