开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
xyuv.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：25k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

xyuv.c：源码内容
  1. /*****************************************************************************
  2.  * xyuv.c: a SDL yuv 420 planer viewer.
  3.  *****************************************************************************
  4.  * Copyright (C) 2004 Laurent Aimar <fenrir@via.ecp.fr>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  19.  *****************************************************************************/
  21. #include <stdlib.h>
  22. #include <stdio.h>
  23. #include <string.h>
  24. #include <stdint.h>
  26. #include <SDL/SDL.h>
  28. #define YUV_MAX 20
  29. #define SDL_TITLE "xyuv: %s - %d/%d - %.2ffps"
  30. typedef struct
  31. {
  32.     /* globals */
  33.     int     i_width;
  34.     int     i_height;
  35.     int     i_frame_size;
  36.     int     i_frame;
  37.     int     i_frames;
  38.     float   f_fps;
  40.     float   f_y;
  42.     int     b_pause;
  43.     int     b_grid;
  44.     int     b_split;
  45.     int     b_diff;
  46.     int     i_join;
  48.     /* Constructed picture */
  49.     int     i_wall_width;   /* in picture count */
  51.     /* YUV files */
  52.     int     i_yuv;
  53.     struct
  54.     {
  55.         char    *name;
  56.         FILE    *f;         /* handles */
  57.         int     i_frames;   /* frames count */
  59.         /* Position in the whole picture */
  60.         int     x, y;
  61.     } yuv[YUV_MAX];
  63.     /* SDL */
  64.     int i_sdl_width;
  65.     int i_sdl_height;
  67.     int i_display_width;
  68.     int i_display_height;
  69.     char *title;
  71.     SDL_Surface *screen;
  72.     SDL_Overlay *overlay;
  74.     /* */
  75.     uint8_t *pic;
  77. } xyuv_t;
  79. xyuv_t xyuv = {
  80.     .i_width = 0,
  81.     .i_height = 0,
  82.     .i_frame  = 1,
  83.     .i_frames = 0,
  84.     .f_fps = 25.0,
  85.     .f_y = 0.0,
  86.     .i_wall_width = 0,
  88.     .i_yuv = 0,
  90.     .b_pause = 0,
  91.     .b_split = 0,
  92.     .b_diff = 0,
  93.     .i_join = -1,
  95.     .title = NULL,
  96.     .pic = NULL,
  97. };
  99. static void help( void )
  100. {
  101.     fprintf( stderr,
  102.              "Syntax: xyuv [options] file [file2 ...]n"
  103.              "n"
  104.              "      --help                  Print this helpn"
  105.              "n"
  106.              "  -s, --size <WIDTHxHEIGHT>   Set input sizen"
  107.              "  -w, --width <integer>       Set widthn"
  108.              "  -h, --height <integer>      Set heightn"
  109.              "n"
  110.              "  -S, --split                 Show splited Y/U/V planesn"
  111.              "  -d, --diff                  Show difference (only 2 files) in split moden"
  112.              "  -j, --joint <integer>n"
  113.              "n"
  114.              "  -y <float>                  Set Y factorn"
  115.              "n"
  116.              "  -g, --grid                  Show a grid (macroblock 16x16)n"
  117.              "  -W <integer>                Set wall width (in picture count)n"
  118.              "  -f, --fps <float>           Set fpsn"
  119.              "n" );
  120. }
  122. static void xyuv_count_frames( xyuv_t *xyuv );
  123. static void xyuv_detect( int *pi_width, int *pi_height );
  124. static void xyuv_display( xyuv_t *xyuv, int i_frame );
  126. int main( int argc, char **argv )
  127. {
  128.     int i;
  130.     /* Parse commande line */
  131.     for( i = 1; i < argc; i++ ) {
  132.         if( !strcasecmp( argv[i], "--help" ) ) {
  133.             help();
  134.             return 0;
  135.         }
  136.         if( !strcmp( argv[i], "-d" ) || !strcasecmp( argv[i], "--diff" ) ) {
  137.             xyuv.b_diff = 1;
  138.         } else if( !strcmp( argv[i], "-S" ) || !strcasecmp( argv[i], "--split" ) ) {
  139.             xyuv.b_split = 1;
  140.         } else if( !strcmp( argv[i], "-f" ) || !strcasecmp( argv[i], "--fps" ) ) {
  141.             if( i >= argc -1 ) goto err_missing_arg;
  142.             xyuv.f_fps = atof( argv[++i] );
  143.         } else if( !strcmp( argv[i], "-h" ) || !strcasecmp( argv[i], "--height" ) ) {
  144.             if( i >= argc -1 ) goto err_missing_arg;
  145.             xyuv.i_height = atoi( argv[++i] );
  146.         } else if( !strcmp( argv[i], "-w" ) || !strcasecmp( argv[i], "--width" ) ) {
  147.             if( i >= argc -1 ) goto err_missing_arg;
  148.             xyuv.i_width = atoi( argv[++i] );
  149.         } else if( !strcmp( argv[i], "-s" ) || !strcasecmp( argv[i], "--size" ) ) {
  150.             char *p;
  152.             if( i >= argc -1 ) goto err_missing_arg;
  154.             xyuv.i_width = strtol( argv[++i], &p, 0 );
  155.             p++;
  156.             xyuv.i_height = atoi( p );
  157.         } else if( !strcmp( argv[i], "-W" ) ) {
  158.             if( i >= argc -1 ) goto err_missing_arg;
  159.             xyuv.i_wall_width = atoi( argv[++i] );
  160.         } else if( !strcmp( argv[i], "-y" ) ) {
  161.             if( i >= argc -1 ) goto err_missing_arg;
  162.             xyuv.f_y = atof( argv[++i] );
  163.         } else if( !strcmp( argv[i], "-j" ) || !strcasecmp( argv[i], "--join" ) ) {
  164.             if( i >= argc -1 ) goto err_missing_arg;
  165.             xyuv.i_join = atoi( argv[++i] );
  166.         } else if( !strcmp( argv[i], "-g" ) || !strcasecmp( argv[i], "--grid" ) ) {
  167.             xyuv.b_grid = 1;
  168.         } else {
  169.             FILE *f = fopen( argv[i], "rb" );
  170.             if( !f ) {
  171.                 fprintf( stderr, "cannot open YUV %sn", argv[i] );
  172.             } else {
  173.                 xyuv.yuv[xyuv.i_yuv].name = strdup( argv[i] );
  174.                 xyuv.yuv[xyuv.i_yuv].f = f;
  175.                 xyuv.yuv[xyuv.i_yuv].i_frames = 0;
  177.                 xyuv.i_yuv++;
  178.             }
  179.         }
  180.     }
  182.     if( xyuv.i_yuv == 0 ) {
  183.         fprintf( stderr, "no file to displayn" );
  184.         return -1;
  185.     }
  186.     if( xyuv.i_width == 0 || xyuv.i_height == 0 ) {
  187.         char *psz = xyuv.yuv[0].name;
  188.         char *num;
  189.         char *x;
  190.         /* See if we find widthxheight in the file name */
  191.         for( ;; ) {
  192.             if( !( x = strchr( psz+1, 'x' ) ) ) {
  193.                 break;
  194.             }
  195.             num = x;
  196.             while( num > psz && num[-1] >= '0' && num[-1] <= '9' )
  197.                 num--;
  199.             if( num != x && x[1] >= '0' && x[1] <= '9' ) {
  200.                 xyuv.i_width = atoi( num );
  201.                 xyuv.i_height = atoi( x+1 );
  202.                 break;
  203.             }
  204.             psz = x;
  205.         }
  206.         fprintf( stderr, "file name gives %dx%dn", xyuv.i_width, xyuv.i_height );
  207.     }
  209.     if( xyuv.i_width == 0 || xyuv.i_height == 0 ) {
  210.         xyuv_detect( &xyuv.i_width, &xyuv.i_height );
  211.     }
  213.     if( xyuv.i_width == 0 || xyuv.i_height == 0 ) {
  214.         fprintf( stderr, "invalid or missing frames sizen" );
  215.         return -1;
  216.     }
  217.     if( xyuv.b_diff && xyuv.i_yuv != 2 ) {
  218.         fprintf( stderr, "--diff works only with 2 filesn" );
  219.         return -1;
  220.     }
  221.     if( (xyuv.i_join == 0 || xyuv.i_join >= xyuv.i_width) && xyuv.i_yuv != 2 ) {
  222.         fprintf( stderr, "--join woeks only with two files and range is [1, width-1]n" );
  223.         return -1;
  224.     }
  225.     if( xyuv.i_join % 2 != 0 ) {
  226.         if( xyuv.i_join + 1 < xyuv.i_width )
  227.             xyuv.i_join++;
  228.         else
  229.             xyuv.i_join--;
  230.     }
  232.     /* Now check frames */
  233.     fprintf( stderr, "displaying :n" );
  234.     xyuv.i_frame_size = 3 * xyuv.i_width * xyuv.i_height / 2;
  235.     xyuv_count_frames( &xyuv );
  236.     for( i = 0; i < xyuv.i_yuv; i++ ) {
  237.         fprintf( stderr, " - '%s' : %d framesn", xyuv.yuv[i].name, xyuv.yuv[i].i_frames );
  238.     }
  240.     if( xyuv.i_frames == 0 ) {
  241.         fprintf( stderr, "no frames to displayn" );
  242.     }
  244.     xyuv.pic = malloc( xyuv.i_frame_size );
  246.     /* calculate SDL view */
  247.     if( xyuv.i_wall_width > xyuv.i_yuv ) {
  248.         xyuv.i_wall_width = xyuv.i_yuv;
  249.     }
  250.     if( xyuv.i_wall_width == 0 ) {
  251.         while( xyuv.i_wall_width < xyuv.i_yuv && xyuv.i_wall_width * xyuv.i_wall_width < xyuv.i_yuv ) {
  252.             xyuv.i_wall_width++;
  253.         }
  254.     }
  256.     for( i = 0; i < xyuv.i_yuv; i++ ) {
  257.         if( xyuv.b_diff || xyuv.i_join > 0 ) {
  258.             xyuv.yuv[i].x = 0;
  259.             xyuv.yuv[i].y = 0;
  260.         } else if( xyuv.b_split ) {
  261.             xyuv.yuv[i].x = (i%xyuv.i_wall_width) * 3 * xyuv.i_width / 2;
  262.             xyuv.yuv[i].y = (i/xyuv.i_wall_width) * xyuv.i_height;
  263.         } else {
  264.             xyuv.yuv[i].x = (i%xyuv.i_wall_width) * xyuv.i_width;
  265.             xyuv.yuv[i].y = (i/xyuv.i_wall_width) * xyuv.i_height;
  266.         }
  267.     }
  268.     if( xyuv.b_diff ) {
  269.         xyuv.i_sdl_width = 3 * xyuv.i_width / 2;
  270.         xyuv.i_sdl_height= xyuv.i_height;
  271.     } else if( xyuv.i_join > 0 ) {
  272.         xyuv.i_sdl_width = xyuv.i_width;
  273.         xyuv.i_sdl_height= xyuv.i_height;
  274.     } else if( xyuv.b_split ) {
  275.         xyuv.i_sdl_width = xyuv.i_wall_width * 3 * xyuv.i_width / 2;
  276.         xyuv.i_sdl_height= xyuv.i_height * ( ( xyuv.i_yuv  + xyuv.i_wall_width - 1 ) / xyuv.i_wall_width );
  277.     } else {
  278.         xyuv.i_sdl_width = xyuv.i_wall_width * xyuv.i_width;
  279.         xyuv.i_sdl_height= xyuv.i_height * ( ( xyuv.i_yuv  + xyuv.i_wall_width - 1 ) / xyuv.i_wall_width );
  280.     }
  281.     xyuv.i_display_width = xyuv.i_sdl_width;
  282.     xyuv.i_display_height = xyuv.i_sdl_height;
  284.     /* Open SDL */
  285.     if( SDL_Init( SDL_INIT_EVENTTHREAD|SDL_INIT_NOPARACHUTE|SDL_INIT_VIDEO) ) {
  286.         fprintf( stderr, "cannot init SDLn" );
  287.         return -1;
  288.     }
  290.     SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, 100 );
  291.     SDL_EventState( SDL_KEYUP, SDL_IGNORE );
  293.     xyuv.screen = SDL_SetVideoMode( xyuv.i_sdl_width, xyuv.i_sdl_height, 0,
  294.                                     SDL_HWSURFACE|SDL_RESIZABLE|
  295.                                     SDL_ASYNCBLIT|SDL_HWACCEL );
  296.     if( xyuv.screen == NULL ) {
  297.         fprintf( stderr, "SDL_SetVideoMode failedn" );
  298.         return -1;
  299.     }
  301.     SDL_LockSurface( xyuv.screen );
  302.     xyuv.overlay = SDL_CreateYUVOverlay( xyuv.i_sdl_width, xyuv.i_sdl_height,
  303.                                          SDL_YV12_OVERLAY,
  304.                                          xyuv.screen );
  305.     /* reset with black */
  306.     memset( xyuv.overlay->pixels[0],   0, xyuv.overlay->pitches[0] * xyuv.i_sdl_height );
  307.     memset( xyuv.overlay->pixels[1], 128, xyuv.overlay->pitches[1] * xyuv.i_sdl_height / 2);
  308.     memset( xyuv.overlay->pixels[2], 128, xyuv.overlay->pitches[2] * xyuv.i_sdl_height / 2);
  309.     SDL_UnlockSurface( xyuv.screen );
  311.     if( xyuv.overlay == NULL ) {
  312.         fprintf( stderr, "recon: SDL_CreateYUVOverlay failedn" );
  313.         return -1;
  314.     }
  316.     for( ;; ) {
  317.         SDL_Event event;
  318.         static int b_fullscreen = 0;
  319.         int64_t i_start = SDL_GetTicks();
  320.         int i_wait;
  322.         if( !xyuv.b_pause ) {
  323.             xyuv_display( &xyuv, xyuv.i_frame );
  324.         }
  326.         for( ;; ) {
  327.             int b_refresh = 0;
  328.             while( SDL_PollEvent( &event ) )  {
  329.                 switch( event.type )
  330.                 {
  331.                     case SDL_QUIT:
  332.                         if( b_fullscreen )
  333.                             SDL_WM_ToggleFullScreen( xyuv.screen );
  334.                         exit( 1 );
  336.                     case SDL_KEYDOWN:
  337.                         switch( event.key.keysym.sym )
  338.                         {
  339.                             case SDLK_q:
  340.                             case SDLK_ESCAPE:
  341.                                 if( b_fullscreen )
  342.                                     SDL_WM_ToggleFullScreen( xyuv.screen );
  343.                                 exit(1);
  345.                             case SDLK_f:
  346.                                 if( SDL_WM_ToggleFullScreen( xyuv.screen ) )
  347.                                     b_fullscreen = 1 - b_fullscreen;
  348.                                 break;
  350.                             case SDLK_g:
  351.                                 if( xyuv.b_grid )
  352.                                     xyuv.b_grid = 0;
  353.                                 else
  354.                                     xyuv.b_grid = 1;
  355.                                 if( xyuv.b_pause )
  356.                                     b_refresh = 1;
  357.                                 break;
  359.                             case SDLK_SPACE:
  360.                                 if( xyuv.b_pause )
  361.                                     xyuv.b_pause = 0;
  362.                                 else
  363.                                     xyuv.b_pause = 1;
  364.                                 break;
  365.                             case SDLK_LEFT:
  366.                                 if( xyuv.i_frame > 1 ) xyuv.i_frame--;
  367.                                 b_refresh = 1;
  368.                                 break;
  370.                             case SDLK_RIGHT:
  371.                                 if( xyuv.i_frame >= xyuv.i_frames )
  372.                                     xyuv_count_frames( &xyuv );
  373.                                 if( xyuv.i_frame < xyuv.i_frames ) xyuv.i_frame++;
  374.                                 b_refresh = 1;
  375.                                 break;
  377.                             case SDLK_HOME:
  378.                                 xyuv.i_frame = 1;
  379.                                 if( xyuv.b_pause )
  380.                                     b_refresh = 1;
  381.                                 break;
  383.                             case SDLK_END:
  384.                                 xyuv_count_frames( &xyuv );
  385.                                 xyuv.i_frame = xyuv.i_frames;
  386.                                 b_refresh = 1;
  387.                                 break;
  389.                             case SDLK_UP:
  390.                                 xyuv.i_frame += xyuv.i_frames / 20;
  392.                                 if( xyuv.i_frame >= xyuv.i_frames )
  393.                                     xyuv_count_frames( &xyuv );
  395.                                 if( xyuv.i_frame > xyuv.i_frames )
  396.                                     xyuv.i_frame = xyuv.i_frames;
  397.                                 b_refresh = 1;
  398.                                 break;
  400.                             case SDLK_DOWN:
  401.                                 xyuv.i_frame -= xyuv.i_frames / 20;
  402.                                 if( xyuv.i_frame < 1 )
  403.                                     xyuv.i_frame = 1;
  404.                                 b_refresh = 1;
  405.                                 break;
  407.                             case SDLK_PAGEUP:
  408.                                 xyuv.i_frame += xyuv.i_frames / 10;
  410.                                 if( xyuv.i_frame >= xyuv.i_frames )
  411.                                     xyuv_count_frames( &xyuv );
  413.                                 if( xyuv.i_frame > xyuv.i_frames )
  414.                                     xyuv.i_frame = xyuv.i_frames;
  415.                                 b_refresh = 1;
  416.                                 break;
  418.                             case SDLK_PAGEDOWN:
  419.                                 xyuv.i_frame -= xyuv.i_frames / 10;
  420.                                 if( xyuv.i_frame < 1 )
  421.                                     xyuv.i_frame = 1;
  422.                                 b_refresh = 1;
  423.                                 break;
  425.                             default:
  426.                                 break;
  427.                         }
  428.                         break;
  429.                     case SDL_VIDEORESIZE:
  430.                         xyuv.i_display_width = event.resize.w;
  431.                         xyuv.i_display_height = event.resize.h;
  432.                         xyuv.screen = SDL_SetVideoMode( xyuv.i_display_width, xyuv.i_display_height, 0,
  433.                                                         SDL_HWSURFACE|SDL_RESIZABLE|
  434.                                                         SDL_ASYNCBLIT|SDL_HWACCEL );
  435.                         xyuv_display( &xyuv, xyuv.i_frame );
  436.                         break;
  438.                     default:
  439.                         break;
  440.                 }
  441.             }
  442.             if( b_refresh ) {
  443.                 xyuv.b_pause = 1;
  444.                 xyuv_display( &xyuv, xyuv.i_frame );
  445.             }
  446.             /* wait */
  447.             i_wait = 1000 / xyuv.f_fps - ( SDL_GetTicks() - i_start);
  448.             if( i_wait < 0 )
  449.                 break;
  450.             else if( i_wait > 200 )
  451.                 SDL_Delay( 200 );
  452.             else {
  453.                 SDL_Delay( i_wait );
  454.                 break;
  455.             }
  456.         }
  457.         if( !xyuv.b_pause ) {
  458.             /* next frame */
  459.             if( xyuv.i_frame == xyuv.i_frames )
  460.                     xyuv.b_pause = 1;
  461.             else if( xyuv.i_frame < xyuv.i_frames )
  462.                 xyuv.i_frame++;
  463.         }
  464.     }
  467.     return 0;
  469. err_missing_arg:
  470.     fprintf( stderr, "missing arg for option=%sn", argv[i] );
  471.     return -1;
  472. }
  475. static void xyuv_display( xyuv_t *xyuv, int i_frame )
  476. {
  477.     SDL_Rect rect;
  478.     int i_picture = 0;
  479.     int i;
  481.     if( i_frame > xyuv->i_frames )
  482.         return;
  484.     xyuv->i_frame = i_frame;
  486.     /* Load and copy pictue data */
  487.     for( i = 0; i < xyuv->i_yuv; i++ ) {
  488.         int i_plane;
  490.         fprintf( stderr, "yuv[%d] %d/%dn", i, i_frame, xyuv->yuv[i].i_frames );
  491.         if( i_frame - 1 >= xyuv->yuv[i].i_frames ) {
  492.             xyuv_count_frames( xyuv );
  493.             if( i_frame - 1 >= xyuv->yuv[i].i_frames )
  494.                 continue;
  495.         }
  496.         i_picture++;
  498.         fseek( xyuv->yuv[i].f, (xyuv->i_frame-1) * xyuv->i_frame_size, SEEK_SET );
  499.         fread( xyuv->pic, xyuv->i_frame_size, 1, xyuv->yuv[i].f );
  501.         SDL_LockYUVOverlay( xyuv->overlay );
  503.         if( xyuv->b_diff || xyuv->b_split ) {
  504.             /* Reset UV */
  505.             for( i_plane = 1; i_plane < 3; i_plane++ ) {
  506.                 memset( xyuv->overlay->pixels[i_plane], 128, xyuv->overlay->pitches[i_plane] * xyuv->overlay->h / 2 );
  507.             }
  508.             /* Show diff in Y plane of overlay */
  510.             for( i_plane = 0; i_plane < 3; i_plane++ ) {
  511.                 int div = i_plane == 0 ? 1 : 2;
  512.                 uint8_t *src = xyuv->pic;
  513.                 uint8_t *dst = xyuv->overlay->pixels[0] +
  514.                                 (xyuv->yuv[i].x + xyuv->yuv[i].y * xyuv->overlay->pitches[0] );
  515.                 int j;
  516.                 if( i_plane == 1 ) {
  517.                     src +=  5*xyuv->i_width * xyuv->i_height/4;
  518.                     dst += xyuv->i_width;
  519.                 } else if( i_plane == 2 ) {
  520.                     src += xyuv->i_width * xyuv->i_height;
  521.                     dst += xyuv->i_width + xyuv->i_height / 2 * xyuv->overlay->pitches[0];
  522.                 }
  524.                 for( j = 0; j < xyuv->i_height / div; j++ ) {
  525.                     if( i_picture == 1 || xyuv->b_split ) {
  526.                         memcpy( dst, src, xyuv->i_width / div );
  527.                     } else {
  528.                         int k;
  529.                         for( k = 0; k < xyuv->i_width / div; k++ ) {
  530.                             dst[k] = abs( dst[k] - src[k]);
  531.                         }
  532.                     }
  533.                     src += xyuv->i_width / div;
  534.                     dst += xyuv->overlay->pitches[0];
  535.                 }
  536.             }
  537.         } else {
  538.             for( i_plane = 0; i_plane < 3; i_plane++ ) {
  539.                 int div = i_plane == 0 ? 1 : 2;
  540.                 uint8_t *src = xyuv->pic;
  541.                 uint8_t *dst = xyuv->overlay->pixels[i_plane] +
  542.                                 ((xyuv->yuv[i].x + xyuv->yuv[i].y * xyuv->overlay->pitches[i_plane] ) / div );
  543.                 int w = xyuv->i_width / div;
  544.                 int j;
  546.                 if( i_plane == 1 ) {
  547.                     src +=  5*xyuv->i_width * xyuv->i_height/4;
  548.                 } else if( i_plane == 2 ) {
  549.                     src += xyuv->i_width * xyuv->i_height;
  550.                 }
  551.                 if( xyuv->i_join > 0 ) {
  552.                     if( i_picture > 1 ) {
  553.                         src += xyuv->i_join / div;
  554.                         dst += xyuv->i_join / div;
  555.                         w = (xyuv->i_width - xyuv->i_join) /div;
  556.                     } else {
  557.                         w = xyuv->i_join / div;
  558.                     }
  559.                 }
  561.                 for( j = 0; j < xyuv->i_height / div; j++ ) {
  562.                     memcpy( dst, src, w );
  563.                     src += xyuv->i_width / div;
  564.                     dst += xyuv->overlay->pitches[i_plane];
  565.                 }
  566.             }
  567.         }
  569.         SDL_UnlockYUVOverlay( xyuv->overlay );
  570.     }
  572.     if( xyuv->f_y != 0.0 ) {
  573.         uint8_t *pix = xyuv->overlay->pixels[0];
  574.         int j;
  576.         for( j = 0; j < xyuv->i_sdl_height; j++ ) {
  577.             int k;
  578.             for( k = 0; k < xyuv->i_sdl_width; k++ ) {
  579.                 int v= pix[k] * xyuv->f_y;
  580.                 if( v > 255 )
  581.                     pix[k] = 255;
  582.                 else if( v < 0 )
  583.                     pix[k] = 0;
  584.                 else
  585.                     pix[k] = v;
  586.             }
  587.             pix += xyuv->overlay->pitches[0];
  588.         }
  589.     }
  590.     if( xyuv->b_grid ) {
  591.         int x, y;
  593.         for( y = 0; y < xyuv->i_sdl_height; y += 4 ) {
  594.             uint8_t *p = xyuv->overlay->pixels[0] + y * xyuv->overlay->pitches[0];
  595.             for( x = 0; x < xyuv->i_sdl_width; x += 4 ) {
  596.                 if( x%16== 0 || y%16 == 0 )
  597.                     p[x] = 0;
  598.             }
  599.         }
  600.     }
  602.     /* Update display */
  603.     rect.x = 0;
  604.     rect.y = 0;
  605.     rect.w = xyuv->i_display_width;
  606.     rect.h = xyuv->i_display_height;
  607.     SDL_DisplayYUVOverlay( xyuv->overlay, &rect );
  609.     /* Display title */
  610.     if( xyuv->title )
  611.         free( xyuv->title );
  612.     asprintf( &xyuv->title, SDL_TITLE, xyuv->yuv[0].name, xyuv->i_frame, xyuv->i_frames, xyuv->f_fps );
  613.     SDL_WM_SetCaption( xyuv->title, "" );
  614. }
  616. static void xyuv_count_frames( xyuv_t *xyuv )
  617. {
  618.     int i;
  620.     xyuv->i_frames = 0;
  621.     if( xyuv->i_frame_size <= 0 )
  622.         return;
  624.     for( i = 0; i < xyuv->i_yuv; i++ ) {
  625.         /* Beurk but avoid using fstat */
  626.         fseek( xyuv->yuv[i].f, 0, SEEK_END );
  628.         xyuv->yuv[i].i_frames = ftell( xyuv->yuv[i].f ) / xyuv->i_frame_size;
  629.         fprintf( stderr, "count (%d) -> %dn", i, xyuv->yuv[i].i_frames );
  631.         fseek( xyuv->yuv[i].f, 0, SEEK_SET );
  633.         if( xyuv->i_frames < xyuv->yuv[i].i_frames )
  634.             xyuv->i_frames = xyuv->yuv[i].i_frames;
  635.     }
  636. }
  638. static inline int ssd( int a ) { return a*a; }
  640. static void xyuv_detect( int *pi_width, int *pi_height )
  641. {
  642.     static const int pi_size[][2] = {
  643.         {128, 96},
  644.         {160,120},
  645.         {320,244},
  646.         {320,288},
  648.         /* PAL */
  649.         {176,144},  // QCIF
  650.         {352,288},  // CIF
  651.         {352,576},  // 1/2 D1
  652.         {480,576},  // 2/3 D1
  653.         {544,576},
  654.         {640,576},  // VGA
  655.         {704,576},  // D1
  656.         {720,576},  // D1
  658.         /* NTSC */
  659.         {176,112},  // QCIF
  660.         {320,240},  // MPEG I
  661.         {352,240},  // CIF
  662.         {352,480},  // 1/2 D1
  663.         {480,480},  // 2/3 D1
  664.         {544,480},
  665.         {640,480},  // VGA
  666.         {704,480},  // D1
  667.         {720,480},  // D1
  669.         /* */
  670.         {0,0},
  671.     };
  672.     int i_max;
  673.     int i_size_max;
  674.     uint8_t *pic;
  675.     int i;
  677.     *pi_width = 0;
  678.     *pi_height = 0;
  680.     /* Compute size max */
  681.     for( i_max = 0, i_size_max = 0;
  682.             pi_size[i_max][0] != 0 && pi_size[i_max][1] != 0; i_max++ ) {
  683.         int s = pi_size[i_max][0] * pi_size[i_max][1] * 3 / 2;
  685.         if( i_size_max < s )
  686.             i_size_max = s;
  687.     }
  689.     /* Temporary buffer */
  690.     i_size_max *= 3;
  691.     pic = malloc( i_size_max );
  693.     fprintf( stderr, "guessing size for:n" );
  694.     for( i = 0; i < xyuv.i_yuv; i++ ) {
  695.         int j;
  696.         int i_read;
  697.         double dbest = 255*255;
  698.         int    i_best = i_max;
  699.         int64_t t;
  701.         fprintf( stderr, " - %sn", xyuv.yuv[i].name );
  703.         i_read = fread( pic, 1, i_size_max, xyuv.yuv[i].f );
  704.         if( i_read < 0 )
  705.             continue;
  707.         /* Check if file size is at least compatible with one format
  708.          * (if not, ignore file size)*/
  709.         fseek( xyuv.yuv[i].f, 0, SEEK_END );
  710.         t = ftell( xyuv.yuv[i].f );
  711.         fseek( xyuv.yuv[i].f, 0, SEEK_SET );
  712.         for( j = 0; j < i_max; j++ ) {
  713.             const int w = pi_size[j][0];
  714.             const int h = pi_size[j][1];
  715.             const int s = w * h * 3 / 2;
  717.             if( t % s == 0 )
  718.                 break;
  719.         }
  720.         if( j == i_max )
  721.             t = 0;
  724.         /* Try all size */
  725.         for( j = 0; j < i_max; j++ ) {
  726.             const int w = pi_size[j][0];
  727.             const int h = pi_size[j][1];
  728.             const int s = w * h * 3 / 2;
  729.             double dd;
  731.             int x, y, n;
  732.             int64_t d;
  734.             /* To small */
  735.             if( i_read < 3*s )
  736.                 continue;
  737.             /* Check file size */
  738.             if( ( t > 0 && (t % s) != 0  ) ) {
  739.                 fprintf( stderr, "  * %dx%d ignored (incompatible file size)n", w, h );
  740.                 continue;
  741.             }
  744.             /* We do a simple ssd between 2 consecutives lines */
  745.             d = 0;
  746.             for( n = 0; n < 3; n++ ) {
  747.                 uint8_t *p;
  749.                 /* Y */
  750.                 p = &pic[n*s];
  751.                 for( y = 0; y < h-1; y++ ) {
  752.                     for( x = 0; x < w; x++ )
  753.                         d += ssd( p[x] - p[w+x] );
  754.                     p += w;
  755.                 }
  757.                 /* U */
  758.                 p = &pic[n*s+w*h];
  759.                 for( y = 0; y < h/2-1; y++ ) {
  760.                     for( x = 0; x < w/2; x++ )
  761.                         d += ssd( p[x] - p[(w/2)+x] );
  762.                     p += w/2;
  763.                 }
  765.                 /* V */
  766.                 p = &pic[n*s+5*w*h/4];
  767.                 for( y = 0; y < h/2-1; y++ ) {
  768.                     for( x = 0; x < w/2; x++ )
  769.                         d += ssd( p[x] - p[(w/2)+x] );
  770.                     p += w/2;
  771.                 }
  772.             }
  773.             dd = (double)d / (3*w*h*3/2);
  774.             fprintf( stderr, "  * %dx%d d=%fn", w, h, dd );
  776.             if( dd < dbest ) {
  777.                 i_best = j;
  778.                 dbest = dd;
  779.             }
  780.         }
  782.         fseek( xyuv.yuv[i].f, 0, SEEK_SET );
  784.         if( i_best < i_max ) {
  785.             fprintf( stderr, "  -> %dx%dn", pi_size[i_best][0], pi_size[i_best][1] );
  786.             *pi_width = pi_size[i_best][0];
  787.             *pi_height = pi_size[i_best][1];
  788.         }
  789.     }
  791.     free( pic );
  792. }