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.
52073 Commits
32 Branches
283MB
Tree: 03e2ec32b8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '03e2ec32b8'
${ noResults }
FFmpeg/libavfilter/vf_mp.c

871 lines
29KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2011 Michael Niedermayer

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; if not, write to the Free Software

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

  19.  *

  20.  * Parts of this file have been stolen from mplayer

  21.  */

  22. 

  23. /**

  24.  * @file

  25.  */

  26. 

  27. #include "avfilter.h"

  28. #include "video.h"

  29. #include "formats.h"

  30. #include "internal.h"

  31. #include "libavutil/avassert.h"

  32. #include "libavutil/pixdesc.h"

  33. #include "libavutil/intreadwrite.h"

  34. #include "libavutil/imgutils.h"

  35. #include "libavutil/opt.h"

  36. 

  37. #include "libmpcodecs/vf.h"

  38. #include "libmpcodecs/img_format.h"

  39. #include "libmpcodecs/cpudetect.h"

  40. #include "libmpcodecs/av_helpers.h"

  41. #include "libmpcodecs/vf_scale.h"

  42. #include "libmpcodecs/libvo/fastmemcpy.h"

  43. 

  44. #include "libswscale/swscale.h"

  45. 

  46. 

  47. //FIXME maybe link the orig in

  48. //XXX: identical pix_fmt must be following with each others

  49. static const struct {

  50.     int fmt;

  51.     enum AVPixelFormat pix_fmt;

  52. } conversion_map[] = {

  53.     {IMGFMT_ARGB, AV_PIX_FMT_ARGB},

  54.     {IMGFMT_BGRA, AV_PIX_FMT_BGRA},

  55.     {IMGFMT_BGR24, AV_PIX_FMT_BGR24},

  56.     {IMGFMT_BGR16BE, AV_PIX_FMT_RGB565BE},

  57.     {IMGFMT_BGR16LE, AV_PIX_FMT_RGB565LE},

  58.     {IMGFMT_BGR15BE, AV_PIX_FMT_RGB555BE},

  59.     {IMGFMT_BGR15LE, AV_PIX_FMT_RGB555LE},

  60.     {IMGFMT_BGR12BE, AV_PIX_FMT_RGB444BE},

  61.     {IMGFMT_BGR12LE, AV_PIX_FMT_RGB444LE},

  62.     {IMGFMT_BGR8,  AV_PIX_FMT_RGB8},

  63.     {IMGFMT_BGR4,  AV_PIX_FMT_RGB4},

  64.     {IMGFMT_BGR1,  AV_PIX_FMT_MONOBLACK},

  65.     {IMGFMT_RGB1,  AV_PIX_FMT_MONOBLACK},

  66.     {IMGFMT_RG4B,  AV_PIX_FMT_BGR4_BYTE},

  67.     {IMGFMT_BG4B,  AV_PIX_FMT_RGB4_BYTE},

  68.     {IMGFMT_RGB48LE, AV_PIX_FMT_RGB48LE},

  69.     {IMGFMT_RGB48BE, AV_PIX_FMT_RGB48BE},

  70.     {IMGFMT_ABGR, AV_PIX_FMT_ABGR},

  71.     {IMGFMT_RGBA, AV_PIX_FMT_RGBA},

  72.     {IMGFMT_RGB24, AV_PIX_FMT_RGB24},

  73.     {IMGFMT_RGB16BE, AV_PIX_FMT_BGR565BE},

  74.     {IMGFMT_RGB16LE, AV_PIX_FMT_BGR565LE},

  75.     {IMGFMT_RGB15BE, AV_PIX_FMT_BGR555BE},

  76.     {IMGFMT_RGB15LE, AV_PIX_FMT_BGR555LE},

  77.     {IMGFMT_RGB12BE, AV_PIX_FMT_BGR444BE},

  78.     {IMGFMT_RGB12LE, AV_PIX_FMT_BGR444LE},

  79.     {IMGFMT_RGB8,  AV_PIX_FMT_BGR8},

  80.     {IMGFMT_RGB4,  AV_PIX_FMT_BGR4},

  81.     {IMGFMT_BGR8,  AV_PIX_FMT_PAL8},

  82.     {IMGFMT_YUY2,  AV_PIX_FMT_YUYV422},

  83.     {IMGFMT_UYVY,  AV_PIX_FMT_UYVY422},

  84.     {IMGFMT_NV12,  AV_PIX_FMT_NV12},

  85.     {IMGFMT_NV21,  AV_PIX_FMT_NV21},

  86.     {IMGFMT_Y800,  AV_PIX_FMT_GRAY8},

  87.     {IMGFMT_Y8,    AV_PIX_FMT_GRAY8},

  88.     {IMGFMT_YVU9,  AV_PIX_FMT_YUV410P},

  89.     {IMGFMT_IF09,  AV_PIX_FMT_YUV410P},

  90.     {IMGFMT_YV12,  AV_PIX_FMT_YUV420P},

  91.     {IMGFMT_I420,  AV_PIX_FMT_YUV420P},

  92.     {IMGFMT_IYUV,  AV_PIX_FMT_YUV420P},

  93.     {IMGFMT_411P,  AV_PIX_FMT_YUV411P},

  94.     {IMGFMT_422P,  AV_PIX_FMT_YUV422P},

  95.     {IMGFMT_444P,  AV_PIX_FMT_YUV444P},

  96.     {IMGFMT_440P,  AV_PIX_FMT_YUV440P},

  97. 

  98.     {IMGFMT_420A,  AV_PIX_FMT_YUVA420P},

  99. 

  100.     {IMGFMT_420P16_LE,  AV_PIX_FMT_YUV420P16LE},

  101.     {IMGFMT_420P16_BE,  AV_PIX_FMT_YUV420P16BE},

  102.     {IMGFMT_422P16_LE,  AV_PIX_FMT_YUV422P16LE},

  103.     {IMGFMT_422P16_BE,  AV_PIX_FMT_YUV422P16BE},

  104.     {IMGFMT_444P16_LE,  AV_PIX_FMT_YUV444P16LE},

  105.     {IMGFMT_444P16_BE,  AV_PIX_FMT_YUV444P16BE},

  106. 

  107.     // YUVJ are YUV formats that use the full Y range and not just

  108.     // 16 - 235 (see colorspaces.txt).

  109.     // Currently they are all treated the same way.

  110.     {IMGFMT_YV12,  AV_PIX_FMT_YUVJ420P},

  111.     {IMGFMT_422P,  AV_PIX_FMT_YUVJ422P},

  112.     {IMGFMT_444P,  AV_PIX_FMT_YUVJ444P},

  113.     {IMGFMT_440P,  AV_PIX_FMT_YUVJ440P},

  114. 

  115.     {IMGFMT_XVMC_MOCO_MPEG2, AV_PIX_FMT_XVMC_MPEG2_MC},

  116.     {IMGFMT_XVMC_IDCT_MPEG2, AV_PIX_FMT_XVMC_MPEG2_IDCT},

  117.     {IMGFMT_VDPAU_MPEG1,     AV_PIX_FMT_VDPAU_MPEG1},

  118.     {IMGFMT_VDPAU_MPEG2,     AV_PIX_FMT_VDPAU_MPEG2},

  119.     {IMGFMT_VDPAU_H264,      AV_PIX_FMT_VDPAU_H264},

  120.     {IMGFMT_VDPAU_WMV3,      AV_PIX_FMT_VDPAU_WMV3},

  121.     {IMGFMT_VDPAU_VC1,       AV_PIX_FMT_VDPAU_VC1},

  122.     {IMGFMT_VDPAU_MPEG4,     AV_PIX_FMT_VDPAU_MPEG4},

  123.     {0, AV_PIX_FMT_NONE}

  124. };

  125. 

  126. extern const vf_info_t ff_vf_info_detc;

  127. extern const vf_info_t ff_vf_info_dint;

  128. extern const vf_info_t ff_vf_info_divtc;

  129. extern const vf_info_t ff_vf_info_down3dright;

  130. extern const vf_info_t ff_vf_info_eq2;

  131. extern const vf_info_t ff_vf_info_eq;

  132. extern const vf_info_t ff_vf_info_fil;

  133. //extern const vf_info_t ff_vf_info_filmdint;

  134. extern const vf_info_t ff_vf_info_fspp;

  135. extern const vf_info_t ff_vf_info_ilpack;

  136. extern const vf_info_t ff_vf_info_ivtc;

  137. extern const vf_info_t ff_vf_info_mcdeint;

  138. extern const vf_info_t ff_vf_info_ow;

  139. extern const vf_info_t ff_vf_info_perspective;

  140. extern const vf_info_t ff_vf_info_phase;

  141. extern const vf_info_t ff_vf_info_pp7;

  142. extern const vf_info_t ff_vf_info_pullup;

  143. extern const vf_info_t ff_vf_info_qp;

  144. extern const vf_info_t ff_vf_info_sab;

  145. extern const vf_info_t ff_vf_info_softpulldown;

  146. extern const vf_info_t ff_vf_info_spp;

  147. extern const vf_info_t ff_vf_info_tinterlace;

  148. extern const vf_info_t ff_vf_info_uspp;

  149. 

  150. 

  151. static const vf_info_t* const filters[]={

  152.     &ff_vf_info_detc,

  153.     &ff_vf_info_dint,

  154.     &ff_vf_info_divtc,

  155.     &ff_vf_info_down3dright,

  156.     &ff_vf_info_eq2,

  157.     &ff_vf_info_eq,

  158.     &ff_vf_info_fil,

  159. //    &ff_vf_info_filmdint, cmmx.h vd.h ‘opt_screen_size_x’

  160.     &ff_vf_info_fspp,

  161.     &ff_vf_info_ilpack,

  162.     &ff_vf_info_ivtc,

  163.     &ff_vf_info_mcdeint,

  164.     &ff_vf_info_ow,

  165.     &ff_vf_info_perspective,

  166.     &ff_vf_info_phase,

  167.     &ff_vf_info_pp7,

  168.     &ff_vf_info_pullup,

  169.     &ff_vf_info_qp,

  170.     &ff_vf_info_sab,

  171.     &ff_vf_info_softpulldown,

  172.     &ff_vf_info_spp,

  173.     &ff_vf_info_tinterlace,

  174.     &ff_vf_info_uspp,

  175. 

  176.     NULL

  177. };

  178. 

  179. /*

  180. Unsupported filters

  181. 1bpp

  182. ass

  183. bmovl

  184. crop

  185. dvbscale

  186. flip

  187. expand

  188. format

  189. halfpack

  190. lavc

  191. lavcdeint

  192. noformat

  193. pp

  194. scale

  195. tfields

  196. vo

  197. yadif

  198. zrmjpeg

  199. */

  200. 

  201. CpuCaps ff_gCpuCaps; //FIXME initialize this so optims work

  202. 

  203. enum AVPixelFormat ff_mp2ff_pix_fmt(int mp){

  204.     int i;

  205.     for(i=0; conversion_map[i].fmt && mp != conversion_map[i].fmt; i++)

  206.         ;

  207.     return mp == conversion_map[i].fmt ? conversion_map[i].pix_fmt : AV_PIX_FMT_NONE;

  208. }

  209. 

  210. static void ff_sws_getFlagsAndFilterFromCmdLine(int *flags, SwsFilter **srcFilterParam, SwsFilter **dstFilterParam)

  211. {

  212.         static int firstTime=1;

  213.         *flags=0;

  214. 

  215. #if ARCH_X86

  216.         if(ff_gCpuCaps.hasMMX)

  217.                 __asm__ volatile("emms\n\t"::: "memory"); //FIXME this should not be required but it IS (even for non-MMX versions)

  218. #endif

  219.         if(firstTime)

  220.         {

  221.                 firstTime=0;

  222.                 *flags= SWS_PRINT_INFO;

  223.         }

  224.         else if( ff_mp_msg_test(MSGT_VFILTER,MSGL_DBG2) ) *flags= SWS_PRINT_INFO;

  225. 

  226.         switch(SWS_BILINEAR)

  227.         {

  228.                 case 0: *flags|= SWS_FAST_BILINEAR; break;

  229.                 case 1: *flags|= SWS_BILINEAR; break;

  230.                 case 2: *flags|= SWS_BICUBIC; break;

  231.                 case 3: *flags|= SWS_X; break;

  232.                 case 4: *flags|= SWS_POINT; break;

  233.                 case 5: *flags|= SWS_AREA; break;

  234.                 case 6: *flags|= SWS_BICUBLIN; break;

  235.                 case 7: *flags|= SWS_GAUSS; break;

  236.                 case 8: *flags|= SWS_SINC; break;

  237.                 case 9: *flags|= SWS_LANCZOS; break;

  238.                 case 10:*flags|= SWS_SPLINE; break;

  239.                 default:*flags|= SWS_BILINEAR; break;

  240.         }

  241. 

  242.         *srcFilterParam= NULL;

  243.         *dstFilterParam= NULL;

  244. }

  245. 

  246. //exact copy from vf_scale.c

  247. // will use sws_flags & src_filter (from cmd line)

  248. struct SwsContext *ff_sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)

  249. {

  250.         int flags, i;

  251.         SwsFilter *dstFilterParam, *srcFilterParam;

  252.         enum AVPixelFormat dfmt, sfmt;

  253. 

  254.         for(i=0; conversion_map[i].fmt && dstFormat != conversion_map[i].fmt; i++);

  255.         dfmt= conversion_map[i].pix_fmt;

  256.         for(i=0; conversion_map[i].fmt && srcFormat != conversion_map[i].fmt; i++);

  257.         sfmt= conversion_map[i].pix_fmt;

  258. 

  259.         if (srcFormat == IMGFMT_RGB8 || srcFormat == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;

  260.         ff_sws_getFlagsAndFilterFromCmdLine(&flags, &srcFilterParam, &dstFilterParam);

  261. 

  262.         return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags , srcFilterParam, dstFilterParam, NULL);

  263. }

  264. 

  265. typedef struct {

  266.     const AVClass *class;

  267.     vf_instance_t vf;

  268.     vf_instance_t next_vf;

  269.     AVFilterContext *avfctx;

  270.     int frame_returned;

  271.     char *filter;

  272. } MPContext;

  273. 

  274. #define OFFSET(x) offsetof(MPContext, x)

  275. #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

  276. static const AVOption mp_options[] = {

  277.     { "filter", "set MPlayer filter name and parameters", OFFSET(filter), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },

  278.     { NULL }

  279. };

  280. 

  281. AVFILTER_DEFINE_CLASS(mp);

  282. 

  283. void ff_mp_msg(int mod, int lev, const char *format, ... ){

  284.     va_list va;

  285.     va_start(va, format);

  286.     //FIXME convert lev/mod

  287.     av_vlog(NULL, AV_LOG_DEBUG, format, va);

  288.     va_end(va);

  289. }

  290. 

  291. int ff_mp_msg_test(int mod, int lev){

  292.     return 123;

  293. }

  294. 

  295. void ff_init_avcodec(void)

  296. {

  297.     //we maybe should init but its kinda 1. unneeded 2. a bit inpolite from here

  298. }

  299. 

  300. //Exact copy of vf.c

  301. void ff_vf_clone_mpi_attributes(mp_image_t* dst, mp_image_t* src){

  302.     dst->pict_type= src->pict_type;

  303.     dst->fields = src->fields;

  304.     dst->qscale_type= src->qscale_type;

  305.     if(dst->width == src->width && dst->height == src->height){

  306.         dst->qstride= src->qstride;

  307.         dst->qscale= src->qscale;

  308.     }

  309. }

  310. 

  311. //Exact copy of vf.c

  312. void ff_vf_next_draw_slice(struct vf_instance *vf,unsigned char** src, int * stride,int w, int h, int x, int y){

  313.     if (vf->next->draw_slice) {

  314.         vf->next->draw_slice(vf->next,src,stride,w,h,x,y);

  315.         return;

  316.     }

  317.     if (!vf->dmpi) {

  318.         ff_mp_msg(MSGT_VFILTER,MSGL_ERR,"draw_slice: dmpi not stored by vf_%s\n", vf->info->name);

  319.         return;

  320.     }

  321.     if (!(vf->dmpi->flags & MP_IMGFLAG_PLANAR)) {

  322.         memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+vf->dmpi->bpp/8*x,

  323.             src[0], vf->dmpi->bpp/8*w, h, vf->dmpi->stride[0], stride[0]);

  324.         return;

  325.     }

  326.     memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+x, src[0],

  327.         w, h, vf->dmpi->stride[0], stride[0]);

  328.     memcpy_pic(vf->dmpi->planes[1]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[1]+(x>>vf->dmpi->chroma_x_shift),

  329.         src[1], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[1], stride[1]);

  330.     memcpy_pic(vf->dmpi->planes[2]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[2]+(x>>vf->dmpi->chroma_x_shift),

  331.         src[2], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[2], stride[2]);

  332. }

  333. 

  334. //Exact copy of vf.c

  335. void ff_vf_mpi_clear(mp_image_t* mpi,int x0,int y0,int w,int h){

  336.     int y;

  337.     if(mpi->flags&MP_IMGFLAG_PLANAR){

  338.         y0&=~1;h+=h&1;

  339.         if(x0==0 && w==mpi->width){

  340.             // full width clear:

  341.             memset(mpi->planes[0]+mpi->stride[0]*y0,0,mpi->stride[0]*h);

  342.             memset(mpi->planes[1]+mpi->stride[1]*(y0>>mpi->chroma_y_shift),128,mpi->stride[1]*(h>>mpi->chroma_y_shift));

  343.             memset(mpi->planes[2]+mpi->stride[2]*(y0>>mpi->chroma_y_shift),128,mpi->stride[2]*(h>>mpi->chroma_y_shift));

  344.         } else

  345.         for(y=y0;y<y0+h;y+=2){

  346.             memset(mpi->planes[0]+x0+mpi->stride[0]*y,0,w);

  347.             memset(mpi->planes[0]+x0+mpi->stride[0]*(y+1),0,w);

  348.             memset(mpi->planes[1]+(x0>>mpi->chroma_x_shift)+mpi->stride[1]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));

  349.             memset(mpi->planes[2]+(x0>>mpi->chroma_x_shift)+mpi->stride[2]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));

  350.         }

  351.         return;

  352.     }

  353.     // packed:

  354.     for(y=y0;y<y0+h;y++){

  355.         unsigned char* dst=mpi->planes[0]+mpi->stride[0]*y+(mpi->bpp>>3)*x0;

  356.         if(mpi->flags&MP_IMGFLAG_YUV){

  357.             unsigned int* p=(unsigned int*) dst;

  358.             int size=(mpi->bpp>>3)*w/4;

  359.             int i;

  360. #if HAVE_BIGENDIAN

  361. #define CLEAR_PACKEDYUV_PATTERN 0x00800080

  362. #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x80008000

  363. #else

  364. #define CLEAR_PACKEDYUV_PATTERN 0x80008000

  365. #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x00800080

  366. #endif

  367.             if(mpi->flags&MP_IMGFLAG_SWAPPED){

  368.                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;

  369.                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;

  370.             } else {

  371.                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN;

  372.                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN;

  373.             }

  374.         } else

  375.             memset(dst,0,(mpi->bpp>>3)*w);

  376.     }

  377. }

  378. 

  379. int ff_vf_next_query_format(struct vf_instance *vf, unsigned int fmt){

  380.     return 1;

  381. }

  382. 

  383. //used by delogo

  384. unsigned int ff_vf_match_csp(vf_instance_t** vfp,const unsigned int* list,unsigned int preferred){

  385.     return preferred;

  386. }

  387. 

  388. mp_image_t* ff_vf_get_image(vf_instance_t* vf, unsigned int outfmt, int mp_imgtype, int mp_imgflag, int w, int h){

  389.     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, next_vf));

  390.   mp_image_t* mpi=NULL;

  391.   int w2;

  392.   int number = mp_imgtype >> 16;

  393. 

  394.   av_assert0(vf->next == NULL); // all existing filters call this just on next

  395. 

  396.   //vf_dint needs these as it calls ff_vf_get_image() before configuring the output

  397.   if(vf->w==0 && w>0) vf->w=w;

  398.   if(vf->h==0 && h>0) vf->h=h;

  399. 

  400.   av_assert0(w == -1 || w >= vf->w);

  401.   av_assert0(h == -1 || h >= vf->h);

  402.   av_assert0(vf->w > 0);

  403.   av_assert0(vf->h > 0);

  404. 

  405.   av_log(m->avfctx, AV_LOG_DEBUG, "get_image: %d:%d, vf: %d:%d\n", w,h,vf->w,vf->h);

  406. 

  407.   if (w == -1) w = vf->w;

  408.   if (h == -1) h = vf->h;

  409. 

  410.   w2=(mp_imgflag&MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE)?((w+15)&(~15)):w;

  411. 

  412.   // Note: we should call libvo first to check if it supports direct rendering

  413.   // and if not, then fallback to software buffers:

  414.   switch(mp_imgtype & 0xff){

  415.   case MP_IMGTYPE_EXPORT:

  416.     if(!vf->imgctx.export_images[0]) vf->imgctx.export_images[0]=ff_new_mp_image(w2,h);

  417.     mpi=vf->imgctx.export_images[0];

  418.     break;

  419.   case MP_IMGTYPE_STATIC:

  420.     if(!vf->imgctx.static_images[0]) vf->imgctx.static_images[0]=ff_new_mp_image(w2,h);

  421.     mpi=vf->imgctx.static_images[0];

  422.     break;

  423.   case MP_IMGTYPE_TEMP:

  424.     if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=ff_new_mp_image(w2,h);

  425.     mpi=vf->imgctx.temp_images[0];

  426.     break;

  427.   case MP_IMGTYPE_IPB:

  428.     if(!(mp_imgflag&MP_IMGFLAG_READABLE)){ // B frame:

  429.       if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=ff_new_mp_image(w2,h);

  430.       mpi=vf->imgctx.temp_images[0];

  431.       break;

  432.     }

  433.   case MP_IMGTYPE_IP:

  434.     if(!vf->imgctx.static_images[vf->imgctx.static_idx]) vf->imgctx.static_images[vf->imgctx.static_idx]=ff_new_mp_image(w2,h);

  435.     mpi=vf->imgctx.static_images[vf->imgctx.static_idx];

  436.     vf->imgctx.static_idx^=1;

  437.     break;

  438.   case MP_IMGTYPE_NUMBERED:

  439.     if (number == -1) {

  440.       int i;

  441.       for (i = 0; i < NUM_NUMBERED_MPI; i++)

  442.         if (!vf->imgctx.numbered_images[i] || !vf->imgctx.numbered_images[i]->usage_count)

  443.           break;

  444.       number = i;

  445.     }

  446.     if (number < 0 || number >= NUM_NUMBERED_MPI) return NULL;

  447.     if (!vf->imgctx.numbered_images[number]) vf->imgctx.numbered_images[number] = ff_new_mp_image(w2,h);

  448.     mpi = vf->imgctx.numbered_images[number];

  449.     mpi->number = number;

  450.     break;

  451.   }

  452.   if(mpi){

  453.     mpi->type=mp_imgtype;

  454.     mpi->w=vf->w; mpi->h=vf->h;

  455.     // keep buffer allocation status & color flags only:

  456. //    mpi->flags&=~(MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE|MP_IMGFLAG_DIRECT);

  457.     mpi->flags&=MP_IMGFLAG_ALLOCATED|MP_IMGFLAG_TYPE_DISPLAYED|MP_IMGFLAGMASK_COLORS;

  458.     // accept restrictions, draw_slice and palette flags only:

  459.     mpi->flags|=mp_imgflag&(MP_IMGFLAGMASK_RESTRICTIONS|MP_IMGFLAG_DRAW_CALLBACK|MP_IMGFLAG_RGB_PALETTE);

  460.     if(!vf->draw_slice) mpi->flags&=~MP_IMGFLAG_DRAW_CALLBACK;

  461.     if(mpi->width!=w2 || mpi->height!=h){

  462. //      printf("vf.c: MPI parameters changed!  %dx%d -> %dx%d   \n", mpi->width,mpi->height,w2,h);

  463.         if(mpi->flags&MP_IMGFLAG_ALLOCATED){

  464.             if(mpi->width<w2 || mpi->height<h){

  465.                 // need to re-allocate buffer memory:

  466.                 av_free(mpi->planes[0]);

  467.                 mpi->flags&=~MP_IMGFLAG_ALLOCATED;

  468.                 ff_mp_msg(MSGT_VFILTER,MSGL_V,"vf.c: have to REALLOCATE buffer memory :(\n");

  469.             }

  470. //      } else {

  471.         } {

  472.             mpi->width=w2; mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;

  473.             mpi->height=h; mpi->chroma_height=(h + (1<<mpi->chroma_y_shift) - 1)>>mpi->chroma_y_shift;

  474.         }

  475.     }

  476.     if(!mpi->bpp) ff_mp_image_setfmt(mpi,outfmt);

  477.     if(!(mpi->flags&MP_IMGFLAG_ALLOCATED) && mpi->type>MP_IMGTYPE_EXPORT){

  478. 

  479.         av_assert0(!vf->get_image);

  480.         // check libvo first!

  481.         if(vf->get_image) vf->get_image(vf,mpi);

  482. 

  483.         if(!(mpi->flags&MP_IMGFLAG_DIRECT)){

  484.           // non-direct and not yet allocated image. allocate it!

  485.           if (!mpi->bpp) { // no way we can allocate this

  486.               ff_mp_msg(MSGT_DECVIDEO, MSGL_FATAL,

  487.                      "ff_vf_get_image: Tried to allocate a format that can not be allocated!\n");

  488.               return NULL;

  489.           }

  490. 

  491.           // check if codec prefer aligned stride:

  492.           if(mp_imgflag&MP_IMGFLAG_PREFER_ALIGNED_STRIDE){

  493.               int align=(mpi->flags&MP_IMGFLAG_PLANAR &&

  494.                          mpi->flags&MP_IMGFLAG_YUV) ?

  495.                          (8<<mpi->chroma_x_shift)-1 : 15; // -- maybe FIXME

  496.               w2=((w+align)&(~align));

  497.               if(mpi->width!=w2){

  498. #if 0

  499.                   // we have to change width... check if we CAN co it:

  500.                   int flags=vf->query_format(vf,outfmt); // should not fail

  501.                   if(!(flags&3)) ff_mp_msg(MSGT_DECVIDEO,MSGL_WARN,"??? ff_vf_get_image{vf->query_format(outfmt)} failed!\n");

  502. //                printf("query -> 0x%X    \n",flags);

  503.                   if(flags&VFCAP_ACCEPT_STRIDE){

  504. #endif

  505.                       mpi->width=w2;

  506.                       mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;

  507. //                  }

  508.               }

  509.           }

  510. 

  511.           ff_mp_image_alloc_planes(mpi);

  512. //        printf("clearing img!\n");

  513.           ff_vf_mpi_clear(mpi,0,0,mpi->width,mpi->height);

  514.         }

  515.     }

  516.     av_assert0(!vf->start_slice);

  517.     if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)

  518.         if(vf->start_slice) vf->start_slice(vf,mpi);

  519.     if(!(mpi->flags&MP_IMGFLAG_TYPE_DISPLAYED)){

  520.             ff_mp_msg(MSGT_DECVIDEO,MSGL_V,"*** [%s] %s%s mp_image_t, %dx%dx%dbpp %s %s, %d bytes\n",

  521.                   "NULL"/*vf->info->name*/,

  522.                   (mpi->type==MP_IMGTYPE_EXPORT)?"Exporting":

  523.                   ((mpi->flags&MP_IMGFLAG_DIRECT)?"Direct Rendering":"Allocating"),

  524.                   (mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)?" (slices)":"",

  525.                   mpi->width,mpi->height,mpi->bpp,

  526.                   (mpi->flags&MP_IMGFLAG_YUV)?"YUV":((mpi->flags&MP_IMGFLAG_SWAPPED)?"BGR":"RGB"),

  527.                   (mpi->flags&MP_IMGFLAG_PLANAR)?"planar":"packed",

  528.                   mpi->bpp*mpi->width*mpi->height/8);

  529.             ff_mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"(imgfmt: %x, planes: %p,%p,%p strides: %d,%d,%d, chroma: %dx%d, shift: h:%d,v:%d)\n",

  530.                 mpi->imgfmt, mpi->planes[0], mpi->planes[1], mpi->planes[2],

  531.                 mpi->stride[0], mpi->stride[1], mpi->stride[2],

  532.                 mpi->chroma_width, mpi->chroma_height, mpi->chroma_x_shift, mpi->chroma_y_shift);

  533.             mpi->flags|=MP_IMGFLAG_TYPE_DISPLAYED;

  534.     }

  535. 

  536.   mpi->qscale = NULL;

  537.   mpi->usage_count++;

  538.   }

  539. //    printf("\rVF_MPI: %p %p %p %d %d %d    \n",

  540. //      mpi->planes[0],mpi->planes[1],mpi->planes[2],

  541. //      mpi->stride[0],mpi->stride[1],mpi->stride[2]);

  542.   return mpi;

  543. }

  544. 

  545. static void dummy_free(void *opaque, uint8_t *data){}

  546. 

  547. int ff_vf_next_put_image(struct vf_instance *vf,mp_image_t *mpi, double pts){

  548.     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, vf));

  549.     AVFilterLink *outlink     = m->avfctx->outputs[0];

  550.     AVFrame *picref = av_frame_alloc();

  551.     int i;

  552. 

  553.     av_assert0(vf->next);

  554. 

  555.     av_log(m->avfctx, AV_LOG_DEBUG, "ff_vf_next_put_image\n");

  556. 

  557.     if (!picref)

  558.         goto fail;

  559. 

  560.     picref->width  = mpi->w;

  561.     picref->height = mpi->h;

  562. 

  563.     picref->type = AVMEDIA_TYPE_VIDEO;

  564. 

  565.     for(i=0; conversion_map[i].fmt && mpi->imgfmt != conversion_map[i].fmt; i++);

  566.     picref->format = conversion_map[i].pix_fmt;

  567. 

  568.     memcpy(picref->linesize, mpi->stride, FFMIN(sizeof(picref->linesize), sizeof(mpi->stride)));

  569. 

  570.     for(i=0; i<4 && mpi->stride[i]; i++){

  571.         picref->data[i] = mpi->planes[i];

  572.     }

  573. 

  574.     if(pts != MP_NOPTS_VALUE)

  575.         picref->pts= pts * av_q2d(outlink->time_base);

  576. 

  577.     if(1) { // mp buffers are currently unsupported in libavfilter, we thus must copy

  578.         AVFrame *tofree = picref;

  579.         picref = av_frame_clone(picref);

  580.         av_frame_free(&tofree);

  581.     }

  582. 

  583.     ff_filter_frame(outlink, picref);

  584.     m->frame_returned++;

  585. 

  586.     return 1;

  587. fail:

  588.     av_frame_free(&picref);

  589.     return 0;

  590. }

  591. 

  592. int ff_vf_next_config(struct vf_instance *vf,

  593.         int width, int height, int d_width, int d_height,

  594.         unsigned int voflags, unsigned int outfmt){

  595. 

  596.     av_assert0(width>0 && height>0);

  597.     vf->next->w = width; vf->next->h = height;

  598. 

  599.     return 1;

  600. #if 0

  601.     int flags=vf->next->query_format(vf->next,outfmt);

  602.     if(!flags){

  603.         // hmm. colorspace mismatch!!!

  604.         //this is fatal for us ATM

  605.         return 0;

  606.     }

  607.     ff_mp_msg(MSGT_VFILTER,MSGL_V,"REQ: flags=0x%X  req=0x%X  \n",flags,vf->default_reqs);

  608.     miss=vf->default_reqs - (flags&vf->default_reqs);

  609.     if(miss&VFCAP_ACCEPT_STRIDE){

  610.         // vf requires stride support but vf->next doesn't support it!

  611.         // let's insert the 'expand' filter, it does the job for us:

  612.         vf_instance_t* vf2=vf_open_filter(vf->next,"expand",NULL);

  613.         if(!vf2) return 0; // shouldn't happen!

  614.         vf->next=vf2;

  615.     }

  616.     vf->next->w = width; vf->next->h = height;

  617.     return 1;

  618. #endif

  619. }

  620. 

  621. int ff_vf_next_control(struct vf_instance *vf, int request, void* data){

  622.     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, vf));

  623.     av_log(m->avfctx, AV_LOG_DEBUG, "Received control %d\n", request);

  624.     return 0;

  625. }

  626. 

  627. static int vf_default_query_format(struct vf_instance *vf, unsigned int fmt){

  628.     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, vf));

  629.     int i;

  630.     av_log(m->avfctx, AV_LOG_DEBUG, "query %X\n", fmt);

  631. 

  632.     for(i=0; conversion_map[i].fmt; i++){

  633.         if(fmt==conversion_map[i].fmt)

  634.             return 1; //we suport all

  635.     }

  636.     return 0;

  637. }

  638. 

  639. 

  640. static av_cold int init(AVFilterContext *ctx)

  641. {

  642.     MPContext *m = ctx->priv;

  643.     int cpu_flags = av_get_cpu_flags();

  644.     char name[256];

  645.     const char *args;

  646.     int i;

  647. 

  648.     ff_gCpuCaps.hasMMX      = cpu_flags & AV_CPU_FLAG_MMX;

  649.     ff_gCpuCaps.hasMMX2     = cpu_flags & AV_CPU_FLAG_MMX2;

  650.     ff_gCpuCaps.hasSSE      = cpu_flags & AV_CPU_FLAG_SSE;

  651.     ff_gCpuCaps.hasSSE2     = cpu_flags & AV_CPU_FLAG_SSE2;

  652.     ff_gCpuCaps.hasSSE3     = cpu_flags & AV_CPU_FLAG_SSE3;

  653.     ff_gCpuCaps.hasSSSE3    = cpu_flags & AV_CPU_FLAG_SSSE3;

  654.     ff_gCpuCaps.hasSSE4     = cpu_flags & AV_CPU_FLAG_SSE4;

  655.     ff_gCpuCaps.hasSSE42    = cpu_flags & AV_CPU_FLAG_SSE42;

  656.     ff_gCpuCaps.hasAVX      = cpu_flags & AV_CPU_FLAG_AVX;

  657.     ff_gCpuCaps.has3DNow    = cpu_flags & AV_CPU_FLAG_3DNOW;

  658.     ff_gCpuCaps.has3DNowExt = cpu_flags & AV_CPU_FLAG_3DNOWEXT;

  659. 

  660.     m->avfctx= ctx;

  661. 

  662.     args = m->filter;

  663.     if(!args || 1!=sscanf(args, "%255[^:=]", name)){

  664.         av_log(ctx, AV_LOG_ERROR, "Invalid parameter.\n");

  665.         return AVERROR(EINVAL);

  666.     }

  667.     args += strlen(name);

  668.     if (args[0] == '=')

  669.         args++;

  670. 

  671.     for(i=0; ;i++){

  672.         if(!filters[i] || !strcmp(name, filters[i]->name))

  673.             break;

  674.     }

  675. 

  676.     if(!filters[i]){

  677.         av_log(ctx, AV_LOG_ERROR, "Unknown filter %s\n", name);

  678.         return AVERROR(EINVAL);

  679.     }

  680. 

  681.     av_log(ctx, AV_LOG_WARNING,

  682.            "'%s' is a wrapped MPlayer filter (libmpcodecs). This filter may be removed\n"

  683.            "once it has been ported to a native libavfilter.\n", name);

  684. 

  685.     memset(&m->vf,0,sizeof(m->vf));

  686.     m->vf.info= filters[i];

  687. 

  688.     m->vf.next        = &m->next_vf;

  689.     m->vf.put_image   = ff_vf_next_put_image;

  690.     m->vf.config      = ff_vf_next_config;

  691.     m->vf.query_format= vf_default_query_format;

  692.     m->vf.control     = ff_vf_next_control;

  693.     m->vf.default_caps=VFCAP_ACCEPT_STRIDE;

  694.     m->vf.default_reqs=0;

  695.     if(m->vf.info->opts)

  696.         av_log(ctx, AV_LOG_ERROR, "opts / m_struct_set is unsupported\n");

  697. #if 0

  698.     if(vf->info->opts) { // vf_vo get some special argument

  699.       const m_struct_t* st = vf->info->opts;

  700.       void* vf_priv = m_struct_alloc(st);

  701.       int n;

  702.       for(n = 0 ; args && args[2*n] ; n++)

  703.         m_struct_set(st,vf_priv,args[2*n],args[2*n+1]);

  704.       vf->priv = vf_priv;

  705.       args = NULL;

  706.     } else // Otherwise we should have the '_oldargs_'

  707.       if(args && !strcmp(args[0],"_oldargs_"))

  708.         args = (char**)args[1];

  709.       else

  710.         args = NULL;

  711. #endif

  712.     if(m->vf.info->vf_open(&m->vf, (char*)args)<=0){

  713.         av_log(ctx, AV_LOG_ERROR, "vf_open() of %s with arg=%s failed\n", name, args);

  714.         return -1;

  715.     }

  716. 

  717.     return 0;

  718. }

  719. 

  720. static av_cold void uninit(AVFilterContext *ctx)

  721. {

  722.     MPContext *m = ctx->priv;

  723.     vf_instance_t *vf = &m->vf;

  724. 

  725.     while(vf){

  726.         vf_instance_t *next = vf->next;

  727.         if(vf->uninit)

  728.             vf->uninit(vf);

  729.         ff_free_mp_image(vf->imgctx.static_images[0]);

  730.         ff_free_mp_image(vf->imgctx.static_images[1]);

  731.         ff_free_mp_image(vf->imgctx.temp_images[0]);

  732.         ff_free_mp_image(vf->imgctx.export_images[0]);

  733.         vf = next;

  734.     }

  735. }

  736. 

  737. static int query_formats(AVFilterContext *ctx)

  738. {

  739.     AVFilterFormats *avfmts=NULL;

  740.     MPContext *m = ctx->priv;

  741.     enum AVPixelFormat lastpixfmt = AV_PIX_FMT_NONE;

  742.     int i;

  743. 

  744.     for(i=0; conversion_map[i].fmt; i++){

  745.         av_log(ctx, AV_LOG_DEBUG, "query: %X\n", conversion_map[i].fmt);

  746.         if(m->vf.query_format(&m->vf, conversion_map[i].fmt)){

  747.             av_log(ctx, AV_LOG_DEBUG, "supported,adding\n");

  748.             if (conversion_map[i].pix_fmt != lastpixfmt) {

  749.                 ff_add_format(&avfmts, conversion_map[i].pix_fmt);

  750.                 lastpixfmt = conversion_map[i].pix_fmt;

  751.             }

  752.         }

  753.     }

  754. 

  755.     if (!avfmts)

  756.         return -1;

  757. 

  758.     //We assume all allowed input formats are also allowed output formats

  759.     ff_set_common_formats(ctx, avfmts);

  760.     return 0;

  761. }

  762. 

  763. static int config_inprops(AVFilterLink *inlink)

  764. {

  765.     MPContext *m = inlink->dst->priv;

  766.     int i;

  767.     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);

  768. 

  769.     av_assert0(conversion_map[i].fmt && inlink->w && inlink->h);

  770. 

  771.     m->vf.fmt.have_configured = 1;

  772.     m->vf.fmt.orig_height     = inlink->h;

  773.     m->vf.fmt.orig_width      = inlink->w;

  774.     m->vf.fmt.orig_fmt        = conversion_map[i].fmt;

  775. 

  776.     if(m->vf.config(&m->vf, inlink->w, inlink->h, inlink->w, inlink->h, 0, conversion_map[i].fmt)<=0)

  777.         return -1;

  778. 

  779.     return 0;

  780. }

  781. 

  782. static int config_outprops(AVFilterLink *outlink)

  783. {

  784.     MPContext *m = outlink->src->priv;

  785. 

  786.     outlink->w = m->next_vf.w;

  787.     outlink->h = m->next_vf.h;

  788. 

  789.     return 0;

  790. }

  791. 

  792. static int request_frame(AVFilterLink *outlink)

  793. {

  794.     MPContext *m = outlink->src->priv;

  795.     int ret;

  796. 

  797.     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame\n");

  798. 

  799.     for(m->frame_returned=0; !m->frame_returned;){

  800.         ret=ff_request_frame(outlink->src->inputs[0]);

  801.         if(ret<0)

  802.             break;

  803.     }

  804. 

  805.     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame ret=%d\n", ret);

  806.     return ret;

  807. }

  808. 

  809. static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)

  810. {

  811.     MPContext *m = inlink->dst->priv;

  812.     int i;

  813.     double pts= MP_NOPTS_VALUE;

  814.     mp_image_t* mpi = ff_new_mp_image(inpic->width, inpic->height);

  815. 

  816.     if(inpic->pts != AV_NOPTS_VALUE)

  817.         pts= inpic->pts / av_q2d(inlink->time_base);

  818. 

  819.     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);

  820.     ff_mp_image_setfmt(mpi,conversion_map[i].fmt);

  821. 

  822.     memcpy(mpi->planes, inpic->data,     FFMIN(sizeof(inpic->data)    , sizeof(mpi->planes)));

  823.     memcpy(mpi->stride, inpic->linesize, FFMIN(sizeof(inpic->linesize), sizeof(mpi->stride)));

  824. 

  825.     //FIXME pass interleced & tff flags around

  826. 

  827.     // mpi->flags|=MP_IMGFLAG_ALLOCATED; ?

  828.     mpi->flags |= MP_IMGFLAG_READABLE;

  829.     if(!av_frame_is_writable(inpic))

  830.         mpi->flags |= MP_IMGFLAG_PRESERVE;

  831.     if(m->vf.put_image(&m->vf, mpi, pts) == 0){

  832.         av_log(m->avfctx, AV_LOG_DEBUG, "put_image() says skip\n");

  833.     }else{

  834.         av_frame_free(&inpic);

  835.     }

  836.     ff_free_mp_image(mpi);

  837.     return 0;

  838. }

  839. 

  840. static const AVFilterPad mp_inputs[] = {

  841.     {

  842.         .name         = "default",

  843.         .type         = AVMEDIA_TYPE_VIDEO,

  844.         .filter_frame = filter_frame,

  845.         .config_props = config_inprops,

  846.     },

  847.     { NULL }

  848. };

  849. 

  850. static const AVFilterPad mp_outputs[] = {

  851.     {

  852.         .name          = "default",

  853.         .type          = AVMEDIA_TYPE_VIDEO,

  854.         .request_frame = request_frame,

  855.         .config_props  = config_outprops,

  856.     },

  857.     { NULL }

  858. };

  859. 

  860. AVFilter avfilter_vf_mp = {

  861.     .name      = "mp",

  862.     .description = NULL_IF_CONFIG_SMALL("Apply a libmpcodecs filter to the input video."),

  863.     .init = init,

  864.     .uninit = uninit,

  865.     .priv_size = sizeof(MPContext),

  866.     .query_formats = query_formats,

  867.     .inputs        = mp_inputs,

  868.     .outputs       = mp_outputs,

  869.     .priv_class    = &mp_class,

  870. };