Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * originally by Andreas Öman (andoma)
  3.  * some changes by Alexander Strange
  4.  */
  5.  
  6. #include <string.h>
  7. #include <stdlib.h>
  8. #include <inttypes.h>
  9. #include <stdio.h>
  10. #include <sys/stat.h>
  11. #include <fcntl.h>
  12.  
  13. #if HAVE_UNISTD_H
  14. #include <unistd.h>
  15. #endif
  16.  
  17. int
  18. main(int argc, char **argv)
  19. {
  20.     int fd[2];
  21.     int print_pixels = 0;
  22.     int dump_blocks = 0;
  23.  
  24.     int width;
  25.     int height;
  26.     int to_skip = 0;
  27.  
  28.     if (argc < 6) {
  29.         fprintf(stderr, "%s [YUV file 1] [YUV file 2] width height pixelcmp|blockdump (# to skip)\n", argv[0]);
  30.         return 1;
  31.     }
  32.  
  33.     width  = atoi(argv[3]);
  34.     height = atoi(argv[4]);
  35.     if (argc > 6)
  36.         to_skip = atoi(argv[6]);
  37.  
  38.     uint8_t *Y[2], *C[2][2];
  39.     int i, v, c, p;
  40.     int lsiz = width * height;
  41.     int csiz = width * height / 4;
  42.     int x, y;
  43.     int cwidth = width / 2;
  44.     int fr = to_skip;
  45.     int mb;
  46.     char *mberrors;
  47.     int mb_x, mb_y;
  48.     uint8_t *a;
  49.     uint8_t *b;
  50.     int die = 0;
  51.  
  52.     print_pixels = strstr(argv[5], "pixelcmp") ? 1 : 0;
  53.     dump_blocks  = strstr(argv[5], "blockdump") ? 1 : 0;
  54.  
  55.     for(i = 0; i < 2; i++) {
  56.         Y[i] = malloc(lsiz);
  57.         C[0][i] = malloc(csiz);
  58.         C[1][i] = malloc(csiz);
  59.  
  60.         fd[i] = open(argv[1 + i], O_RDONLY);
  61.         if(fd[i] == -1) {
  62.             perror("open");
  63.             exit(1);
  64.         }
  65.         fcntl(fd[i], F_NOCACHE, 1);
  66.  
  67.         if (to_skip)
  68.             lseek(fd[i], to_skip * (lsiz + 2*csiz), SEEK_SET);
  69.     }
  70.  
  71.     mb_x = width / 16;
  72.     mb_y = height / 16;
  73.  
  74.     mberrors = malloc(mb_x * mb_y);
  75.  
  76.     while(!die) {
  77.         memset(mberrors, 0, mb_x * mb_y);
  78.  
  79.         printf("Loading frame %d\n", ++fr);
  80.  
  81.         for(i = 0; i < 2; i++) {
  82.             v = read(fd[i], Y[i], lsiz);
  83.             if(v != lsiz) {
  84.                 fprintf(stderr, "Unable to read Y from file %d, exiting\n", i + 1);
  85.                 return 1;
  86.             }
  87.         }
  88.  
  89.  
  90.         for(c = 0; c < lsiz; c++) {
  91.             if(Y[0][c] != Y[1][c]) {
  92.                 x = c % width;
  93.                 y = c / width;
  94.  
  95.                 mb = x / 16 + (y / 16) * mb_x;
  96.  
  97.                 if(print_pixels)
  98.                     printf("Luma diff 0x%02x != 0x%02x at pixel (%4d,%-4d) mb(%d,%d) #%d\n",
  99.                            Y[0][c],
  100.                            Y[1][c],
  101.                            x, y,
  102.                            x / 16,
  103.                            y / 16,
  104.                            mb);
  105.  
  106.                 mberrors[mb] |= 1;
  107.             }
  108.         }
  109.  
  110.         /* Chroma planes */
  111.  
  112.         for(p = 0; p < 2; p++) {
  113.  
  114.             for(i = 0; i < 2; i++) {
  115.                 v = read(fd[i], C[p][i], csiz);
  116.                 if(v != csiz) {
  117.                     fprintf(stderr, "Unable to read %c from file %d, exiting\n",
  118.                             "UV"[p], i + 1);
  119.                     return 1;
  120.                 }
  121.             }
  122.  
  123.             for(c = 0; c < csiz; c++) {
  124.                 if(C[p][0][c] != C[p][1][c]) {
  125.                     x = c % cwidth;
  126.                     y = c / cwidth;
  127.  
  128.                     mb = x / 8 + (y / 8) * mb_x;
  129.  
  130.                     mberrors[mb] |= 2 << p;
  131.  
  132.                     if(print_pixels)
  133.  
  134.                         printf("c%c diff 0x%02x != 0x%02x at pixel (%4d,%-4d) "
  135.                                "mb(%3d,%-3d) #%d\n",
  136.                                p ? 'r' : 'b',
  137.                                C[p][0][c],
  138.                                C[p][1][c],
  139.  
  140.                                x, y,
  141.                                x / 8,
  142.                                y / 8,
  143.                                x / 8 + y / 8 * cwidth / 8);
  144.                 }
  145.             }
  146.         }
  147.  
  148.         for(i = 0; i < mb_x * mb_y; i++) {
  149.             x = i % mb_x;
  150.             y = i / mb_x;
  151.  
  152.             if(mberrors[i]) {
  153.                 die = 1;
  154.  
  155.                 printf("MB (%3d,%-3d) %4d %d %c%c%c damaged\n",
  156.                        x, y, i, mberrors[i],
  157.                        mberrors[i] & 1 ? 'Y' : ' ',
  158.                        mberrors[i] & 2 ? 'U' : ' ',
  159.                        mberrors[i] & 4 ? 'V' : ' ');
  160.  
  161.                 if(dump_blocks) {
  162.                     a = Y[0] + x * 16 + y * 16 * width;
  163.                     b = Y[1] + x * 16 + y * 16 * width;
  164.  
  165.                     for(y = 0; y < 16; y++) {
  166.                         printf("%c ", "TB"[y&1]);
  167.                         for(x = 0; x < 16; x++)
  168.                             printf("%02x%c", a[x + y * width],
  169.                                    a[x + y * width] != b[x + y * width] ? '<' : ' ');
  170.  
  171.                         printf("| ");
  172.                         for(x = 0; x < 16; x++)
  173.                             printf("%02x%c", b[x + y * width],
  174.                                    a[x + y * width] != b[x + y * width] ? '<' : ' ');
  175.  
  176.                         printf("\n");
  177.                     }
  178.                 }
  179.             }
  180.         }
  181.     }
  182.  
  183.     return 0;
  184. }
  185.