Delphi JPEG komponens benchmark
2010-12-04T13:18:38+01:00
2010-12-29T18:45:29+01:00
2022-06-29T09:35:22+02:00
  • Original link!

    /* -------- 16x16 DCT (Discrete Cosine Transform) / Inverse of DCT -------- [definition] <CASE1> Normalized 16x16 IDCT C[k1][k2] = (1/8) * sum_j1=0^15 sum_j2=0^15 a[j1][j2] * s[j1] * s[j2] * cos(pi*j1*(k1+1/2)/16) * cos(pi*j2*(k2+1/2)/16), 0<=k1<16, 0<=k2<16 (s[0] = 1/sqrt(2), s[j] = 1, j > 0) <CASE2> Normalized 16x16 DCT C[k1][k2] = (1/8) * s[k1] * s[k2] * sum_j1=0^15 sum_j2=0^15 a[j1][j2] * cos(pi*(j1+1/2)*k1/16) * cos(pi*(j2+1/2)*k2/16), 0<=k1<16, 0<=k2<16 (s[0] = 1/sqrt(2), s[j] = 1, j > 0) [usage] <CASE1> ddct16x16s(1, a); <CASE2> ddct16x16s(-1, a); [parameters] a[0...15][0...15] :input/output data (double **) output data a[k1][k2] = C[k1][k2], 0<=k1<16, 0<=k2<16 */ /* Cn_kR = sqrt(2.0/n) * cos(pi/2*k/n) */ /* Cn_kI = sqrt(2.0/n) * sin(pi/2*k/n) */ /* Wn_kR = cos(pi/2*k/n) */ /* Wn_kI = sin(pi/2*k/n) */ #define C16_1R 0.35185093438159561476 #define C16_1I 0.03465429229977286565 #define C16_2R 0.34675996133053686546 #define C16_2I 0.06897484482073575308 #define C16_3R 0.33832950029358816957 #define C16_3I 0.10263113188058934529 #define C16_4R 0.32664074121909413196 #define C16_4I 0.13529902503654924610 #define C16_5R 0.31180625324666780814 #define C16_5I 0.16666391461943662432 #define C16_6R 0.29396890060483967924 #define C16_6I 0.19642373959677554532 #define C16_7R 0.27330046675043937206 #define C16_7I 0.22429189658565907106 #define C16_8R 0.25 #define W16_4R 0.92387953251128675613 #define W16_4I 0.38268343236508977173 #define W16_8R 0.70710678118654752440 void ddct16x16s(int isgn, double **a) { int j; double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i; double x4r, x4i, x5r, x5i, x6r, x6i, x7r, x7i; double xr, xi; if (isgn < 0) { for (j = 0; j <= 15; j++) { x4r = a[0][j] - a[15][j]; xr = a[0][j] + a[15][j]; x4i = a[8][j] - a[7][j]; xi = a[8][j] + a[7][j]; x0r = xr + xi; x0i = xr - xi; x5r = a[2][j] - a[13][j]; xr = a[2][j] + a[13][j]; x5i = a[10][j] - a[5][j]; xi = a[10][j] + a[5][j]; x1r = xr + xi; x1i = xr - xi; x6r = a[4][j] - a[11][j]; xr = a[4][j] + a[11][j]; x6i = a[12][j] - a[3][j]; xi = a[12][j] + a[3][j]; x2r = xr + xi; x2i = xr - xi; x7r = a[6][j] - a[9][j]; xr = a[6][j] + a[9][j]; x7i = a[14][j] - a[1][j]; xi = a[14][j] + a[1][j]; x3r = xr + xi; x3i = xr - xi; xr = x0r + x2r; xi = x1r + x3r; a[0][j] = C16_8R * (xr + xi); a[8][j] = C16_8R * (xr - xi); xr = x0r - x2r; xi = x1r - x3r; a[4][j] = C16_4R * xr - C16_4I * xi; a[12][j] = C16_4R * xi + C16_4I * xr; x0r = W16_8R * (x1i - x3i); x2r = W16_8R * (x1i + x3i); xr = x0i + x0r; xi = x2r + x2i; a[2][j] = C16_2R * xr - C16_2I * xi; a[14][j] = C16_2R * xi + C16_2I * xr; xr = x0i - x0r; xi = x2r - x2i; a[6][j] = C16_6R * xr - C16_6I * xi; a[10][j] = C16_6R * xi + C16_6I * xr; xr = W16_8R * (x6r - x6i); xi = W16_8R * (x6i + x6r); x6r = x4r - xr; x6i = x4i - xi; x4r += xr; x4i += xi; xr = W16_4I * x7r - W16_4R * x7i; xi = W16_4I * x7i + W16_4R * x7r; x7r = W16_4R * x5r - W16_4I * x5i; x7i = W16_4R * x5i + W16_4I * x5r; x5r = x7r + xr; x5i = x7i + xi; x7r -= xr; x7i -= xi; xr = x4r + x5r; xi = x5i + x4i; a[1][j] = C16_1R * xr - C16_1I * xi; a[15][j] = C16_1R * xi + C16_1I * xr; xr = x4r - x5r; xi = x5i - x4i; a[7][j] = C16_7R * xr - C16_7I * xi; a[9][j] = C16_7R * xi + C16_7I * xr; xr = x6r - x7i; xi = x7r + x6i; a[5][j] = C16_5R * xr - C16_5I * xi; a[11][j] = C16_5R * xi + C16_5I * xr; xr = x6r + x7i; xi = x7r - x6i; a[3][j] = C16_3R * xr - C16_3I * xi; a[13][j] = C16_3R * xi + C16_3I * xr; } for (j = 0; j <= 15; j++) { x4r = a[j][0] - a[j][15]; xr = a[j][0] + a[j][15]; x4i = a[j][8] - a[j][7]; xi = a[j][8] + a[j][7]; x0r = xr + xi; x0i = xr - xi; x5r = a[j][2] - a[j][13]; xr = a[j][2] + a[j][13]; x5i = a[j][10] - a[j][5]; xi = a[j][10] + a[j][5]; x1r = xr + xi; x1i = xr - xi; x6r = a[j][4] - a[j][11]; xr = a[j][4] + a[j][11]; x6i = a[j][12] - a[j][3]; xi = a[j][12] + a[j][3]; x2r = xr + xi; x2i = xr - xi; x7r = a[j][6] - a[j][9]; xr = a[j][6] + a[j][9]; x7i = a[j][14] - a[j][1]; xi = a[j][14] + a[j][1]; x3r = xr + xi; x3i = xr - xi; xr = x0r + x2r; xi = x1r + x3r; a[j][0] = C16_8R * (xr + xi); a[j][8] = C16_8R * (xr - xi); xr = x0r - x2r; xi = x1r - x3r; a[j][4] = C16_4R * xr - C16_4I * xi; a[j][12] = C16_4R * xi + C16_4I * xr; x0r = W16_8R * (x1i - x3i); x2r = W16_8R * (x1i + x3i); xr = x0i + x0r; xi = x2r + x2i; a[j][2] = C16_2R * xr - C16_2I * xi; a[j][14] = C16_2R * xi + C16_2I * xr; xr = x0i - x0r; xi = x2r - x2i; a[j][6] = C16_6R * xr - C16_6I * xi; a[j][10] = C16_6R * xi + C16_6I * xr; xr = W16_8R * (x6r - x6i); xi = W16_8R * (x6i + x6r); x6r = x4r - xr; x6i = x4i - xi; x4r += xr; x4i += xi; xr = W16_4I * x7r - W16_4R * x7i; xi = W16_4I * x7i + W16_4R * x7r; x7r = W16_4R * x5r - W16_4I * x5i; x7i = W16_4R * x5i + W16_4I * x5r; x5r = x7r + xr; x5i = x7i + xi; x7r -= xr; x7i -= xi; xr = x4r + x5r; xi = x5i + x4i; a[j][1] = C16_1R * xr - C16_1I * xi; a[j][15] = C16_1R * xi + C16_1I * xr; xr = x4r - x5r; xi = x5i - x4i; a[j][7] = C16_7R * xr - C16_7I * xi; a[j][9] = C16_7R * xi + C16_7I * xr; xr = x6r - x7i; xi = x7r + x6i; a[j][5] = C16_5R * xr - C16_5I * xi; a[j][11] = C16_5R * xi + C16_5I * xr; xr = x6r + x7i; xi = x7r - x6i; a[j][3] = C16_3R * xr - C16_3I * xi; a[j][13] = C16_3R * xi + C16_3I * xr; } } else { for (j = 0; j <= 15; j++) { x5r = C16_1R * a[1][j] + C16_1I * a[15][j]; x5i = C16_1R * a[15][j] - C16_1I * a[1][j]; xr = C16_7R * a[7][j] + C16_7I * a[9][j]; xi = C16_7R * a[9][j] - C16_7I * a[7][j]; x4r = x5r + xr; x4i = x5i - xi; x5r -= xr; x5i += xi; x7r = C16_5R * a[5][j] + C16_5I * a[11][j]; x7i = C16_5R * a[11][j] - C16_5I * a[5][j]; xr = C16_3R * a[3][j] + C16_3I * a[13][j]; xi = C16_3R * a[13][j] - C16_3I * a[3][j]; x6r = x7r + xr; x6i = x7i - xi; x7r -= xr; x7i += xi; xr = x4r - x6r; xi = x4i - x6i;
    Mutasd a teljes hozzászólást!
  • Szia!

    Találtam egy jobban magyarázó PDF fájlt.
    Mutasd a teljes hozzászólást!
  • Szia!

    Köszönöm a válaszodat.

    A kvantálás és a többi érthető, csak DCT algoritmusból találtam vagy 10 félét, azon belül több optimalizált verziót, és már nem nagyon tudom melyik mit jelent.
    Mutasd a teljes hozzászólást!
  • Ez egy 'expression' gráf, balrol jobbra kell ertelmezni.
    A csomopontok osszegzest jelentenek. (ures karika)
    Az osszegzesek bizonyos bemeneteinel - elojellel kell osszegezni a megjelolt bemenetet. Az abran a + is meg a 0 elojelek is meg vannak jelolve.
    A 'dobozok' szorzasokat csinalnak sin/cos-al, ahol a szög konstans. Benne van a keplet, hogy pontosan hogyan.
    Van még a végén gyok2-vel szorzas is.

    Ez lenne a 8x1 DCT. Hogy lesz ebbol 8x8? -> A fenti 8x1 transformot vegre kell hajtani a 8x8 input osszes sorara, majd az igy keletkezett 8x8 matrix minden oszlopara is.

    Itt pegig a fenti modszer optimizalt valtozata: http://www.cs.cmu.edu/~dongw/final_fantasy/Image2.gif
    csak 5 szorzas van belul, majd a legvegen 8 szorzas, viszont azok a szorzasok összegyúrhatóak a jpeg kovetkezô lépésével: a kvantálás elôtti szorzással (az 64 darab szorzas, amit mar nem lehet elkerulni).

    Ez még egy jó 'tutorial' oldal: ImpulseAdventure - JPEG Decoder Design
    Mutasd a teljes hozzászólást!
  • Szia!

    Bocsánat, félreérthető vagyok.
    Az ábrából hogyan lesz forráskód?
    Mutasd a teljes hozzászólást!
  • Loeffler's algorithm for computing fast DCT 16 (see reference [4]) ez a 'nativ' 16-os.
    És persze, hogy tartalmaz egy 8-ast, az a 8-as meg tartalmaz egy 4-est. (x0,x1,x2,x3 outputok) Ami pedig tartalmaz egy 2-est (x0,x1 outputok) vegul elerkezunk az 1-esig (x0 output), azaz az egyenaramu osszetevoig, ami az x0-ba szamolodik.
    Mutasd a teljes hozzászólást!
  • Szia!

    Valahogy így.

    Azért nem értem, mert nem vagyok megokosodva az ilyesmikhez.

    A h.264-et értem, de nekem natív 16x16 kell.

    Loeffler's algorithm for computing fast DCT 16 (see reference [4]): (ez is tartalmaz egy 8x8-at)
    Mutasd a teljes hozzászólást!
  • Marmint az ilyen arbakat nem erted? -> http://www.cs.cmu.edu/~dongw/final_fantasy/Image2.gif Ebben ott a magyarazat is alul. A binDct-ben tobb a szogletes 'dobozzal' van kozelitve az eredetiben levo szsorzas ugye.

    16x16 fast dct terv legalul

    16x16 dct -> A h264 pl. igy helyettesiti -> 4*4 darab 4*4dct majd ezeknek a DC-ihez még egy 4*4dct tehat osszesen 17 darab 4x4dct-bol rak ossze egy 16x16-os blokkot.
    Mutasd a teljes hozzászólást!
  • Szia!

    A binDCT processzor kb annyi transzoztorból áll mint az első 8086-os processzor

    Nekem a 16x16 rész kellene, de képből nem tudom kiolvasni a forráskódot
    Mutasd a teljes hozzászólást!
  • Ez inkabb a leggyorsabb celhardveres valtozat lesz mert itt az idct-ben az 5 darab szorzast ha jol szamoltam 18 shift-el valositja meg.
    Ez aztan a bitvadászat :D
    Mutasd a teljes hozzászólást!
  • Utility.h

    /* 520.643 Digital Multimedia Coding and Processing */ /* Prof. Trac D. Tran */ /* Department of Electrical and Computer Engineering */ /* The Johns Hopkins University */ /* ***************************************************** *$Log: utility.h,v $ *Revision 1.2 1999/09/26 18:40:51 jliang *Modified the get_image_info for type other than P5 and P6. * * ****************************************************** */ #ifndef _UTILITY_H #define _UTILITY_H #define sat_uchar(t) ((t < 0.0) ? 0.0 : ((t > 255.0) ? 255.0 : t)) FILE *open_get_file (char *message,char *mode,char *dir,char *ext) { char file[256], temp[256], dummy; FILE *fd; printf ("%s", message); do { scanf ("%s", temp); sprintf (file, "%s/%s%s", dir, temp, ext); if ((fd = fopen (file, mode)) == NULL) { printf ("\n\t\tError opening file [%s]\n\n", file); printf ("%s", message); } } while (fd == NULL); return (fd); } FILE *open_file (char *file,char *mode) { FILE *fd; if ((fd = fopen (file, mode)) == NULL) printf ("Error opening file [%s]\n\n", file); return (fd); } /* allocate 2D unsigned char array -- can be used as 1D array (raster scan) */ char **allocate_char (int c,int r) { char **p; int i, j; if ((p = (char **) malloc (sizeof (char *) * r)) == NULL){ printf (" Error in space allocation : allocate_char\n"); exit (0); } if ((p[0] = (char *)malloc(c*r*sizeof(char))) == NULL){ printf (" Error in space allocation : allocate_char\n"); exit (0); } for (i = 1; i < r; i++) p[i] = p[i-1] + c; return p; } /* allocate 2D unsigned float array */ float **allocate_float (int c,int r) { float **p; int i, j; if ((p = (float **) malloc (sizeof (float *) * r)) == NULL){ printf (" Error in space allocation : allocate_float\n"); exit (0); } if ((p[0] = (float *)malloc(c*r*sizeof(float))) == NULL){ printf (" Error in space allocation : allocate_float\n"); exit (0); } for (i = 1; i < r; i++) p[i] = p[i-1] + c; return p; } /* allocate 2D unsigned unsigned char array */ unsigned char **allocate_uchar (int c,int r) { unsigned char **p; int i, j; if ((p = (unsigned char **) malloc (sizeof (unsigned char *) * r)) == NULL){ printf (" Error in space allocation : allocate_uchar\n"); exit (0); } if ((p[0] = (unsigned char *)malloc(c*r*sizeof(unsigned char))) == NULL){ printf (" Error in space allocation : allocate_uchar\n"); exit (0); } for (i = 1; i < r; i++) p[i] = p[i-1] + c; return p; } /* process pgm header */ void get_image_info(FILE *fd,int *row,int *col,int *color) { char P, Five, str[256]; fread(&P, 1, 1, fd); fread(&Five, 1, 1, fd); rewind(fd); if ((P == 'P') && (Five == '5')){ printf("PGM header skipped.\n"); fgets (str, 256, fd); do { fgets (str, 256, fd);} while (str[0] == '#'); sscanf (str, "%d%d", col, row); fgets (str, 256, fd); *color = 1; } else if ((P == 'P') && (Five == '6')){ fgets (str, 256, fd); do { fgets (str, 256, fd);} while (str[0] == '#'); sscanf (str, "%d%d", col, row); fgets (str, 256, fd); *color = 3; } else { /* do nothing for other types, such as qcif. */ /* which format is this? Jie Liang *color = 1; fread(col, sizeof(int), 1, fd); fread(row, sizeof(int), 1, fd); */ } } /* read pgm (raw with simple header) image */ unsigned char **alloc_read_image(char *file,int *row,int *col,int *color) { FILE *fd; unsigned char **image; if ((fd = fopen(file, "r")) == NULL){ printf(" Error opening file [%s]\n", file); return NULL; } get_image_info(fd, row, col, color); image = allocate_uchar( (*col)*(*color), *row); fread(image[0], 1, (*row)*(*col)*(*color), fd); fclose(fd); return image; } /* write pgm (raw with simple header) image */ /* Typical pgm header for a QCIF frame P5 176 144 255 */ void save_image(unsigned char **image,char *file,int row,int col,int color) { FILE *fd; int i, j; int val; if ((fd = open_file(file,"w")) == NULL){ printf("Error opening file [%s]\n", file); return ; } if (color == 3) fprintf(fd,"P6\n%d %d\n255\n", col, row); else { fprintf(fd,"P5\n%d %d\n255\n", col, row); color = 1; } fwrite(image[0], 1, color*row*col, fd); fclose(fd); } #endif
    Mutasd a teljes hozzászólást!

  • /* * * File Name: dprdct.c * * Designed by: * Jie Liang * * Created Date: June 30, 2000 * * Contents: * Implement the 2D 8x8 inverse lossless binDCT. * * Usage: dprdct dctfile recfile hsize vsize * "Arguments:\n" * " dctfile: input DCT-transformed file,\n" * " recfile: reconstructed image file,\n" * " hsize: Horizontal size of the image,\n" * " vsize: Vertical size of the image.\n" * "Examples:\n" * " ./dprdct lena.dct lena.rec 512 512\n" * * * Limitations: * * * Copyright (C) 2000 Department of Electrical and Computer Engineering * The Johns Hopkins University. All right reserved. * */ /* * * Modification History: * * Date Programmer Description * * $Log$ * * * */ static const char rcsid[] = "$Id$"; /* * Include Files * */ #include <stdio.h> #include <stdlib.h> #include <math.h> #include <string.h> #include <time.h> #include "global.h" #include "utility.h" /* * Local Data Types */ #define DCTSIZE 8 typedef int4 DCTELEM; /* * Local Function Prototypes */ void jpeg_idct_bin_a1_pr (DCTELEM *coef_block, unsigned char *output_buf) ; /* * * Function Name: main * * Descriptions: * open input image, perform DCT transformation * * * Input Parameters: * argc: argument count; * argv: array of input arguments. * Output Parameters: 0: successful, * -1: error. * Limitations: * */ int main(int argc, char *argv[]) { FILE *dctfile, *recfile; unsigned char row, col, rblks, cblks, rbidx, cbidx; /* horizontal, vertical blocks and indexes */ int i, j, hsize, vsize, offset, qtzer, qtzrate; /* source symbols */ unsigned char *imgptr_chr, outbuf[64], *tmpoutptr; DCTELEM *imgptr, *hdptr, *tmptr, dct_1d_buf[64]; clock_t timer0, timer1; printf("\nInverse lossless binDCT:\n"); if (argc != 5) { printf( "\nUsage:\n dprdct dctfile dctfile hsize vsize\n" "Arguments:\n" " dctfile: DCT-transformed file,\n" " recfile: reconstructed image file to be generated,\n" " hsize: Horizontal size of the image,\n" " vsize: Vertical size of the image.\n" "Examples:\n" " ./dprdct lena.dct lena_rec.raw 512 512\n" ); return(-1); } /* Open Input files */ dctfile = fopen(argv[1], "r"); if (dctfile == NULL) { fprintf(stderr, "Input file not found.\n"); return(-1); } /*create output file */ recfile = fopen(argv[2], "w"); if( recfile == NULL ) { fprintf(stderr, "Error in generating output file.\n"); return(-1); } /* read image size */ hsize = atoi(argv[3]); vsize = atoi(argv[4]); if ( (hsize & 7) || (vsize & 7) ) { fprintf(stderr, "Image size paramemters should be multiples of 8.\n"); return(-1); } /* block indexes in two directions */ cblks = hsize / 8 ; rblks = vsize / 8 ; // cblks = hsize >> 3 ; // rblks = vsize >> 3 ; /* allocate memory for the img array */ if( !(imgptr_chr = (unsigned char *) malloc(hsize * vsize)) || !(imgptr = (DCTELEM *) malloc(hsize * vsize * sizeof(DCTELEM) )) ) { printf("Memory allocation error.\n"); return(-1); } /* read image data */ fread(imgptr, sizeof(DCTELEM), hsize * vsize, dctfile); fclose(dctfile); // for (i=0; i<64;i++) printf("%5d", *(imgptr+i)); /* * Inverse DCT */ timer0 = clock(); for(rbidx = 0; rbidx < rblks; rbidx++) { for (cbidx = 0; cbidx < cblks; cbidx++) { // pointer of input block hdptr = imgptr + rbidx * hsize * 8 + cbidx * 8 ; //copy block to a 8x8 array for (i = 0; i < 8; i++) { tmptr = hdptr + i * hsize; for (j = 0; j < 8; j++) { dct_1d_buf[8*i + j] = *(tmptr + j); } } // for (i=0; i<64;i++) printf("%5d", dct_1d_buf[i]); // printf("\n\n"); jpeg_idct_bin_a1_pr((DCTELEM *)&dct_1d_buf, (unsigned char *)&outbuf); //copy output in a 8x8 array to output image block. for (i = 0; i < 8; i++) { tmpoutptr = (imgptr_chr + rbidx * hsize * 8 + cbidx * 8) + i * hsize; for (j = 0; j < 8; j++) { *(tmpoutptr + j) = outbuf[8*i + j]; // printf("%5d",*(tmpoutptr + j) ); } } } } timer1 = clock(); printf("Time used by Inverse lossless binDCT is: %10.6f sec.\n", ((float) (timer1 - timer0)) / (float )CLOCKS_PER_SEC); fwrite(imgptr_chr, sizeof(unsigned char), hsize * vsize, recfile); fclose(recfile); printf("\nReconstructed file generated.\n"); return(0); } /* * * Function Name: inv_fastdct * * Descriptions: * perform 8-point DCT for one row data of unsigned char type. * A(i, :) * C_transpose * * Input Parameters: * data: pointer to the given data. * Return Parameters: none. * * Notice: * Because butfly * butfly = 2I, the fast DCT will scale * the imgae by a factor of 2. * */ void jpeg_idct_bin_a1_pr (DCTELEM *coef_block, unsigned char *output_buf) { DCTELEM tmp0, tmp1, tmp2, tmp3,tmp4,tmp5,tmp6,tmp7; DCTELEM tmp10, tmp11, tmp12, tmp13; DCTELEM *inptr, *wsptr; int ctr; unsigned char *outptr; /* Pass 1: process columns from input, store into work array. */ /* Note results are scaled up by sqrt(8) compared to a true IDCT; */ /* furthermore, we scale the results by 2**PASS1_BITS. */ inptr = coef_block; wsptr = coef_block; for (ctr = DCTSIZE; ctr > 0; ctr--) { if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) { int dcval = inptr[DCTSIZE*0] >> 1; wsptr[DCTSIZE*0] = dcval; wsptr[DCTSIZE*1] = dcval; wsptr[DCTSIZE*2] = dcval; wsptr[DCTSIZE*3] = dcval; wsptr[DCTSIZE*4] = dcval; wsptr[DCTSIZE*5] = dcval; wsptr[DCTSIZE*6] = dcval; wsptr[DCTSIZE*7] = dcval; inptr++; continue; } tmp0 = inptr[DCTSIZE*0]; tmp1 = inptr[DCTSIZE*4]; tmp2 = inptr[DCTSIZE*6]; tmp3 = inptr[DCTSIZE*2]; tmp4 = inptr[DCTSIZE*7]; tmp5 = inptr[DCTSIZE*5]; tmp6 = inptr[DCTSIZE*3]; tmp7 = inptr[DCTSIZE*1]; /* fprintf(stderr, "%10d", tmp0); fprintf(stderr, "%10d", tmp7); fprintf(stderr, "%10d", tmp3); fprintf(stderr, "%10d", tmp6); fprintf(stderr, "%10d", tmp1); fprintf(stderr, "%10d", tmp5); fprintf(stderr, "%10d", tmp2); fprintf(stderr, "%10d", tmp4); fprintf(stderr, "\n"); */ /* X[0] and X[4] */ tmp11 = ((tmp0 + 1) >> 1) - tmp1; tmp10 = tmp0 - tmp11; /* X[6] and X[2] */ tmp13 = tmp3 + (((tmp2 << 1) + tmp2 + 4) >> 3); tmp12 = ((tmp13 + 1) >> 1) - ((tmp13 + 8) >> 4) - tmp2; tmp0 = tmp10 + tmp13; tmp3 = tmp10 - tmp13; tmp1 = tmp11 + tmp12; tmp2 = tmp11 - tmp12; /* X[7] and X[1]: */ /* 7pi/16 = 3/16d 3/16u */ tmp13 = tmp7 + ( ((tmp4 << 1) + tmp4 + 8) >> 4 ); tmp10 = ( ((tmp13 << 1) + tmp13 + 8) >> 4 ) - tmp4; /* X[5] and X[3] */ /* 3pi/16 = 1/2d -7/8u */ /* tmp12 = tmp6 + ((tmp5 + 1) >> 1); tmp11 = tmp5 - tmp12 + ((tmp12 + 4) >> 3);*/ /* new 7/16 and -5/8*/ tmp12 = tmp6 + ((tmp5 + 1) >> 1) - ((tmp5 + 8) >> 4); tmp11 = tmp5 - ((tmp12 + 1) >> 1) - ((tmp12 + 4) >> 3); /* Butterfly */ tmp4 = tmp10 + tmp11; tmp5 = tmp10 - tmp11; tmp6 = tmp13 - tmp12; tmp7 = tmp13 + tmp12; /* pi/4 = -3/8u -11/16d 7/16u */ tmp5 = (((tmp6 << 1) + tmp6 + 4) >> 3) - tmp5; tmp6 = tmp6 - tmp5 + ((tmp5 + 2) >> 2) + ((tmp5 + 8) >> 4); tmp5 = tmp5 + ((tmp6 + 1) >> 1) - ((tmp6 + 8) >> 4); /* last stage: butterfly */ wsptr[DCTSIZE*0] = (tmp0 + tmp7); wsptr[DCTSIZE*7] = (tmp0 - tmp7); wsptr[DCTSIZE*1] = (tmp1 + tmp6); wsptr[DCTSIZE*6] = (tmp1 - tmp6); wsptr[DCTSIZE*2] = (tmp2 + tmp5); wsptr[DCTSIZE*5] = (tmp2 - tmp5); wsptr[DCTSIZE*3] = (tmp3 + tmp4); wsptr[DCTSIZE*4] = (tmp3 - tmp4); inptr++; /* advance pointers to next column */ } /* Pass 2: process rows from work array, store into output array. */ /* Note that we must descale the results by a factor of 8 == 2**3, */ /* and also undo the PASS1_BITS scaling. */ //fprintf(stderr, "\nAfter inverse DCT:\n"); wsptr = coef_block; outptr = output_buf; for (ctr = 0; ctr < DCTSIZE; ctr++) { outptr = outptr + ctr*8; /* Rows of zeroes can be exploited in the same way as we did with columns. * However, the column calculation has created many nonzero AC terms, so * the simplification applies less often (typically 5% to 10% of the time). * On machines with very fast multiplication, it's possible that the * test takes more time than it's worth. In that case this section * may be commented out. */ #ifndef NO_ZERO_ROW_TEST if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 && wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { /* if all AC are 0, the IDCT will all equal to 1/2 DC, so downscale by 2, After that, apply the downscale of 16 caused by butterflies, so total downscale = 32.*/ // unsigned char dcval = wsptr[0] >> 5; int4 dcval = wsptr[0] >> 5; outptr[0] = dcval; outptr[1] = dcval; outptr[2] = dcval; outptr[3] = dcval; outptr[4] = dcval; outptr[5] = dcval; outptr[6] = dcval; outptr[7] = dcval; wsptr += DCTSIZE; continue; } #endif /* Even part: reverse the even part of the forward DCT. */ /* The rotator is sqrt(2)*c(-6). */ /* Even part */ /**********************/ /* not necessary ??? */ /************************/ /******** tmp0 = (INT32) wsptr[0]; tmp1 = (INT32) wsptr[4]; tmp2 = (INT32) wsptr[6]; tmp3 = (INT32) wsptr[2]; tmp4 = (INT32) wsptr[7]; tmp5 = (INT32) wsptr[5]; tmp6 = (INT32) wsptr[3]; tmp7 = (INT32) wsptr[1]; *********/ /* X[0] and X[4] */ tmp11 = ((wsptr[0] + 1) >> 1) - wsptr[4]; tmp10 = wsptr[0] - tmp11; /* X[6] and X[2] */ tmp13 = wsptr[2] + (((wsptr[6] << 1) + wsptr[6] + 4) >> 3); tmp12 = ((tmp13 + 1) >> 1) - ((tmp13 + 8) >> 4) - wsptr[6]; tmp0 = tmp10 + tmp13; tmp3 = tmp10 - tmp13; tmp1 = tmp11 + tmp12; tmp2 = tmp11 - tmp12; /* 7pi/16 = -3/16d 3/16u */ tmp13 = wsptr[1] +( ((wsptr[7] << 1) + wsptr[7] + 8) >> 4 ); tmp10 = ( ((tmp13 << 1) + tmp13 + 8) >> 4 ) - wsptr[7]; /* 3pi/16 = 1/2d -7/8u */ /* tmp12 = wsptr[3] + ((wsptr[5] + 1) >> 1); tmp11 = wsptr[5] - tmp12 + ((tmp12 + 4) >> 3); */ /* new 7/16 and -5/8*/ tmp12 = wsptr[3] + ((wsptr[5] + 1) >> 1) - ((wsptr[5] + 8) >> 4); tmp11 = wsptr[5] - ((tmp12 + 1) >> 1) - ((tmp12 + 4) >> 3); tmp4 = tmp10 + tmp11; tmp5 = tmp10 - tmp11; tmp6 = tmp13 - tmp12; tmp7 = tmp13 + tmp12; /* pi/4 = -3/8u -11/16d 7/16u */ tmp5 = (((tmp6 << 1) + tmp6 + 4) >> 3) - tmp5; tmp6 = tmp6 - tmp5 + ((tmp5 + 2) >> 2) + ((tmp5 + 8) >> 4); tmp5 = tmp5 + ((tmp6 + 1) >> 1) - ((tmp6 + 8) >> 4); /* last stage: butterfly */ /* Final output stage: scale down by a factor of 8 and range-limit */ outptr[0] = (tmp0 + tmp7) >> 4; outptr[7] = (tmp0 - tmp7) >> 4; outptr[1]=(tmp1 + tmp6) >> 4; outptr[6]=(tmp1 - tmp6) >> 4; outptr[2]=(tmp2 + tmp5) >> 4; outptr[5]=(tmp2 - tmp5) >> 4; outptr[3]=(tmp3 + tmp4) >> 4; outptr[4]=(tmp3 - tmp4) >> 4; wsptr += DCTSIZE; /* advance pointer to next row */ /*******************/ /* Jie: test code */ /* for (tmp0 = 0; tmp0 < 8; tmp0 ++) { fprintf(stderr, "%10d", outptr[tmp0]); } fprintf(stderr, "\n"); */ } } /* * End of $Source$ dprdct.c */
    Mutasd a teljes hozzászólást!
  • /* * * File Name: cprdct.c * * Designed by: * Jie Liang * * Created Date: June 30, 2000 * * Contents: * Implement the forward lossless binDCT, * which enables perfect reconstruction. * * Usage: cprdct infile outfile hsize vsize * "Arguments:\n" * " infile: image file to be transformed(pgm or raw),\n" * " dctfile: output file that will contain the transformed result,\n" * " hsize: Horizontal size of the image,\n" * " vsize: Vertical size of the image.\n" * "Examples:\n" * " ./cprdct lena.raw lena.dct 512 512\n" * * Limitations: * * Copyright (C) 2000 Department of Electrical and Computer Engineering * The Johns Hopkins University. All right reserved. * */ /* * * Modification History: * * Date Programmer Description * */ static const char rcsid[] = "$Id$"; /* * Include Files */ #include <stdio.h> #include <stdlib.h> #include <math.h> #include <string.h> #include <time.h> #include "global.h" #include "utility.h" /* * Local Data Types */ #define DCTSIZE 8 // typedef signed short int DCTELEM; typedef int4 DCTELEM; /* * Local Function Prototypes */ void jpeg_fdct_bin_a1_pr(DCTELEM *data); /* * * Function Name: main * * Descriptions: * open input image, perform DCT transformation * * * Input Parameters: * argc: argument count; * argv: array of input arguments. * Output Parameters: 0: successful, * -1: error. * Limitations: * */ int main(int argc, char *argv[]) { FILE *infile, *outfile, *recfile; int row, col, rblks, cblks, rbidx, cbidx; /* horizontal, vertical blocks and indexes */ int i, j, hsize, vsize, offset; /* source symbols */ unsigned char *imgptr_chr; int *imgptr, *hdptr, *fltidx, dct_1d_buf[8]; clock_t timer0, timer1; int tmp1, tmp2, tmp3; printf("\nForward Lossless binDCT:\n"); if (argc != 5) { printf( "\nUsage:\n cprdct infile dctfile hsize vsize\n" "Arguments:\n" " infile: image file to be transformed,\n" " dctfile: output file that will contain the transformed result,\n" " hsize: Horizontal size of the image,\n" " vsize: Vertical size of the image.\n" "Examples:\n" " ./cprdct lena.raw lena.dct 512 512\n" ); return(-1); } /* Open Input files */ infile = fopen(argv[1], "r"); if (infile == NULL) {fprintf(stderr,"Input file not found.\n");return(-1);} /*create output file */ outfile = fopen(argv[2], "w"); if(outfile == NULL) {fprintf(stderr, "Error in generating output file.\n");return(-1);} /* read image size */ hsize = atoi(argv[3]); vsize = atoi(argv[4]); if ( (hsize & 7) || (vsize & 7) ) {fprintf(stderr, "Image size paramemters should be multiples of 8.\n");return(-1);} /* block indexes in two directions */ cblks = hsize / 8 ; rblks = vsize / 8 ; /* allocate memory for the img array */ if( ! (imgptr_chr = (unsigned char *) malloc(hsize * vsize)) || // ! (imgptr = (short *) malloc(hsize * vsize * sizeof(short))) ) { ! (imgptr = (int4 *) malloc(hsize * vsize * sizeof(int4))) ) { printf("Memory allocation error.\n"); return(-1); } /* read the file header of pgm or ppm, do nothing for raw. */ get_image_info(infile, (int *) &tmp1, (int *) &tmp2, (int *) &tmp3); /* read image data */ fread(imgptr_chr, sizeof(unsigned char), hsize * vsize, infile); fclose(infile); /* convert to short */ for (i = 0; i < hsize * vsize; i++) { // *(imgptr + i) = (short) *(imgptr_chr + i); *(imgptr + i) = (int4) *(imgptr_chr + i); } /* * Forward DCT transform */ /* record the beginning of the processing */ timer0 = clock(); for(rbidx = 0; rbidx < rblks; rbidx++) { for (cbidx = 0; cbidx < cblks; cbidx++) { hdptr = imgptr + (rbidx * hsize * 8 + cbidx * 8); // this is short type. jpeg_fdct_bin_a1_pr(hdptr); } } timer1 = clock(); printf("Time used by Forward binDCT is: %10.6f sec.\n", ((float) (timer1 - timer0)) / (float )CLOCKS_PER_SEC); // fwrite(imgptr, sizeof(short), hsize * vsize, outfile); fwrite(imgptr, sizeof(int4), hsize * vsize, outfile); fclose(outfile); printf("DCT result file generated.\n"); for (rbidx=0; rbidx<64;rbidx++) printf("%5d ", *(imgptr+rbidx)); return(0); } /* * Function Name: jpeg_fdct_bin_a1_pr * * Descriptions: * * Input Parameters: * data: pointer to a 8x8 block. * Return Parameters: none. * * Notice: * DCTELEM is now short int. */ void jpeg_fdct_bin_a1_pr (DCTELEM * data) { DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; DCTELEM tmp10, tmp11, tmp12, tmp13; DCTELEM z1, z2, z3, z4, z5; DCTELEM *dataptr; int ctr; /* Pass 1: process rows. */ /* Note results are scaled up by sqrt(8) compared to a true DCT; */ /* furthermore, we scale the results by 2**PASS1_BITS. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { /*******************/ /* Jie: test code */ // for (tmp0 = 0; tmp0 < 8; tmp0 ++) { // fprintf(stderr, "%10d", dataptr[tmp0]+128); // } // fprintf(stderr, "\n"); tmp0 = dataptr[0] + dataptr[7]; tmp7 = dataptr[0] - dataptr[7]; tmp1 = dataptr[1] + dataptr[6]; tmp6 = dataptr[1] - dataptr[6]; tmp2 = dataptr[2] + dataptr[5]; tmp5 = dataptr[2] - dataptr[5]; tmp3 = dataptr[3] + dataptr[4]; tmp4 = dataptr[3] - dataptr[4]; /* Even part */ tmp10 = (tmp0 + tmp3) ; /* phase 2 */ tmp13 = tmp0 - tmp3; tmp11 = (tmp1 + tmp2) ; tmp12 = tmp1 - tmp2; dataptr[0] = (tmp10 + tmp11); /* phase 3 */ dataptr[4] = ((dataptr[0] + 1) >> 1) - tmp11; /* Jie 05/18/00 */ //dataptr[4] = tmp10 - tmp11; /*3/8, -3/8: alter the sign to get positive scaling factor */ /* new version: 7/16 and -3/8 */ dataptr[6] = ((tmp13 + 1) >> 1) - ((tmp13 + 8) >> 4) - tmp12; /* 1/2 - 1/16 */ dataptr[2] = tmp13 - (((dataptr[6] << 1) + dataptr[6] + 4) >> 3); /* Odd part */ /* pi/4 = -7/16u 11/16d -3/8u*/ tmp10 = tmp5 - (( (tmp6 << 3) - tmp6 + 8) >> 4); tmp6 = tmp6 + tmp10 - ((tmp10 + 2) >> 2) -((tmp10 + 8) >> 4); tmp5 = (((tmp6 << 1) + tmp6 + 4) >> 3) - tmp10; tmp10 = tmp4 + tmp5; tmp11 = tmp4 - tmp5; tmp12 = tmp7 - tmp6; tmp13 = tmp7 + tmp6; /* 7pi/16 = 3/16u -3/16d: alter the sign to get positive scaling factor */ dataptr[7] = (((tmp13 << 1) + tmp13 + 8) >> 4) - tmp10; dataptr[1] = tmp13 - (((dataptr[7] << 1) + dataptr[7] + 8) >> 4); /* 3pi/16 = 7/8u -1/2d */ /* new version: 5/8, -7/16 */ dataptr[5] = tmp11 + ((tmp12 + 1) >> 1) + ((tmp12 + 4) >> 3); dataptr[3] = tmp12 - ((dataptr[5] + 1) >> 1) + ((dataptr[5] + 8) >> 4); dataptr += DCTSIZE; /* advance pointer to next row */ } /* Pass 2: process columns. * We remove the PASS1_BITS scaling, but leave the results scaled up * by an overall factor of 8. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = (dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]); tmp7 = (dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]); tmp1 = (dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]); tmp6 = (dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]); tmp2 = (dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]); tmp5 = (dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]); tmp3 = (dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]); tmp4 = (dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]); /* Even part */ tmp10 = (tmp0 + tmp3); /* phase 2 */ tmp13 = tmp0 - tmp3; tmp11 = (tmp1 + tmp2); tmp12 = tmp1 - tmp2; dataptr[DCTSIZE*0] = (tmp10 + tmp11); /* phase 3 */ dataptr[DCTSIZE*4] = ((dataptr[DCTSIZE*0] + 1) >> 1) - tmp11; /* Jie 05/18/00 */ //dataptr[DCTSIZE*4] = (tmp10 - tmp11); /* phase 3 */ dataptr[DCTSIZE*6] = ((tmp13 + 1) >> 1) - ((tmp13 + 8) >> 4) - tmp12; dataptr[DCTSIZE*2] = tmp13 - (((dataptr[DCTSIZE*6] << 1) + dataptr[DCTSIZE*6] + 4) >> 3); /* Odd part */ /* pi/4 = -7/16u 11/16d -3/8u*/ tmp10 = tmp5 - (((tmp6 << 3) - tmp6 + 8) >> 4); tmp6 = tmp6 + tmp10 - ((tmp10 + 2) >> 2) - ((tmp10 + 8) >> 4); tmp5 = (((tmp6 << 1) + tmp6 + 4) >> 3) - tmp10; tmp10 = tmp4 + tmp5; tmp11 = tmp4 - tmp5; tmp12 = tmp7 - tmp6; tmp13 = tmp7 + tmp6; /* 7pi/16 = 3/16u -3/16d: alter sign to get positive scaling factor */ dataptr[DCTSIZE*7] = (((tmp13 << 1) + tmp13 + 8) >> 4) - tmp10; dataptr[DCTSIZE*1] = tmp13 - (((dataptr[DCTSIZE*7] << 1) + dataptr[DCTSIZE*7] + 8) >> 4); /* 3pi/16 = 7/8u -1/2d */ /* new : 5/8 and -7/16 */ dataptr[DCTSIZE*5] = tmp11 + ((tmp12 + 1) >> 1) + ((tmp12 + 4) >> 3); dataptr[DCTSIZE*3] = tmp12 - ((dataptr[DCTSIZE*5] + 1) >> 1) + ((dataptr[DCTSIZE*5] + 8) >> 4); dataptr++; /* advance pointer to next column */ } } /* * End of $Source$ cprdct.c */
    Mutasd a teljes hozzászólást!
  • Hi!

    Elrontottam a gépen lévő XP-t, kicsit meg kellett piszkálnom (újratelepítés nélkül). Elfogyott a hely.

    A leggyorsabb DCT algoritmus Tran bácsi nevéhez fűzödik. 2000-ben publikálta binDCT néven (eredeti 106, binDCT 2). Emiatt lehet ma HD kamera olyan kicsi méretben.

    A lényeg, már sehol nem találok forráskódot, csak a gépemen. Pedig beleépítette a szabványos CJPEG és DJPEG alaprogram 6b változatában (forráskód már nincs az interneten).
    Ennyit az internet szabadságáról.

    Mutasd a teljes hozzászólást!
  • ImageMagick-et próbáltad? Én jó régen egy ujjlenyomatellenőrző progit készítettem és ahhoz kellett. Igaz linux alatt volt, de ez nem gond, ott a cygwin.

    Most nézem, van windows-ra fordított bináris is. Baloldalt, a Binary Releases linket nézd.

    ---
    Sőt, még ott van az Install from Sources link is!
    Mutasd a teljes hozzászólást!
  • Nem tudom mitől lehet, semmit nem változtattam a régebbi kódon, és elég egyszerű a kód, nem nagyon lehet elrontani.

    Azt hiszem benéztem a legutóbbi eredményeket. A GFL SDK a progressive JPEG-et tölti gyorsabban mint a Free Image Library, sima JPEG-ben még mindig a Free Image Libary a nyertes.

    Viszont készítetem egy JPEG2000 benchmark-oló progit is (ha már), letölthető: JPEG2000 Benchmark.zip

    Megint a Free Image Library tűnik a legjobbnak, eredmények:

    LoadJPEG2000FreeImageLibrary took: 2994 ms
    LoadJPEG2000Jpeg2000Bitmap took: 5269 ms

    Ha tudtok még JPEG 2000 komponenseket írjátok meg és tesztelem!
    Mutasd a teljes hozzászólást!
  • Hi!

    Motherboard: Gigabyte GA-MA78G-DS3H
    CPU: AMD Athlon(tm) Dual Core Processor 4850exL, 2500 MHz
    Memory: 4 x 1GB (EDO, DIMM 64-bit, 800Mhz, Speed 32 ns)
    Video Adapter: ATI Radeon HD 3200 Graphics (700 MB)

    A gépen XP (Sp3) van.

    File:360-degree_Panorama_of_the_Southern_Sky.jpg
    Ready.
    Processing...
    LoadJPEGDelphiImage took: 66909 ms
    LoadJPEGImage took: 101823 ms
    LoadJPEGOptimized took: 27518 ms
    LoadJPEGSynGdiPlus took: 52804 ms
    LoadJPEGFreeImageLibrary took: 35043 ms
    LoadJPEGTurboJPEGLibrary took: 12629 ms
    LoadJPEGGFL took: 35669 ms
    Completed.

    Orion_Nebula_-_Hubble_2006_mosaic_18000
    Processing...
    LoadJPEGDelphiImage took: 685 ms

    A kedvenc képemen az előző verzió első tesztje lefutott, itt már rögvest csipcsirip lett belőle. A memóriában elférne.
    Mutasd a teljes hozzászólást!
  • Új győztes!
    A GflSDK egy hajszálnyival ugyan, de gyorsabb a Free Image Library-nál:

    LoadJPEGDelphiImage took: 5387 ms
    LoadJPEGImage took: 8643 ms
    LoadJPEGOptimized took: 1304 ms
    LoadJPEGSynGdiPlus took: 4131 ms
    LoadJPEGFreeImageLibrary took: 2451 ms
    LoadJPEGTurboJPEGLibrary took: 778 ms
    LoadJPEGGFL took: 2085 ms

    10 passes után már majdnem fél másodperc az előnye.
    Érdekes mert azt hittem lassabb lesz a külön bitmap-ba másolás miatt, de nem.

    Az update-elt benchmark progi letölthető az első hozzászólásban.

    A JPEG2000 támogatást már beépítettem a programomba, nem annyira elterjedt de ha valaki tud gyorsabb komponenst mint a Jpeg2000Bitmap akkor írjon!

    A GraphicEx a Delphi-s JPEG unitot regisztrálja be, szóval nem kerül fel ismételten a listára.
    Mutasd a teljes hozzászólást!
  • Az 1 megas .dll az az intel performance primitivjei. Egy multinalm meg nem is olyan nagy az az 1 mega. Minden egyes processzortipusra kulon optimizalt IDCT8x8 (meg mindenfele kepfeldolgozo) funkciok vannak benne (+Amd-hez is, de azt meg biztos direkt lassitjak lol)

    A progresszivet ugy tudja, hogy asszem van egy 1/8zoom flag a .h fileban. Kicsit fapados no

    Nem teljesen ide tartozik, de a jpeg2000-et ismered-e? Kicsit jobban tomorit (20-40%), mert az egesz kepet 'latja' egyszerre, es nincsenek benne negyszog artifactok. Viszont sokkal tobbet bitvadaszkodik a kitomoriteshez, gondolom ezert nem terjedt el :/
    Aztan a kutatok asztalan meg ott van az Edge Enhancing Anisotropic Diffusion, ami megjobb tomoritesi aranyt tud, de nem fogom fel agyilag. (Nem kellett volna kocsmaznom annak idejen, amikor azokat a parcionalis differencial egyenleteket tanitottak hahahhhh)
    Mutasd a teljes hozzászólást!
  • Letöltöttem a GflSdk-t, nagyon jónak tűnik, de commerciális programhoz külön engedélyt kell kérni, és azt írja képnézegetőhöz nem ad (mert konkurencia lenne az XNView-nek).
    És kell egy kicsit variálni vele, mert bár a példaprgram egyből lefordult, de unicode problémái vannak.

    Megnézem a GraphicEx-et is, bár nem fűzök hozzá túl sok reményt, nem hiszem, hogy nagyon optimalizált lenne, elég régi komponens.
    Mutasd a teljes hozzászólást!
  • A leggyorsabb használható.

    Az optimized nem támogatja a progressive JPEG-et így nem tudom használni.

    Kipróbáltam! Az első hozzászólásban letölthető a turbót is tesztelő változat.
    De most próbáltam PS-pal átknovertáltam progressive JPEG-be a képet és nem töltötte be, szóval mégsem tudom használni, pedig nagyon jónak tünt. De nem értem, hogy egy majdnem 1 megás .dll és nincs benne progressive JPEG támogatás?
    Mutasd a teljes hozzászólást!
  • Nekem a GflSdk jött be. Nagyon gyors, mindent támogat, eddig tényleg mindent megevett. Tulajdonképpen az XNView motorja, ingyen letölthető. C++-ban íródott, de van Delphi wrapper hozzá.

    Szerk:
    ott van még a Mike Lischke-féle GraphicEx lib is, amiben szintén van egy JPG unit. Nem néztem, de ki tudja.
    Mutasd a teljes hozzászólást!
  • Hogy lehet a leggyorsabb, ha a teszted alapjan 2-3x annyi ideig fut, mint a JpegOptimized (amin pedig 2x gyorsabb a turbo)? :D

    A turbojepeg az win32-n dll-be fordul, ossz 3 import es mar lehet is dekodolni vele 1/8-ad zoomot tud, szoval gondolom progressziv. Plusz ha jol tevedek hasznalja, az intel performance promitivest, ami szinten egy dll, csak hogy megnagyobb legyen az öröm :D. aPar aLyza legutolso posztjaban van a link egy leforditott valtozatrol. Az en utolso postomban meg egy konzol app, amivel azt ki lehet probalni.
    Mutasd a teljes hozzászólást!
  • Én is találtam egy mégjobbat a LoadJPEGSynGdiPlus-nál!

    Régóta használom a Free Image Library-t és most eszembe jutott, hogy megfeledkeztem róla.

    Free Image Library
    Előnyök:
    -A legyorsabb
    -Van mentés funkció is
    -Vannak egyéb (pl. lossless) funkciók is
    -Sok egyéb formátutom is támogat
    Hátrányok:
    -Külső .dll (bár a BTMemoryModule-t használva beleintegrálható az .exe-be)

    Ready.
    Processing...
    LoadJPEGDelphiImage took: 6262 ms
    LoadJPEGImage took: 7976 ms
    LoadJPEGOptimized took: 1223 ms
    LoadJPEGSynGdiPlus took: 3956 ms
    LoadJPEGFreeImageLibrary took: 2766 ms
    Completed.

    Az update-elt benchmark program letölthető az első hozzászólásban!

    Ez a Delphis Turbo JPEG most akkor használható egy commerciális programban?
    És támogat minden JPEG formátumot (progressive meg hasonlók)?
    ÉS még egy kérdés csak a turbojpeg.dll-re van szüksége?

    Majd még tesztelem, ha bejön ő lesz a nyertes! :)
    Megpróbálom beintegrálni a benchmark programba.
    Mutasd a teljes hozzászólást!
  • Ez egy remek dekoder!!!!! 47ms (itt LoadJPEGOptimized took: 82 ms) (az enyem is csak azert 44, mert trukkos huffmant hasznal, emiatt csak magaval kompatibilis :D)

    Ez 16bit integer-t hasznal, a LoadJPEGOptimized, meg 32bit float-ot, foleg innen jon a 2x speedup.

    Egy kis problema, hogy ez top-down RGB-be tomorit ki, a tbitmap meg bottom-top BGR, azt még konvertalni kell. De pl. igy opengl-be meg azonnal lehet felkuldeni.

    program LibJpgTurboTest; {$APPTYPE CONSOLE} uses windows, SysUtils, graphics; function tjInitDecompress:integer;cdecl;external 'turbojpeg.dll'; function tjDecompressHeader(dec:integer;var srcbuf;size:integer;out width,height:integer):integer;cdecl;external 'turbojpeg.dll'; function tjDecompress(dec:integer;var srcbuf;size:integer;var dstbuf;width,pitch,height,pixelsize,flags:integer):integer;cdecl;external 'turbojpeg.dll'; var dec,w,h:integer; f:file; buf:ansistring; b:tbitmap; t0,t1,tf:int64; begin SetThreadPriority(GetCurrentThread,REALTIME_PRIORITY_CLASS); try dec:=tjInitDecompress; assignfile(f,'c:\JPEG Benchmark\01.jpg'); reset(f,1);setlength(buf,filesize(f));blockread(f,buf[1],length(buf));closefile(f); QueryPerformanceCounter(t0); if tjDecompressHeader(dec,buf[1],length(buf),w,h)=0then begin b:=TBitmap.Create; b.PixelFormat:=pf24bit; b.SetSize(w,h); tjDecompress(dec,buf[1],length(buf),b.ScanLine[b.Height-1]^,b.Width,b.Width*3,b.Height,3,0); // b.SaveToFile('c:\test.jpg'); end; QueryPerformanceCounter(t1); QueryPerformanceFrequency(tf); writeln('turbo libjpeg decode: '+format('%.3n',[(t1-t0)/tf*1e3])); except on E: Exception do Writeln(E.ClassName, ': ', E.Message); end; readln; end.
    Mutasd a teljes hozzászólást!
  • Hi!

    Régi EXE van!

    Amúgy az ASM részt kell beilleszteni, abban van az okosság.
    Mutasd a teljes hozzászólást!
  • Néztem ezt a turbo jpeg dolgot, de semmi Delphi-s vonatkozást nem találtam a neten, pedig igéretesnek tűnik, C++-t max olvasni tudok. Jó lenne ha ebből valaki csinálna valami Delphi alatt is használhatót.
    Mutasd a teljes hozzászólást!
  • pár tesztet*
    Mutasd a teljes hozzászólást!
  • Lefuttattam pár, különböző felbontású jpg fájlon:

    (1)
    LoadJPEGDelphiImage took: 153 ms
    LoadJPEGImage took: 311 ms
    LoadJPEGOptimized took: 86 ms
    LoadJPEGSynGdiPlus took: 127 ms

    (2)
    LoadJPEGDelphiImage took: 2787 ms
    LoadJPEGImage took: 2617 ms
    LoadJPEGOptimized took: 635 ms
    LoadJPEGSynGdiPlus took: 1435 ms

    (3)
    LoadJPEGDelphiImage took: 1419 ms
    LoadJPEGImage took: 1941 ms
    LoadJPEGOptimized took: 409 ms
    LoadJPEGSynGdiPlus took: 1348 ms

    (4)
    LoadJPEGDelphiImage took: 1266 ms
    LoadJPEGImage took: 1846 ms
    LoadJPEGOptimized took: 412 ms
    LoadJPEGSynGdiPlus took: 894 ms

    (core2duo t5670, 1800mhz | win7 x86-32 | passes: 10)
    Mutasd a teljes hozzászólást!
  • "18000x18000 felbontású" Na ettol a TBitmap is befordul :D
    Mutasd a teljes hozzászólást!
abcd