быстрее чем так
можно на ассемблере
у кого есть идеи

origBuffer это оригинальный yuy2 кадр, мне из него нужные только нечетные столбики.

if (IsEqualGUID(mtype_, MEDIASUBTYPE_YUY2)) {

unsigned char* src;
unsigned char* dst;

buffer = (unsigned char*)calloc(width_* height_, sizeof(unsigned char));

src = origBuffer;
dst = buffer;

register size_t rowIdx, colIdx;
for (rowIdx = height_; rowIdx--; ) {
for (colIdx = width_; colIdx--{
*dst++ = (src += 2)[-2];
}
src += align_;
}
}

Здравствуйте, Aleksey Skurihin, Вы писали:

AS>if (IsEqualGUID(mtype_, MEDIASUBTYPE_YUY2)) {

AS> unsigned char* src;
AS> unsigned char* dst;

AS> buffer = (unsigned char*)calloc(width_* height_, sizeof(unsigned char));

AS> src = origBuffer;
AS> dst = buffer;

AS> register size_t rowIdx, colIdx;
AS> for (rowIdx = height_; rowIdx--; ) {
AS> for (colIdx = width_; colIdx--{
AS> *dst++ = (src += 2)[-2];
AS> }
AS> src += align_;
AS> }
AS> }


Не обязательно заниматься такой обфускацией кода. Практически невозможно понять что делает вот это "*dst++ = (src += 2)[-2]". Можно записать это по-нормальному — по одному оператору на строчке — компилятор сгенерирует идентичный код.

Основное, что хотелось бы понять — копируемый столбик лежит непрерывно в памяти или нет?
Какая раскладка исходной матрицы в памяти? Какого размера столбик? И какого размера строки?

Здравствуйте, Aleksey Skurihin, Вы писали:

AS>у кого есть идеи

попробуй в цикле звать такую функцию

inline void stripped_copy( T* dst, const T* srcl int dst_count )
{
    for* int i = 0; i < dst_count; i++ ) {
        dst[i] = src[i * 2];
    }
}

Очень даже может быть, что для небольших стандартных T она будет быстрее твонй...

Здравствуйте, Aleksey Skurihin, Вы писали:

AS>origBuffer это оригинальный yuy2 кадр, мне из него нужные только нечетные столбики.

Конечно, premature optimization is..., как мы все помним из серии стикеров на жувачках.
Но я попробую.

size_t const srcw = ...; // ширина исходного буфера
size_t const height = ...; // высота
unsigned char const* src;

size_t const dstw = srcw/2;
unsigned char* dst = malloc(height*dstw);

// лобовое решение
for(y=0; y<height; ++y)
    for(x=0; x<dstw; ++x)
        dst[y*dstw + x] = src[y*srcw + x*2];

// на случай, если компилятор тупой
for(y=0; y<height; ++y, src+=srcw%2)
    for(x=0; x<dstw; ++x, ++dst, ++src)
        *dst = *src;

// продвинутое решение: читаем пословно
for(y=0; y<height; ++y)
{
    __uint16 const* srcline = (__uint16 const*) (src+y*srcw);
    __uint8* dstline = (__uint8*) (dst+y*dstw);
    for(x=0; x<dstw; ++x)
        dstline[x] = srcline[x];
}

// его можно немножко накрутить
for(y=0; y<height; ++y, src+=srcw)
{
    __uint16 const* srcline = (__uint16 const*) src;
    for(x=0; x<dstw; ++x)
        *dst++ = *srcline++;
}

// а если srcw строго чётно
__uint16 const* srcw = (__uint16 const*) src;
for(i=0; i<height*dstw; ++i)
    *dst++ = *srcw++;

На архитектурах, строго относящихся к misalign'у, возможны провалы производительности и даже аппаратные ошибки, если srcw нечётно. (В тех случаях, когда мы химичим с вордами).

Здравствуйте, Aleksey Skurihin,

char s[]={1,2,3,4,5,6,7,8,9,10,11,12};
char d[32];
void copy2(char *d,char *s,int c)
{  char *e=s+c;
   __asm
   {  mov ecx,s
      mov edx,d
   cikl:
      mov eax,[ecx]
      shrd ebx,eax,8
      shr  eax,16
      shrd ebx,eax,8
      lea  ecx, 4+[ecx]

      mov eax,[ecx]
      shrd ebx,eax,8
      shr  eax,16
      shrd ebx,eax,8
      lea  ecx, 4+[ecx]

      cmp ecx,[e]
      mov [edx],ebx
      lea  edx, 4+[edx]

      jna cikl

   }
}

int main(int argc, char* argv[])
{  copy2(d,s,12);
    return 0;
}

Здравствуйте, Aleksey Skurihin, Вы писали:

Попробуй немного развернуть внутренний цикл в помощью того же Duff’s device.

Здравствуйте, remark, Вы писали:

R>Здравствуйте, Aleksey Skurihin, Вы писали:

AS>>if (IsEqualGUID(mtype_, MEDIASUBTYPE_YUY2)) {


AS>> }


R>Не обязательно заниматься такой обфускацией кода. Практически невозможно понять что делает вот это "*dst++ = (src += 2)[-2]". Можно записать это по-нормальному — по одному оператору на строчке — компилятор сгенерирует идентичный код.

R>Основное, что хотелось бы понять — копируемый столбик лежит непрерывно в памяти или нет?
R>Какая раскладка исходной матрицы в памяти? Какого размера столбик? И какого размера строки?


Это уже танцы с бубном, думал поможет

в памяти лежит кадр из видео, непрерывным буфером. В котором каждый второй байт нужно убрать.

Здравствуйте, Bell, Вы писали:

B>Попробуй немного развернуть внутренний цикл в помощью того же Duff’s device.
Скорее всего компиллер сам до такого додумается...

Здравствуйте, Aleksey Skurihin, Вы писали:

AS>быстрее чем так
AS>можно на ассемблере
AS>у кого есть идеи



Всем спасибо. Померял код по времени, потом посчитал, потом понял что Y800 спасет отца русской демокоратии, а любое конвертирование все равно безобразно ресурсоемко..