falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101485 Commits
32 Branches
792MB
Tree: 8b74458d93
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8b74458d93'
${ noResults }
FFmpeg/libavformat/avisynth.c

884 lines
27KB
Raw Blame History 

  1. /*

  2.  * AviSynth(+) support

  3.  * Copyright (c) 2012 AvxSynth Team

  4.  *

  5.  * This file is part of FFmpeg

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include "libavutil/attributes.h"

  23. #include "libavutil/internal.h"

  24. 

  25. #include "libavcodec/internal.h"

  26. 

  27. #include "avformat.h"

  28. #include "internal.h"

  29. #include "config.h"

  30. 

  31. /* Enable function pointer definitions for runtime loading. */

  32. #define AVSC_NO_DECLSPEC

  33. 

  34. /* Platform-specific directives. */

  35. #ifdef _WIN32

  36.   #include "compat/w32dlfcn.h"

  37.   #undef EXTERN_C

  38.   #define AVISYNTH_LIB "avisynth"

  39. #else

  40.   #include <dlfcn.h>

  41.   #define AVISYNTH_NAME "libavisynth"

  42.   #define AVISYNTH_LIB AVISYNTH_NAME SLIBSUF

  43. #endif

  44. 

  45. #include <avisynth/avisynth_c.h>

  46. 

  47. typedef struct AviSynthLibrary {

  48.     void *library;

  49. #define AVSC_DECLARE_FUNC(name) name ## _func name

  50.     AVSC_DECLARE_FUNC(avs_bit_blt);

  51.     AVSC_DECLARE_FUNC(avs_clip_get_error);

  52.     AVSC_DECLARE_FUNC(avs_create_script_environment);

  53.     AVSC_DECLARE_FUNC(avs_delete_script_environment);

  54.     AVSC_DECLARE_FUNC(avs_get_audio);

  55.     AVSC_DECLARE_FUNC(avs_get_error);

  56.     AVSC_DECLARE_FUNC(avs_get_frame);

  57.     AVSC_DECLARE_FUNC(avs_get_version);

  58.     AVSC_DECLARE_FUNC(avs_get_video_info);

  59.     AVSC_DECLARE_FUNC(avs_invoke);

  60.     AVSC_DECLARE_FUNC(avs_is_color_space);

  61.     AVSC_DECLARE_FUNC(avs_release_clip);

  62.     AVSC_DECLARE_FUNC(avs_release_value);

  63.     AVSC_DECLARE_FUNC(avs_release_video_frame);

  64.     AVSC_DECLARE_FUNC(avs_take_clip);

  65.     AVSC_DECLARE_FUNC(avs_bits_per_pixel);

  66.     AVSC_DECLARE_FUNC(avs_get_height_p);

  67.     AVSC_DECLARE_FUNC(avs_get_pitch_p);

  68.     AVSC_DECLARE_FUNC(avs_get_read_ptr_p);

  69.     AVSC_DECLARE_FUNC(avs_get_row_size_p);

  70.     AVSC_DECLARE_FUNC(avs_is_planar_rgb);

  71.     AVSC_DECLARE_FUNC(avs_is_planar_rgba);

  72. #undef AVSC_DECLARE_FUNC

  73. } AviSynthLibrary;

  74. 

  75. typedef struct AviSynthContext {

  76.     AVS_ScriptEnvironment *env;

  77.     AVS_Clip *clip;

  78.     const AVS_VideoInfo *vi;

  79. 

  80.     /* avisynth_read_packet_video() iterates over this. */

  81.     int n_planes;

  82.     const int *planes;

  83. 

  84.     int curr_stream;

  85.     int curr_frame;

  86.     int64_t curr_sample;

  87. 

  88.     int error;

  89. 

  90.     /* Linked list pointers. */

  91.     struct AviSynthContext *next;

  92. } AviSynthContext;

  93. 

  94. static const int avs_planes_packed[1] = { 0 };

  95. static const int avs_planes_grey[1]   = { AVS_PLANAR_Y };

  96. static const int avs_planes_yuv[3]    = { AVS_PLANAR_Y, AVS_PLANAR_U,

  97.                                           AVS_PLANAR_V };

  98. static const int avs_planes_rgb[3]    = { AVS_PLANAR_G, AVS_PLANAR_B,

  99.                                           AVS_PLANAR_R };

  100. static const int avs_planes_yuva[4]   = { AVS_PLANAR_Y, AVS_PLANAR_U,

  101.                                           AVS_PLANAR_V, AVS_PLANAR_A };

  102. static const int avs_planes_rgba[4]   = { AVS_PLANAR_G, AVS_PLANAR_B,

  103.                                           AVS_PLANAR_R, AVS_PLANAR_A };

  104. 

  105. /* A conflict between C++ global objects, atexit, and dynamic loading requires

  106.  * us to register our own atexit handler to prevent double freeing. */

  107. static AviSynthLibrary avs_library;

  108. static int avs_atexit_called        = 0;

  109. 

  110. /* Linked list of AviSynthContexts. An atexit handler destroys this list. */

  111. static AviSynthContext *avs_ctx_list = NULL;

  112. 

  113. static av_cold void avisynth_atexit_handler(void);

  114. 

  115. static av_cold int avisynth_load_library(void)

  116. {

  117.     avs_library.library = dlopen(AVISYNTH_LIB, RTLD_NOW | RTLD_LOCAL);

  118.     if (!avs_library.library)

  119.         return AVERROR_UNKNOWN;

  120. 

  121. #define LOAD_AVS_FUNC(name, continue_on_fail)                          \

  122.         avs_library.name = (name ## _func)                             \

  123.                            dlsym(avs_library.library, #name);          \

  124.         if (!continue_on_fail && !avs_library.name)                    \

  125.             goto fail;

  126. 

  127.     LOAD_AVS_FUNC(avs_bit_blt, 0);

  128.     LOAD_AVS_FUNC(avs_clip_get_error, 0);

  129.     LOAD_AVS_FUNC(avs_create_script_environment, 0);

  130.     LOAD_AVS_FUNC(avs_delete_script_environment, 0);

  131.     LOAD_AVS_FUNC(avs_get_audio, 0);

  132.     LOAD_AVS_FUNC(avs_get_error, 1); // New to AviSynth 2.6

  133.     LOAD_AVS_FUNC(avs_get_frame, 0);

  134.     LOAD_AVS_FUNC(avs_get_version, 0);

  135.     LOAD_AVS_FUNC(avs_get_video_info, 0);

  136.     LOAD_AVS_FUNC(avs_invoke, 0);

  137.     LOAD_AVS_FUNC(avs_is_color_space, 1);

  138.     LOAD_AVS_FUNC(avs_release_clip, 0);

  139.     LOAD_AVS_FUNC(avs_release_value, 0);

  140.     LOAD_AVS_FUNC(avs_release_video_frame, 0);

  141.     LOAD_AVS_FUNC(avs_take_clip, 0);

  142.     LOAD_AVS_FUNC(avs_bits_per_pixel, 1);

  143.     LOAD_AVS_FUNC(avs_get_height_p, 1);

  144.     LOAD_AVS_FUNC(avs_get_pitch_p, 1);

  145.     LOAD_AVS_FUNC(avs_get_read_ptr_p, 1);

  146.     LOAD_AVS_FUNC(avs_get_row_size_p, 1);

  147.     LOAD_AVS_FUNC(avs_is_planar_rgb, 1);

  148.     LOAD_AVS_FUNC(avs_is_planar_rgba, 1);

  149. #undef LOAD_AVS_FUNC

  150. 

  151.     atexit(avisynth_atexit_handler);

  152.     return 0;

  153. 

  154. fail:

  155.     dlclose(avs_library.library);

  156.     return AVERROR_UNKNOWN;

  157. }

  158. 

  159. /* Note that avisynth_context_create and avisynth_context_destroy

  160.  * do not allocate or free the actual context! That is taken care of

  161.  * by libavformat. */

  162. static av_cold int avisynth_context_create(AVFormatContext *s)

  163. {

  164.     AviSynthContext *avs = s->priv_data;

  165.     int ret;

  166. 

  167.     if (!avs_library.library)

  168.         if (ret = avisynth_load_library())

  169.             return ret;

  170. 

  171.     avs->env = avs_library.avs_create_script_environment(3);

  172.     if (avs_library.avs_get_error) {

  173.         const char *error = avs_library.avs_get_error(avs->env);

  174.         if (error) {

  175.             av_log(s, AV_LOG_ERROR, "%s\n", error);

  176.             return AVERROR_UNKNOWN;

  177.         }

  178.     }

  179. 

  180.     if (!avs_ctx_list) {

  181.         avs_ctx_list = avs;

  182.     } else {

  183.         avs->next    = avs_ctx_list;

  184.         avs_ctx_list = avs;

  185.     }

  186. 

  187.     return 0;

  188. }

  189. 

  190. static av_cold void avisynth_context_destroy(AviSynthContext *avs)

  191. {

  192.     if (avs_atexit_called)

  193.         return;

  194. 

  195.     if (avs == avs_ctx_list) {

  196.         avs_ctx_list = avs->next;

  197.     } else {

  198.         AviSynthContext *prev = avs_ctx_list;

  199.         while (prev->next != avs)

  200.             prev = prev->next;

  201.         prev->next = avs->next;

  202.     }

  203. 

  204.     if (avs->clip) {

  205.         avs_library.avs_release_clip(avs->clip);

  206.         avs->clip = NULL;

  207.     }

  208.     if (avs->env) {

  209.         avs_library.avs_delete_script_environment(avs->env);

  210.         avs->env = NULL;

  211.     }

  212. }

  213. 

  214. static av_cold void avisynth_atexit_handler(void)

  215. {

  216.     AviSynthContext *avs = avs_ctx_list;

  217. 

  218.     while (avs) {

  219.         AviSynthContext *next = avs->next;

  220.         avisynth_context_destroy(avs);

  221.         avs = next;

  222.     }

  223.     dlclose(avs_library.library);

  224. 

  225.     avs_atexit_called = 1;

  226. }

  227. 

  228. /* Create AVStream from audio and video data. */

  229. static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)

  230. {

  231.     AviSynthContext *avs = s->priv_data;

  232.     int planar = 0; // 0: packed, 1: YUV, 2: Y8, 3: Planar RGB, 4: YUVA, 5: Planar RGBA

  233. 

  234.     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

  235.     st->codecpar->codec_id   = AV_CODEC_ID_RAWVIDEO;

  236.     st->codecpar->width      = avs->vi->width;

  237.     st->codecpar->height     = avs->vi->height;

  238. 

  239.     st->avg_frame_rate    = (AVRational) { avs->vi->fps_numerator,

  240.                                            avs->vi->fps_denominator };

  241.     st->start_time        = 0;

  242.     st->duration          = avs->vi->num_frames;

  243.     st->nb_frames         = avs->vi->num_frames;

  244.     avpriv_set_pts_info(st, 32, avs->vi->fps_denominator, avs->vi->fps_numerator);

  245. 

  246.     av_log(s, AV_LOG_TRACE, "avs_is_field_based: %d\n", avs_is_field_based(avs->vi));

  247.     av_log(s, AV_LOG_TRACE, "avs_is_parity_known: %d\n", avs_is_parity_known(avs->vi));

  248. 

  249.     /* The following typically only works when assumetff (-bff) and

  250.      * assumefieldbased is used in-script. Additional

  251.      * logic using GetParity() could deliver more accurate results

  252.      * but also decodes a frame which we want to avoid. */

  253.     st->codecpar->field_order = AV_FIELD_UNKNOWN;

  254.     if (avs_is_field_based(avs->vi)) {

  255.         if (avs_is_tff(avs->vi)) {

  256.             st->codecpar->field_order = AV_FIELD_TT;

  257.         }

  258.         else if (avs_is_bff(avs->vi)) {

  259.             st->codecpar->field_order = AV_FIELD_BB;

  260.         }

  261.     }

  262. 

  263.     switch (avs->vi->pixel_type) {

  264.     /* 10~16-bit YUV pix_fmts (AviSynth+) */

  265.     case AVS_CS_YUV444P10:

  266.         st->codecpar->format = AV_PIX_FMT_YUV444P10;

  267.         planar               = 1;

  268.         break;

  269.     case AVS_CS_YUV422P10:

  270.         st->codecpar->format = AV_PIX_FMT_YUV422P10;

  271.         planar               = 1;

  272.         break;

  273.     case AVS_CS_YUV420P10:

  274.         st->codecpar->format = AV_PIX_FMT_YUV420P10;

  275.         planar               = 1;

  276.         break;

  277.     case AVS_CS_YUV444P12:

  278.         st->codecpar->format = AV_PIX_FMT_YUV444P12;

  279.         planar               = 1;

  280.         break;

  281.     case AVS_CS_YUV422P12:

  282.         st->codecpar->format = AV_PIX_FMT_YUV422P12;

  283.         planar               = 1;

  284.         break;

  285.     case AVS_CS_YUV420P12:

  286.         st->codecpar->format = AV_PIX_FMT_YUV420P12;

  287.         planar               = 1;

  288.         break;

  289.     case AVS_CS_YUV444P14:

  290.         st->codecpar->format = AV_PIX_FMT_YUV444P14;

  291.         planar               = 1;

  292.         break;

  293.     case AVS_CS_YUV422P14:

  294.         st->codecpar->format = AV_PIX_FMT_YUV422P14;

  295.         planar               = 1;

  296.         break;

  297.     case AVS_CS_YUV420P14:

  298.         st->codecpar->format = AV_PIX_FMT_YUV420P14;

  299.         planar               = 1;

  300.         break;

  301.     case AVS_CS_YUV444P16:

  302.         st->codecpar->format = AV_PIX_FMT_YUV444P16;

  303.         planar               = 1;

  304.         break;

  305.     case AVS_CS_YUV422P16:

  306.         st->codecpar->format = AV_PIX_FMT_YUV422P16;

  307.         planar               = 1;

  308.         break;

  309.     case AVS_CS_YUV420P16:

  310.         st->codecpar->format = AV_PIX_FMT_YUV420P16;

  311.         planar               = 1;

  312.         break;

  313.     /* 8~16-bit YUV pix_fmts with Alpha (AviSynth+) */

  314.     case AVS_CS_YUVA444:

  315.         st->codecpar->format = AV_PIX_FMT_YUVA444P;

  316.         planar               = 4;

  317.         break;

  318.     case AVS_CS_YUVA422:

  319.         st->codecpar->format = AV_PIX_FMT_YUVA422P;

  320.         planar               = 4;

  321.         break;

  322.     case AVS_CS_YUVA420:

  323.         st->codecpar->format = AV_PIX_FMT_YUVA420P;

  324.         planar               = 4;

  325.         break;

  326.     case AVS_CS_YUVA444P10:

  327.         st->codecpar->format = AV_PIX_FMT_YUVA444P10;

  328.         planar               = 4;

  329.         break;

  330.     case AVS_CS_YUVA422P10:

  331.         st->codecpar->format = AV_PIX_FMT_YUVA422P10;

  332.         planar               = 4;

  333.         break;

  334.     case AVS_CS_YUVA420P10:

  335.         st->codecpar->format = AV_PIX_FMT_YUVA420P10;

  336.         planar               = 4;

  337.         break;

  338.     case AVS_CS_YUVA422P12:

  339.         st->codecpar->format = AV_PIX_FMT_YUVA422P12;

  340.         planar               = 4;

  341.         break;

  342.     case AVS_CS_YUVA444P16:

  343.         st->codecpar->format = AV_PIX_FMT_YUVA444P16;

  344.         planar               = 4;

  345.         break;

  346.     case AVS_CS_YUVA422P16:

  347.         st->codecpar->format = AV_PIX_FMT_YUVA422P16;

  348.         planar               = 4;

  349.         break;

  350.     case AVS_CS_YUVA420P16:

  351.         st->codecpar->format = AV_PIX_FMT_YUVA420P16;

  352.         planar               = 4;

  353.         break;

  354.     /* Planar RGB pix_fmts (AviSynth+) */

  355.     case AVS_CS_RGBP:

  356.         st->codecpar->format = AV_PIX_FMT_GBRP;

  357.         planar               = 3;

  358.         break;

  359.     case AVS_CS_RGBP10:

  360.         st->codecpar->format = AV_PIX_FMT_GBRP10;

  361.         planar               = 3;

  362.         break;

  363.     case AVS_CS_RGBP12:

  364.         st->codecpar->format = AV_PIX_FMT_GBRP12;

  365.         planar               = 3;

  366.         break;

  367.     case AVS_CS_RGBP14:

  368.         st->codecpar->format = AV_PIX_FMT_GBRP14;

  369.         planar               = 3;

  370.         break;

  371.     case AVS_CS_RGBP16:

  372.         st->codecpar->format = AV_PIX_FMT_GBRP16;

  373.         planar               = 3;

  374.         break;

  375.     /* Single precision floating point Planar RGB (AviSynth+) */

  376.     case AVS_CS_RGBPS:

  377.         st->codecpar->format = AV_PIX_FMT_GBRPF32;

  378.         planar               = 3;

  379.         break;

  380.     /* Planar RGB pix_fmts with Alpha (AviSynth+) */

  381.     case AVS_CS_RGBAP:

  382.         st->codecpar->format = AV_PIX_FMT_GBRAP;

  383.         planar               = 5;

  384.         break;

  385.     case AVS_CS_RGBAP10:

  386.         st->codecpar->format = AV_PIX_FMT_GBRAP10;

  387.         planar               = 5;

  388.         break;

  389.     case AVS_CS_RGBAP12:

  390.         st->codecpar->format = AV_PIX_FMT_GBRAP12;

  391.         planar               = 5;

  392.         break;

  393.     case AVS_CS_RGBAP16:

  394.         st->codecpar->format = AV_PIX_FMT_GBRAP16;

  395.         planar               = 5;

  396.         break;

  397.     /* Single precision floating point Planar RGB with Alpha (AviSynth+) */

  398.     case AVS_CS_RGBAPS:

  399.         st->codecpar->format = AV_PIX_FMT_GBRAPF32;

  400.         planar               = 5;

  401.         break;

  402.     /* 10~16-bit gray pix_fmts (AviSynth+) */

  403.     case AVS_CS_Y10:

  404.         st->codecpar->format = AV_PIX_FMT_GRAY10;

  405.         planar               = 2;

  406.         break;

  407.     case AVS_CS_Y12:

  408.         st->codecpar->format = AV_PIX_FMT_GRAY12;

  409.         planar               = 2;

  410.         break;

  411.     case AVS_CS_Y14:

  412.         st->codecpar->format = AV_PIX_FMT_GRAY14;

  413.         planar               = 2;

  414.         break;

  415.     case AVS_CS_Y16:

  416.         st->codecpar->format = AV_PIX_FMT_GRAY16;

  417.         planar               = 2;

  418.         break;

  419.     /* Single precision floating point gray (AviSynth+) */

  420.     case AVS_CS_Y32:

  421.         st->codecpar->format = AV_PIX_FMT_GRAYF32;

  422.         planar               = 2;

  423.         break;

  424.     /* pix_fmts added in AviSynth 2.6 */

  425.     case AVS_CS_YV24:

  426.         st->codecpar->format = AV_PIX_FMT_YUV444P;

  427.         planar               = 1;

  428.         break;

  429.     case AVS_CS_YV16:

  430.         st->codecpar->format = AV_PIX_FMT_YUV422P;

  431.         planar               = 1;

  432.         break;

  433.     case AVS_CS_YV411:

  434.         st->codecpar->format = AV_PIX_FMT_YUV411P;

  435.         planar               = 1;

  436.         break;

  437.     case AVS_CS_Y8:

  438.         st->codecpar->format = AV_PIX_FMT_GRAY8;

  439.         planar               = 2;

  440.         break;

  441.     /* 16-bit packed RGB pix_fmts (AviSynth+) */

  442.     case AVS_CS_BGR48:

  443.         st->codecpar->format = AV_PIX_FMT_BGR48;

  444.         break;

  445.     case AVS_CS_BGR64:

  446.         st->codecpar->format = AV_PIX_FMT_BGRA64;

  447.         break;

  448.     /* AviSynth 2.5 pix_fmts */

  449.     case AVS_CS_BGR24:

  450.         st->codecpar->format = AV_PIX_FMT_BGR24;

  451.         break;

  452.     case AVS_CS_BGR32:

  453.         st->codecpar->format = AV_PIX_FMT_RGB32;

  454.         break;

  455.     case AVS_CS_YUY2:

  456.         st->codecpar->format = AV_PIX_FMT_YUYV422;

  457.         break;

  458.     case AVS_CS_YV12:

  459.         st->codecpar->format = AV_PIX_FMT_YUV420P;

  460.         planar               = 1;

  461.         break;

  462.     case AVS_CS_I420: // Is this even used anywhere?

  463.         st->codecpar->format = AV_PIX_FMT_YUV420P;

  464.         planar               = 1;

  465.         break;

  466.     default:

  467.         av_log(s, AV_LOG_ERROR,

  468.                "unknown AviSynth colorspace %d\n", avs->vi->pixel_type);

  469.         avs->error = 1;

  470.         return AVERROR_UNKNOWN;

  471.     }

  472. 

  473.     switch (planar) {

  474.     case 5: // Planar RGB + Alpha

  475.         avs->n_planes = 4;

  476.         avs->planes   = avs_planes_rgba;

  477.         break;

  478.     case 4: // YUV + Alpha

  479.         avs->n_planes = 4;

  480.         avs->planes   = avs_planes_yuva;

  481.         break;

  482.     case 3: // Planar RGB

  483.         avs->n_planes = 3;

  484.         avs->planes   = avs_planes_rgb;

  485.         break;

  486.     case 2: // Y8

  487.         avs->n_planes = 1;

  488.         avs->planes   = avs_planes_grey;

  489.         break;

  490.     case 1: // YUV

  491.         avs->n_planes = 3;

  492.         avs->planes   = avs_planes_yuv;

  493.         break;

  494.     default:

  495.         avs->n_planes = 1;

  496.         avs->planes   = avs_planes_packed;

  497.     }

  498.     return 0;

  499. }

  500. 

  501. static int avisynth_create_stream_audio(AVFormatContext *s, AVStream *st)

  502. {

  503.     AviSynthContext *avs = s->priv_data;

  504. 

  505.     st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;

  506.     st->codecpar->sample_rate = avs->vi->audio_samples_per_second;

  507.     st->codecpar->channels    = avs->vi->nchannels;

  508.     st->duration              = avs->vi->num_audio_samples;

  509.     avpriv_set_pts_info(st, 64, 1, avs->vi->audio_samples_per_second);

  510. 

  511.     switch (avs->vi->sample_type) {

  512.     case AVS_SAMPLE_INT8:

  513.         st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;

  514.         break;

  515.     case AVS_SAMPLE_INT16:

  516.         st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;

  517.         break;

  518.     case AVS_SAMPLE_INT24:

  519.         st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;

  520.         break;

  521.     case AVS_SAMPLE_INT32:

  522.         st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;

  523.         break;

  524.     case AVS_SAMPLE_FLOAT:

  525.         st->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE;

  526.         break;

  527.     default:

  528.         av_log(s, AV_LOG_ERROR,

  529.                "unknown AviSynth sample type %d\n", avs->vi->sample_type);

  530.         avs->error = 1;

  531.         return AVERROR_UNKNOWN;

  532.     }

  533.     return 0;

  534. }

  535. 

  536. static int avisynth_create_stream(AVFormatContext *s)

  537. {

  538.     AviSynthContext *avs = s->priv_data;

  539.     AVStream *st;

  540.     int ret;

  541.     int id = 0;

  542. 

  543.     if (avs_has_video(avs->vi)) {

  544.         st = avformat_new_stream(s, NULL);

  545.         if (!st)

  546.             return AVERROR_UNKNOWN;

  547.         st->id = id++;

  548.         if (ret = avisynth_create_stream_video(s, st))

  549.             return ret;

  550.     }

  551.     if (avs_has_audio(avs->vi)) {

  552.         st = avformat_new_stream(s, NULL);

  553.         if (!st)

  554.             return AVERROR_UNKNOWN;

  555.         st->id = id++;

  556.         if (ret = avisynth_create_stream_audio(s, st))

  557.             return ret;

  558.     }

  559.     return 0;

  560. }

  561. 

  562. static int avisynth_open_file(AVFormatContext *s)

  563. {

  564.     AviSynthContext *avs = s->priv_data;

  565.     AVS_Value arg, val;

  566.     int ret;

  567. #ifdef _WIN32

  568.     char filename_ansi[MAX_PATH * 4];

  569.     wchar_t filename_wc[MAX_PATH * 4];

  570. #endif

  571. 

  572.     if (ret = avisynth_context_create(s))

  573.         return ret;

  574. 

  575. #ifdef _WIN32

  576.     /* Convert UTF-8 to ANSI code page */

  577.     MultiByteToWideChar(CP_UTF8, 0, s->url, -1, filename_wc, MAX_PATH * 4);

  578.     WideCharToMultiByte(CP_THREAD_ACP, 0, filename_wc, -1, filename_ansi,

  579.                         MAX_PATH * 4, NULL, NULL);

  580.     arg = avs_new_value_string(filename_ansi);

  581. #else

  582.     arg = avs_new_value_string(s->url);

  583. #endif

  584.     val = avs_library.avs_invoke(avs->env, "Import", arg, 0);

  585.     if (avs_is_error(val)) {

  586.         av_log(s, AV_LOG_ERROR, "%s\n", avs_as_error(val));

  587.         ret = AVERROR_UNKNOWN;

  588.         goto fail;

  589.     }

  590.     if (!avs_is_clip(val)) {

  591.         av_log(s, AV_LOG_ERROR, "AviSynth script did not return a clip\n");

  592.         ret = AVERROR_UNKNOWN;

  593.         goto fail;

  594.     }

  595. 

  596.     avs->clip = avs_library.avs_take_clip(val, avs->env);

  597.     avs->vi   = avs_library.avs_get_video_info(avs->clip);

  598. 

  599.     /* On Windows, FFmpeg supports AviSynth interface version 6 or higher.

  600.      * This includes AviSynth 2.6 RC1 or higher, and AviSynth+ r1718 or higher,

  601.      * and excludes 2.5 and the 2.6 alphas. */

  602. 

  603.     if (avs_library.avs_get_version(avs->clip) < 6) {

  604.         av_log(s, AV_LOG_ERROR,

  605.                "AviSynth version is too old. Please upgrade to either AviSynth 2.6 >= RC1 or AviSynth+ >= r1718.\n");

  606.         ret = AVERROR_UNKNOWN;

  607.         goto fail;

  608.     }

  609. 

  610.     /* Release the AVS_Value as it will go out of scope. */

  611.     avs_library.avs_release_value(val);

  612. 

  613.     if (ret = avisynth_create_stream(s))

  614.         goto fail;

  615. 

  616.     return 0;

  617. 

  618. fail:

  619.     avisynth_context_destroy(avs);

  620.     return ret;

  621. }

  622. 

  623. static void avisynth_next_stream(AVFormatContext *s, AVStream **st,

  624.                                  AVPacket *pkt, int *discard)

  625. {

  626.     AviSynthContext *avs = s->priv_data;

  627. 

  628.     avs->curr_stream++;

  629.     avs->curr_stream %= s->nb_streams;

  630. 

  631.     *st = s->streams[avs->curr_stream];

  632.     if ((*st)->discard == AVDISCARD_ALL)

  633.         *discard = 1;

  634.     else

  635.         *discard = 0;

  636. 

  637.     return;

  638. }

  639. 

  640. /* Copy AviSynth clip data into an AVPacket. */

  641. static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt,

  642.                                       int discard)

  643. {

  644.     AviSynthContext *avs = s->priv_data;

  645.     AVS_VideoFrame *frame;

  646.     unsigned char *dst_p;

  647.     const unsigned char *src_p;

  648.     int n, i, plane, rowsize, planeheight, pitch, bits, ret;

  649.     const char *error;

  650. 

  651.     if (avs->curr_frame >= avs->vi->num_frames)

  652.         return AVERROR_EOF;

  653. 

  654.     /* This must happen even if the stream is discarded to prevent desync. */

  655.     n = avs->curr_frame++;

  656.     if (discard)

  657.         return 0;

  658. 

  659.     bits = avs_library.avs_bits_per_pixel(avs->vi);

  660. 

  661.     /* Without the cast to int64_t, calculation overflows at about 9k x 9k

  662.      * resolution. */

  663.     pkt->size = (((int64_t)avs->vi->width *

  664.                   (int64_t)avs->vi->height) * bits) / 8;

  665.     if (!pkt->size)

  666.         return AVERROR_UNKNOWN;

  667. 

  668.     if ((ret = av_new_packet(pkt, pkt->size)) < 0)

  669.         return ret;

  670. 

  671.     pkt->pts      = n;

  672.     pkt->dts      = n;

  673.     pkt->duration = 1;

  674.     pkt->stream_index = avs->curr_stream;

  675. 

  676.     frame = avs_library.avs_get_frame(avs->clip, n);

  677.     error = avs_library.avs_clip_get_error(avs->clip);

  678.     if (error) {

  679.         av_log(s, AV_LOG_ERROR, "%s\n", error);

  680.         avs->error = 1;

  681.         av_packet_unref(pkt);

  682.         return AVERROR_UNKNOWN;

  683.     }

  684. 

  685.     dst_p = pkt->data;

  686.     for (i = 0; i < avs->n_planes; i++) {

  687.         plane = avs->planes[i];

  688.         src_p = avs_library.avs_get_read_ptr_p(frame, plane);

  689.         pitch = avs_library.avs_get_pitch_p(frame, plane);

  690. 

  691.         rowsize     = avs_library.avs_get_row_size_p(frame, plane);

  692.         planeheight = avs_library.avs_get_height_p(frame, plane);

  693. 

  694.         /* Flip RGB video. */

  695.         if (avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR)   ||

  696.             avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR48) ||

  697.             avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR64)) {

  698.             src_p = src_p + (planeheight - 1) * pitch;

  699.             pitch = -pitch;

  700.         }

  701. 

  702.         avs_library.avs_bit_blt(avs->env, dst_p, rowsize, src_p, pitch,

  703.                                  rowsize, planeheight);

  704.         dst_p += rowsize * planeheight;

  705.     }

  706. 

  707.     avs_library.avs_release_video_frame(frame);

  708.     return 0;

  709. }

  710. 

  711. static int avisynth_read_packet_audio(AVFormatContext *s, AVPacket *pkt,

  712.                                       int discard)

  713. {

  714.     AviSynthContext *avs = s->priv_data;

  715.     AVRational fps, samplerate;

  716.     int samples, ret;

  717.     int64_t n;

  718.     const char *error;

  719. 

  720.     if (avs->curr_sample >= avs->vi->num_audio_samples)

  721.         return AVERROR_EOF;

  722. 

  723.     fps.num        = avs->vi->fps_numerator;

  724.     fps.den        = avs->vi->fps_denominator;

  725.     samplerate.num = avs->vi->audio_samples_per_second;

  726.     samplerate.den = 1;

  727. 

  728.     if (avs_has_video(avs->vi)) {

  729.         if (avs->curr_frame < avs->vi->num_frames)

  730.             samples = av_rescale_q(avs->curr_frame, samplerate, fps) -

  731.                       avs->curr_sample;

  732.         else

  733.             samples = av_rescale_q(1, samplerate, fps);

  734.     } else {

  735.         samples = 1000;

  736.     }

  737. 

  738.     /* After seeking, audio may catch up with video. */

  739.     if (samples <= 0) {

  740.         pkt->size = 0;

  741.         pkt->data = NULL;

  742.         return 0;

  743.     }

  744. 

  745.     if (avs->curr_sample + samples > avs->vi->num_audio_samples)

  746.         samples = avs->vi->num_audio_samples - avs->curr_sample;

  747. 

  748.     /* This must happen even if the stream is discarded to prevent desync. */

  749.     n                 = avs->curr_sample;

  750.     avs->curr_sample += samples;

  751.     if (discard)

  752.         return 0;

  753. 

  754.     pkt->size = avs_bytes_per_channel_sample(avs->vi) *

  755.                 samples * avs->vi->nchannels;

  756.     if (!pkt->size)

  757.         return AVERROR_UNKNOWN;

  758. 

  759.     if ((ret = av_new_packet(pkt, pkt->size)) < 0)

  760.         return ret;

  761. 

  762.     pkt->pts      = n;

  763.     pkt->dts      = n;

  764.     pkt->duration = samples;

  765.     pkt->stream_index = avs->curr_stream;

  766. 

  767.     avs_library.avs_get_audio(avs->clip, pkt->data, n, samples);

  768.     error = avs_library.avs_clip_get_error(avs->clip);

  769.     if (error) {

  770.         av_log(s, AV_LOG_ERROR, "%s\n", error);

  771.         avs->error = 1;

  772.         av_packet_unref(pkt);

  773.         return AVERROR_UNKNOWN;

  774.     }

  775.     return 0;

  776. }

  777. 

  778. static av_cold int avisynth_read_header(AVFormatContext *s)

  779. {

  780.     int ret;

  781. 

  782.     // Calling library must implement a lock for thread-safe opens.

  783.     if (ret = ff_lock_avformat())

  784.         return ret;

  785. 

  786.     if (ret = avisynth_open_file(s)) {

  787.         ff_unlock_avformat();

  788.         return ret;

  789.     }

  790. 

  791.     ff_unlock_avformat();

  792.     return 0;

  793. }

  794. 

  795. static int avisynth_read_packet(AVFormatContext *s, AVPacket *pkt)

  796. {

  797.     AviSynthContext *avs = s->priv_data;

  798.     AVStream *st;

  799.     int discard = 0;

  800.     int ret;

  801. 

  802.     if (avs->error)

  803.         return AVERROR_UNKNOWN;

  804. 

  805.     /* If either stream reaches EOF, try to read the other one before

  806.      * giving up. */

  807.     avisynth_next_stream(s, &st, pkt, &discard);

  808.     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {

  809.         ret = avisynth_read_packet_video(s, pkt, discard);

  810.         if (ret == AVERROR_EOF && avs_has_audio(avs->vi)) {

  811.             avisynth_next_stream(s, &st, pkt, &discard);

  812.             return avisynth_read_packet_audio(s, pkt, discard);

  813.         }

  814.     } else {

  815.         ret = avisynth_read_packet_audio(s, pkt, discard);

  816.         if (ret == AVERROR_EOF && avs_has_video(avs->vi)) {

  817.             avisynth_next_stream(s, &st, pkt, &discard);

  818.             return avisynth_read_packet_video(s, pkt, discard);

  819.         }

  820.     }

  821. 

  822.     return ret;

  823. }

  824. 

  825. static av_cold int avisynth_read_close(AVFormatContext *s)

  826. {

  827.     if (ff_lock_avformat())

  828.         return AVERROR_UNKNOWN;

  829. 

  830.     avisynth_context_destroy(s->priv_data);

  831.     ff_unlock_avformat();

  832.     return 0;

  833. }

  834. 

  835. static int avisynth_read_seek(AVFormatContext *s, int stream_index,

  836.                               int64_t timestamp, int flags)

  837. {

  838.     AviSynthContext *avs = s->priv_data;

  839.     AVStream *st;

  840.     AVRational fps, samplerate;

  841. 

  842.     if (avs->error)

  843.         return AVERROR_UNKNOWN;

  844. 

  845.     fps        = (AVRational) { avs->vi->fps_numerator,

  846.                                 avs->vi->fps_denominator };

  847.     samplerate = (AVRational) { avs->vi->audio_samples_per_second, 1 };

  848. 

  849.     st = s->streams[stream_index];

  850.     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {

  851.         /* AviSynth frame counts are signed int. */

  852.         if ((timestamp >= avs->vi->num_frames) ||

  853.             (timestamp > INT_MAX)              ||

  854.             (timestamp < 0))

  855.             return AVERROR_EOF;

  856.         avs->curr_frame = timestamp;

  857.         if (avs_has_audio(avs->vi))

  858.             avs->curr_sample = av_rescale_q(timestamp, samplerate, fps);

  859.     } else {

  860.         if ((timestamp >= avs->vi->num_audio_samples) || (timestamp < 0))

  861.             return AVERROR_EOF;

  862.         /* Force frame granularity for seeking. */

  863.         if (avs_has_video(avs->vi)) {

  864.             avs->curr_frame  = av_rescale_q(timestamp, fps, samplerate);

  865.             avs->curr_sample = av_rescale_q(avs->curr_frame, samplerate, fps);

  866.         } else {

  867.             avs->curr_sample = timestamp;

  868.         }

  869.     }

  870. 

  871.     return 0;

  872. }

  873. 

  874. AVInputFormat ff_avisynth_demuxer = {

  875.     .name           = "avisynth",

  876.     .long_name      = NULL_IF_CONFIG_SMALL("AviSynth script"),

  877.     .priv_data_size = sizeof(AviSynthContext),

  878.     .read_header    = avisynth_read_header,

  879.     .read_packet    = avisynth_read_packet,

  880.     .read_close     = avisynth_read_close,

  881.     .read_seek      = avisynth_read_seek,

  882.     .extensions     = "avs",

  883. };