git.sesse.net Git - x264/blob - input/avs.c

   1 /*****************************************************************************
   2  * avs.c: x264 avisynth input module
   3  *****************************************************************************
   4  * Copyright (C) 2009 x264 project
   5  *
   6  * Authors: Steven Walters <kemuri9@gmail.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 #include "muxers.h"
  24 #include <windows.h>
  25
  26 /* the AVS interface currently uses __declspec to link function declarations to their definitions in the dll.
  27    this has a side effect of preventing program execution if the avisynth dll is not found,
  28    so define __declspec(dllimport) to nothing and work around this */
  29 #undef __declspec
  30 #define __declspec(i)
  31 #undef EXTERN_C
  32
  33 #ifdef HAVE_AVISYNTH_C_H
  34 #include <avisynth_c.h>
  35 #else
  36 #include "extras/avisynth_c.h"
  37 #endif
  38
  39 /* AVS uses a versioned interface to control backwards compatibility */
  40 /* YV12 support is required */
  41 #define AVS_INTERFACE_YV12 2
  42 /* when AVS supports other planar colorspaces, a workaround is required */
  43 #define AVS_INTERFACE_OTHER_PLANAR 5
  44
  45 /* maximum size of the sequence of filters to try on non script files */
  46 #define AVS_MAX_SEQUENCE 5
  47
  48 #define LOAD_AVS_FUNC(name, continue_on_fail) \
  49 {\
  50     h->func.name = (void*)GetProcAddress( h->library, #name );\
  51     if( !continue_on_fail && !h->func.name )\
  52         goto fail;\
  53 }
  54
  55 typedef struct
  56 {
  57     AVS_Clip *clip;
  58     AVS_ScriptEnvironment *env;
  59     HMODULE library;
  60     int num_frames;
  61     /* declare function pointers for the utilized functions to be loaded without __declspec,
  62        as the avisynth header does not compensate for this type of usage */
  63     struct
  64     {
  65         const char *(__stdcall *avs_clip_get_error)( AVS_Clip *clip );
  66         AVS_ScriptEnvironment *(__stdcall *avs_create_script_environment)( int version );
  67         void (__stdcall *avs_delete_script_environment)( AVS_ScriptEnvironment *env );
  68         AVS_VideoFrame *(__stdcall *avs_get_frame)( AVS_Clip *clip, int n );
  69         int (__stdcall *avs_get_version)( AVS_Clip *clip );
  70         const AVS_VideoInfo *(__stdcall *avs_get_video_info)( AVS_Clip *clip );
  71         int (__stdcall *avs_function_exists)( AVS_ScriptEnvironment *env, const char *name );
  72         AVS_Value (__stdcall *avs_invoke)( AVS_ScriptEnvironment *env, const char *name,
  73             AVS_Value args, const char **arg_names );
  74         void (__stdcall *avs_release_clip)( AVS_Clip *clip );
  75         void (__stdcall *avs_release_value)( AVS_Value value );
  76         void (__stdcall *avs_release_video_frame)( AVS_VideoFrame *frame );
  77         AVS_Clip *(__stdcall *avs_take_clip)( AVS_Value, AVS_ScriptEnvironment *env );
  78     } func;
  79 } avs_hnd_t;
  80
  81 /* load the library and functions we require from it */
  82 static int avs_load_library( avs_hnd_t *h )
  83 {
  84     h->library = LoadLibrary( "avisynth" );
  85     if( !h->library )
  86         return -1;
  87     LOAD_AVS_FUNC( avs_clip_get_error, 0 );
  88     LOAD_AVS_FUNC( avs_create_script_environment, 0 );
  89     LOAD_AVS_FUNC( avs_delete_script_environment, 1 );
  90     LOAD_AVS_FUNC( avs_get_frame, 0 );
  91     LOAD_AVS_FUNC( avs_get_version, 0 );
  92     LOAD_AVS_FUNC( avs_get_video_info, 0 );
  93     LOAD_AVS_FUNC( avs_function_exists, 0 );
  94     LOAD_AVS_FUNC( avs_invoke, 0 );
  95     LOAD_AVS_FUNC( avs_release_clip, 0 );
  96     LOAD_AVS_FUNC( avs_release_value, 0 );
  97     LOAD_AVS_FUNC( avs_release_video_frame, 0 );
  98     LOAD_AVS_FUNC( avs_take_clip, 0 );
  99     return 0;
 100 fail:
 101     FreeLibrary( h->library );
 102     return -1;
 103 }
 104
 105 /* generate a filter sequence to try based on the filename extension */
 106 static void avs_build_filter_sequence( char *filename_ext, const char *filter[AVS_MAX_SEQUENCE+1] )
 107 {
 108     int i=0, j;
 109     const char *all_purpose[] = { "FFmpegSource2", "DSS2", "DirectShowSource", 0 };
 110     if( !strcasecmp( filename_ext, "avi" ) )
 111         filter[i++] = "AVISource";
 112     if( !strcasecmp( filename_ext, "d2v" ) )
 113         filter[i++] = "MPEG2Source";
 114     if( !strcasecmp( filename_ext, "dga" ) )
 115         filter[i++] = "AVCSource";
 116     for( j = 0; all_purpose[j] && i < AVS_MAX_SEQUENCE; j++ )
 117         filter[i++] = all_purpose[j];
 118 }
 119
 120 static int open_file( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
 121 {
 122     FILE *fh = fopen( psz_filename, "r" );
 123     if( !fh )
 124         return -1;
 125     else if( !x264_is_regular_file( fh ) )
 126     {
 127         fprintf( stderr, "avs [error]: AVS input is incompatible with non-regular file `%s'\n", psz_filename );
 128         return -1;
 129     }
 130     fclose( fh );
 131
 132     avs_hnd_t *h = malloc( sizeof(avs_hnd_t) );
 133     if( !h )
 134         return -1;
 135     if( avs_load_library( h ) )
 136     {
 137         fprintf( stderr, "avs [error]: failed to load avisynth\n" );
 138         return -1;
 139     }
 140     h->env = h->func.avs_create_script_environment( AVS_INTERFACE_YV12 );
 141     if( !h->env )
 142     {
 143         fprintf( stderr, "avs [error]: failed to initiate avisynth\n" );
 144         return -1;
 145     }
 146     AVS_Value arg = avs_new_value_string( psz_filename );
 147     AVS_Value res;
 148     char *filename_ext = get_filename_extension( psz_filename );
 149
 150     if( !strcasecmp( filename_ext, "avs" ) )
 151     {
 152         res = h->func.avs_invoke( h->env, "Import", arg, NULL );
 153         if( avs_is_error( res ) )
 154         {
 155             fprintf( stderr, "avs [error]: %s\n", avs_as_string( res ) );
 156             return -1;
 157         }
 158     }
 159     else /* non script file */
 160     {
 161         /* cycle through known source filters to find one that works */
 162         const char *filter[AVS_MAX_SEQUENCE+1] = { 0 };
 163         avs_build_filter_sequence( filename_ext, filter );
 164         int i;
 165         for( i = 0; filter[i]; i++ )
 166         {
 167             fprintf( stderr, "avs [info]: Trying %s... ", filter[i] );
 168             if( !h->func.avs_function_exists( h->env, filter[i] ) )
 169             {
 170                 fprintf( stderr, "not found\n" );
 171                 continue;
 172             }
 173             if( !strncasecmp( filter[i], "FFmpegSource", 12 ) )
 174             {
 175                 fprintf( stderr, "Indexing... " );
 176                 fflush( stderr );
 177             }
 178             res = h->func.avs_invoke( h->env, filter[i], arg, NULL );
 179             if( !avs_is_error( res ) )
 180             {
 181                 fprintf( stderr, "succeeded\n" );
 182                 break;
 183             }
 184             fprintf( stderr, "failed\n" );
 185         }
 186         if( !filter[i] )
 187         {
 188             fprintf( stderr, "avs [error]: unable to find source filter to open `%s'\n", psz_filename );
 189             return -1;
 190         }
 191     }
 192     if( !avs_is_clip( res ) )
 193     {
 194         fprintf( stderr, "avs [error]: `%s' didn't return a video clip\n", psz_filename );
 195         return -1;
 196     }
 197     h->clip = h->func.avs_take_clip( res, h->env );
 198     int avs_version = h->func.avs_get_version( h->clip );
 199     const AVS_VideoInfo *vi = h->func.avs_get_video_info( h->clip );
 200     if( !avs_has_video( vi ) )
 201     {
 202         fprintf( stderr, "avs [error]: `%s' has no video data\n", psz_filename );
 203         return -1;
 204     }
 205     if( vi->width&1 || vi->height&1 )
 206     {
 207         fprintf( stderr, "avs [error]: input clip width or height not divisible by 2 (%dx%d)\n",
 208                  vi->width, vi->height );
 209         return -1;
 210     }
 211     /* always call ConvertToYV12 to convert non YV12 planar colorspaces to YV12 when user's AVS supports them,
 212        as all planar colorspaces are flagged as YV12. If it is already YV12 in this case, the call does nothing */
 213     if( !avs_is_yv12( vi ) || avs_version >= AVS_INTERFACE_OTHER_PLANAR )
 214     {
 215         h->func.avs_release_clip( h->clip );
 216         fprintf( stderr, "avs [warning]: converting input clip to YV12\n" );
 217         const char *arg_name[2] = { NULL, "interlaced" };
 218         AVS_Value arg_arr[2] = { res, avs_new_value_bool( p_param->b_interlaced ) };
 219         AVS_Value res2 = h->func.avs_invoke( h->env, "ConvertToYV12", avs_new_value_array( arg_arr, 2 ), arg_name );
 220         if( avs_is_error( res2 ) )
 221         {
 222             fprintf( stderr, "avs [error]: Couldn't convert input clip to YV12\n" );
 223             return -1;
 224         }
 225         h->clip = h->func.avs_take_clip( res2, h->env );
 226         h->func.avs_release_value( res2 );
 227         vi = h->func.avs_get_video_info( h->clip );
 228     }
 229     h->func.avs_release_value( res );
 230
 231     p_param->i_width = vi->width;
 232     p_param->i_height = vi->height;
 233     p_param->i_fps_num = vi->fps_numerator;
 234     p_param->i_fps_den = vi->fps_denominator;
 235     h->num_frames = vi->num_frames;
 236     p_param->i_csp = X264_CSP_YV12;
 237
 238     fprintf( stderr, "avs [info]: %dx%d @ %.2f fps (%d frames)\n",
 239              p_param->i_width, p_param->i_height,
 240              (double)p_param->i_fps_num / p_param->i_fps_den,
 241              h->num_frames );
 242
 243     *p_handle = h;
 244     return 0;
 245 }
 246
 247 static int get_frame_total( hnd_t handle )
 248 {
 249     avs_hnd_t *h = handle;
 250     return h->num_frames;
 251 }
 252
 253 static int picture_alloc( x264_picture_t *pic, int i_csp, int i_width, int i_height )
 254 {
 255     pic->img.i_csp = i_csp;
 256     pic->img.i_plane = 3;
 257     pic->param = NULL;
 258     return 0;
 259 }
 260
 261 static int read_frame( x264_picture_t *p_pic, hnd_t handle, int i_frame )
 262 {
 263     static int plane[3] = { AVS_PLANAR_Y, AVS_PLANAR_V, AVS_PLANAR_U };
 264     avs_hnd_t *h = handle;
 265     if( i_frame >= h->num_frames )
 266         return -1;
 267     AVS_VideoFrame *frm =
 268     p_pic->opaque = h->func.avs_get_frame( h->clip, i_frame );
 269     int i;
 270     const char *err = h->func.avs_clip_get_error( h->clip );
 271     if( err )
 272     {
 273         fprintf( stderr, "avs [error]: %s occurred while reading frame %d\n", err, i_frame );
 274         return -1;
 275     }
 276     for( i = 0; i < 3; i++ )
 277     {
 278         /* explicitly cast away the const attribute to avoid a warning */
 279         p_pic->img.plane[i] = (uint8_t*)avs_get_read_ptr_p( frm, plane[i] );
 280         p_pic->img.i_stride[i] = avs_get_pitch_p( frm, plane[i] );
 281     }
 282     return 0;
 283 }
 284
 285 static int release_frame( x264_picture_t *pic, hnd_t handle )
 286 {
 287     avs_hnd_t *h = handle;
 288     h->func.avs_release_video_frame( pic->opaque );
 289     return 0;
 290 }
 291
 292 static void picture_clean( x264_picture_t *pic )
 293 {
 294     memset( pic, 0, sizeof(x264_picture_t) );
 295 }
 296
 297 static int close_file( hnd_t handle )
 298 {
 299     avs_hnd_t *h = handle;
 300     h->func.avs_release_clip( h->clip );
 301     if( h->func.avs_delete_script_environment )
 302         h->func.avs_delete_script_environment( h->env );
 303     FreeLibrary( h->library );
 304     free( h );
 305     return 0;
 306 }
 307
 308 cli_input_t avs_input = { open_file, get_frame_total, picture_alloc, read_frame, release_frame, picture_clean, close_file };