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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
xyuv.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：25k
源码类别：

Audio

开发平台：

Visual C++

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