vf_uspp.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of MPlayer.
5  *
6  * MPlayer 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  * MPlayer 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 along
17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20 
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <inttypes.h>
25 #include <math.h>
26 #include <assert.h>
27 
28 #include "config.h"
29 
30 #include "mp_msg.h"
31 #include "cpudetect.h"
32 
33 #include "libavutil/mem.h"
34 #include "libavcodec/avcodec.h"
35 
36 #include "img_format.h"
37 #include "mp_image.h"
38 #include "vf.h"
39 #include "av_helpers.h"
40 #include "libvo/fastmemcpy.h"
41 
42 #define XMIN(a,b) ((a) < (b) ? (a) : (b))
43 
44 #define BLOCK 16
45 
46 //===========================================================================//
47 static const uint8_t __attribute__((aligned(8))) dither[8][8]={
48 { 0*4, 48*4, 12*4, 60*4, 3*4, 51*4, 15*4, 63*4, },
49 { 32*4, 16*4, 44*4, 28*4, 35*4, 19*4, 47*4, 31*4, },
50 { 8*4, 56*4, 4*4, 52*4, 11*4, 59*4, 7*4, 55*4, },
51 { 40*4, 24*4, 36*4, 20*4, 43*4, 27*4, 39*4, 23*4, },
52 { 2*4, 50*4, 14*4, 62*4, 1*4, 49*4, 13*4, 61*4, },
53 { 34*4, 18*4, 46*4, 30*4, 33*4, 17*4, 45*4, 29*4, },
54 { 10*4, 58*4, 6*4, 54*4, 9*4, 57*4, 5*4, 53*4, },
55 { 42*4, 26*4, 38*4, 22*4, 41*4, 25*4, 37*4, 21*4, },
56 };
57 
58 static const uint8_t offset[511][2]= {
59 { 0, 0},
60 { 0, 0}, { 8, 8},
61 { 0, 0}, { 4, 4}, {12, 8}, { 8,12},
62 { 0, 0}, {10, 2}, { 4, 4}, {14, 6}, { 8, 8}, { 2,10}, {12,12}, { 6,14},
63 
64 { 0, 0}, {10, 2}, { 4, 4}, {14, 6}, { 8, 8}, { 2,10}, {12,12}, { 6,14},
65 { 5, 1}, {15, 3}, { 9, 5}, { 3, 7}, {13, 9}, { 7,11}, { 1,13}, {11,15},
66 
67 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 5, 1}, {13, 1}, { 5, 9}, {13, 9},
68 { 2, 2}, {10, 2}, { 2,10}, {10,10}, { 7, 3}, {15, 3}, { 7,11}, {15,11},
69 { 4, 4}, {12, 4}, { 4,12}, {12,12}, { 1, 5}, { 9, 5}, { 1,13}, { 9,13},
70 { 6, 6}, {14, 6}, { 6,14}, {14,14}, { 3, 7}, {11, 7}, { 3,15}, {11,15},
71 
72 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 4, 0}, {12, 0}, { 4, 8}, {12, 8},
73 { 1, 1}, { 9, 1}, { 1, 9}, { 9, 9}, { 5, 1}, {13, 1}, { 5, 9}, {13, 9},
74 { 3, 2}, {11, 2}, { 3,10}, {11,10}, { 7, 2}, {15, 2}, { 7,10}, {15,10},
75 { 2, 3}, {10, 3}, { 2,11}, {10,11}, { 6, 3}, {14, 3}, { 6,11}, {14,11},
76 { 0, 4}, { 8, 4}, { 0,12}, { 8,12}, { 4, 4}, {12, 4}, { 4,12}, {12,12},
77 { 1, 5}, { 9, 5}, { 1,13}, { 9,13}, { 5, 5}, {13, 5}, { 5,13}, {13,13},
78 { 3, 6}, {11, 6}, { 3,14}, {11,14}, { 7, 6}, {15, 6}, { 7,14}, {15,14},
79 { 2, 7}, {10, 7}, { 2,15}, {10,15}, { 6, 7}, {14, 7}, { 6,15}, {14,15},
80 
81 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 0, 2}, { 8, 2}, { 0,10}, { 8,10},
82 { 0, 4}, { 8, 4}, { 0,12}, { 8,12}, { 0, 6}, { 8, 6}, { 0,14}, { 8,14},
83 { 1, 1}, { 9, 1}, { 1, 9}, { 9, 9}, { 1, 3}, { 9, 3}, { 1,11}, { 9,11},
84 { 1, 5}, { 9, 5}, { 1,13}, { 9,13}, { 1, 7}, { 9, 7}, { 1,15}, { 9,15},
85 { 2, 0}, {10, 0}, { 2, 8}, {10, 8}, { 2, 2}, {10, 2}, { 2,10}, {10,10},
86 { 2, 4}, {10, 4}, { 2,12}, {10,12}, { 2, 6}, {10, 6}, { 2,14}, {10,14},
87 { 3, 1}, {11, 1}, { 3, 9}, {11, 9}, { 3, 3}, {11, 3}, { 3,11}, {11,11},
88 { 3, 5}, {11, 5}, { 3,13}, {11,13}, { 3, 7}, {11, 7}, { 3,15}, {11,15},
89 { 4, 0}, {12, 0}, { 4, 8}, {12, 8}, { 4, 2}, {12, 2}, { 4,10}, {12,10},
90 { 4, 4}, {12, 4}, { 4,12}, {12,12}, { 4, 6}, {12, 6}, { 4,14}, {12,14},
91 { 5, 1}, {13, 1}, { 5, 9}, {13, 9}, { 5, 3}, {13, 3}, { 5,11}, {13,11},
92 { 5, 5}, {13, 5}, { 5,13}, {13,13}, { 5, 7}, {13, 7}, { 5,15}, {13,15},
93 { 6, 0}, {14, 0}, { 6, 8}, {14, 8}, { 6, 2}, {14, 2}, { 6,10}, {14,10},
94 { 6, 4}, {14, 4}, { 6,12}, {14,12}, { 6, 6}, {14, 6}, { 6,14}, {14,14},
95 { 7, 1}, {15, 1}, { 7, 9}, {15, 9}, { 7, 3}, {15, 3}, { 7,11}, {15,11},
96 { 7, 5}, {15, 5}, { 7,13}, {15,13}, { 7, 7}, {15, 7}, { 7,15}, {15,15},
97 
98 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 4, 4}, {12, 4}, { 4,12}, {12,12}, { 0, 4}, { 8, 4}, { 0,12}, { 8,12}, { 4, 0}, {12, 0}, { 4, 8}, {12, 8}, { 2, 2}, {10, 2}, { 2,10}, {10,10}, { 6, 6}, {14, 6}, { 6,14}, {14,14}, { 2, 6}, {10, 6}, { 2,14}, {10,14}, { 6, 2}, {14, 2}, { 6,10}, {14,10}, { 0, 2}, { 8, 2}, { 0,10}, { 8,10}, { 4, 6}, {12, 6}, { 4,14}, {12,14}, { 0, 6}, { 8, 6}, { 0,14}, { 8,14}, { 4, 2}, {12, 2}, { 4,10}, {12,10}, { 2, 0}, {10, 0}, { 2, 8}, {10, 8}, { 6, 4}, {14, 4}, { 6,12}, {14,12}, { 2, 4}, {10, 4}, { 2,12}, {10,12}, { 6, 0}, {14, 0}, { 6, 8}, {14, 8}, { 1, 1}, { 9, 1}, { 1, 9}, { 9, 9}, { 5, 5}, {13, 5}, { 5,13}, {13,13}, { 1, 5}, { 9, 5}, { 1,13}, { 9,13}, { 5, 1}, {13, 1}, { 5, 9}, {13, 9}, { 3, 3}, {11, 3}, { 3,11}, {11,11}, { 7, 7}, {15, 7}, { 7,15}, {15,15}, { 3, 7}, {11, 7}, { 3,15}, {11,15}, { 7, 3}, {15, 3}, { 7,11}, {15,11}, { 1, 3}, { 9, 3}, { 1,11}, { 9,11}, { 5, 7}, {13, 7}, { 5,15}, {13,15}, { 1, 7}, { 9, 7}, { 1,15}, { 9,15}, { 5, 3}, {13, 3}, { 5,11}, {13,11}, { 3, 1}, {11, 1}
99 , { 3, 9}, {11, 9}, { 7, 5}, {15, 5}, { 7,13}, {15,13}, { 3, 5}, {11, 5}, { 3,13}, {11,13}, { 7, 1}, {15, 1}, { 7, 9}, {15, 9}, { 0, 1}, { 8, 1}, { 0, 9}, { 8, 9}, { 4, 5}, {12, 5}, { 4,13}, {12,13}, { 0, 5}, { 8, 5}, { 0,13}, { 8,13}, { 4, 1}, {12, 1}, { 4, 9}, {12, 9}, { 2, 3}, {10, 3}, { 2,11}, {10,11}, { 6, 7}, {14, 7}, { 6,15}, {14,15}, { 2, 7}, {10, 7}, { 2,15}, {10,15}, { 6, 3}, {14, 3}, { 6,11}, {14,11}, { 0, 3}, { 8, 3}, { 0,11}, { 8,11}, { 4, 7}, {12, 7}, { 4,15}, {12,15}, { 0, 7}, { 8, 7}, { 0,15}, { 8,15}, { 4, 3}, {12, 3}, { 4,11}, {12,11}, { 2, 1}, {10, 1}, { 2, 9}, {10, 9}, { 6, 5}, {14, 5}, { 6,13}, {14,13}, { 2, 5}, {10, 5}, { 2,13}, {10,13}, { 6, 1}, {14, 1}, { 6, 9}, {14, 9}, { 1, 0}, { 9, 0}, { 1, 8}, { 9, 8}, { 5, 4}, {13, 4}, { 5,12}, {13,12}, { 1, 4}, { 9, 4}, { 1,12}, { 9,12}, { 5, 0}, {13, 0}, { 5, 8}, {13, 8}, { 3, 2}, {11, 2}, { 3,10}, {11,10}, { 7, 6}, {15, 6}, { 7,14}, {15,14}, { 3, 6}, {11, 6}, { 3,14}, {11,14}, { 7, 2}, {15, 2}, { 7,10}, {15,10}, { 1, 2}, { 9, 2}, { 1,10}, { 9,
100 10}, { 5, 6}, {13, 6}, { 5,14}, {13,14}, { 1, 6}, { 9, 6}, { 1,14}, { 9,14}, { 5, 2}, {13, 2}, { 5,10}, {13,10}, { 3, 0}, {11, 0}, { 3, 8}, {11, 8}, { 7, 4}, {15, 4}, { 7,12}, {15,12}, { 3, 4}, {11, 4}, { 3,12}, {11,12}, { 7, 0}, {15, 0}, { 7, 8}, {15, 8},
101 };
102 
103 struct vf_priv_s {
104  int log2_count;
105  int qp;
106  int mode;
107  int mpeg2;
108  int temp_stride[3];
109  uint8_t *src[3];
110  int16_t *temp[3];
111  int outbuf_size;
112  uint8_t *outbuf;
113  AVCodecContext *avctx_enc[BLOCK*BLOCK];
114  AVFrame *frame;
115  AVFrame *frame_dec;
116 };
117 
118 static void store_slice_c(uint8_t *dst, int16_t *src, int dst_stride, int src_stride, int width, int height, int log2_scale){
119  int y, x;
120 
121 #define STORE(pos) \
122  temp= ((src[x + y*src_stride + pos]<<log2_scale) + d[pos])>>8;\
123  if(temp & 0x100) temp= ~(temp>>31);\
124  dst[x + y*dst_stride + pos]= temp;
125 
126  for(y=0; y<height; y++){
127  const uint8_t *d= dither[y&7];
128  for(x=0; x<width; x+=8){
129  int temp;
130  STORE(0);
131  STORE(1);
132  STORE(2);
133  STORE(3);
134  STORE(4);
135  STORE(5);
136  STORE(6);
137  STORE(7);
138  }
139  }
140 }
141 
142 static void filter(struct vf_priv_s *p, uint8_t *dst[3], uint8_t *src[3], int dst_stride[3], int src_stride[3], int width, int height, uint8_t *qp_store, int qp_stride){
143  int x, y, i, j;
144  const int count= 1<<p->log2_count;
145 
146  for(i=0; i<3; i++){
147  int is_chroma= !!i;
148  int w= width >>is_chroma;
149  int h= height>>is_chroma;
150  int stride= p->temp_stride[i];
151  int block= BLOCK>>is_chroma;
152 
153  if (!src[i] || !dst[i])
154  continue; // HACK avoid crash for Y8 colourspace
155  for(y=0; y<h; y++){
156  int index= block + block*stride + y*stride;
157  fast_memcpy(p->src[i] + index, src[i] + y*src_stride[i], w);
158  for(x=0; x<block; x++){
159  p->src[i][index - x - 1]= p->src[i][index + x ];
160  p->src[i][index + w + x ]= p->src[i][index + w - x - 1];
161  }
162  }
163  for(y=0; y<block; y++){
164  fast_memcpy(p->src[i] + ( block-1-y)*stride, p->src[i] + ( y+block )*stride, stride);
165  fast_memcpy(p->src[i] + (h+block +y)*stride, p->src[i] + (h-y+block-1)*stride, stride);
166  }
167 
168  p->frame->linesize[i]= stride;
169  memset(p->temp[i], 0, (h+2*block)*stride*sizeof(int16_t));
170  }
171 
172  if(p->qp)
173  p->frame->quality= p->qp * FF_QP2LAMBDA;
174  else
175  p->frame->quality= norm_qscale(qp_store[0], p->mpeg2) * FF_QP2LAMBDA;
176 // init per MB qscale stuff FIXME
177 
178  for(i=0; i<count; i++){
179  const int x1= offset[i+count-1][0];
180  const int y1= offset[i+count-1][1];
181  int offset;
182  p->frame->data[0]= p->src[0] + x1 + y1 * p->frame->linesize[0];
183  p->frame->data[1]= p->src[1] + x1/2 + y1/2 * p->frame->linesize[1];
184  p->frame->data[2]= p->src[2] + x1/2 + y1/2 * p->frame->linesize[2];
185 
186  avcodec_encode_video(p->avctx_enc[i], p->outbuf, p->outbuf_size, p->frame);
187  p->frame_dec = p->avctx_enc[i]->coded_frame;
188 
189  offset= (BLOCK-x1) + (BLOCK-y1)*p->frame_dec->linesize[0];
190  //FIXME optimize
191  for(y=0; y<height; y++){
192  for(x=0; x<width; x++){
193  p->temp[0][ x + y*p->temp_stride[0] ] += p->frame_dec->data[0][ x + y*p->frame_dec->linesize[0] + offset ];
194  }
195  }
196  offset= (BLOCK/2-x1/2) + (BLOCK/2-y1/2)*p->frame_dec->linesize[1];
197  for(y=0; y<height/2; y++){
198  for(x=0; x<width/2; x++){
199  p->temp[1][ x + y*p->temp_stride[1] ] += p->frame_dec->data[1][ x + y*p->frame_dec->linesize[1] + offset ];
200  p->temp[2][ x + y*p->temp_stride[2] ] += p->frame_dec->data[2][ x + y*p->frame_dec->linesize[2] + offset ];
201  }
202  }
203  }
204 
205  for(j=0; j<3; j++){
206  int is_chroma= !!j;
207  if (!dst[j])
208  continue; // HACK avoid crash for Y8 colourspace
209  store_slice_c(dst[j], p->temp[j], dst_stride[j], p->temp_stride[j], width>>is_chroma, height>>is_chroma, 8-p->log2_count);
210  }
211 }
212 
213 static int config(struct vf_instance *vf,
214  int width, int height, int d_width, int d_height,
215  unsigned int flags, unsigned int outfmt){
216  int i;
217  AVCodec *enc= avcodec_find_encoder(AV_CODEC_ID_SNOW);
218 
219  for(i=0; i<3; i++){
220  int is_chroma= !!i;
221  int w= ((width + 4*BLOCK-1) & (~(2*BLOCK-1)))>>is_chroma;
222  int h= ((height + 4*BLOCK-1) & (~(2*BLOCK-1)))>>is_chroma;
223 
224  vf->priv->temp_stride[i]= w;
225  vf->priv->temp[i]= malloc(vf->priv->temp_stride[i]*h*sizeof(int16_t));
226  vf->priv->src [i]= malloc(vf->priv->temp_stride[i]*h*sizeof(uint8_t));
227  }
228  for(i=0; i< (1<<vf->priv->log2_count); i++){
229  AVCodecContext *avctx_enc;
230  AVDictionary *opts = NULL;
231 
232  avctx_enc=
233  vf->priv->avctx_enc[i]= avcodec_alloc_context3(NULL);
234  avctx_enc->width = width + BLOCK;
235  avctx_enc->height = height + BLOCK;
236  avctx_enc->time_base= (AVRational){1,25}; // meaningless
237  avctx_enc->gop_size = 300;
238  avctx_enc->max_b_frames= 0;
239  avctx_enc->pix_fmt = AV_PIX_FMT_YUV420P;
240  avctx_enc->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
241  avctx_enc->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
242  avctx_enc->global_quality= 123;
243  av_dict_set(&opts, "no_bitstream", "1", 0);
244  avcodec_open2(avctx_enc, enc, &opts);
245  av_dict_free(&opts);
246  assert(avctx_enc->codec);
247  }
248  vf->priv->frame= avcodec_alloc_frame();
249  vf->priv->frame_dec= avcodec_alloc_frame();
250 
251  vf->priv->outbuf_size= (width + BLOCK)*(height + BLOCK)*10;
252  vf->priv->outbuf= malloc(vf->priv->outbuf_size);
253 
254  return ff_vf_next_config(vf,width,height,d_width,d_height,flags,outfmt);
255 }
256 
257 static void get_image(struct vf_instance *vf, mp_image_t *mpi){
258  if(mpi->flags&MP_IMGFLAG_PRESERVE) return; // don't change
259  // ok, we can do pp in-place (or pp disabled):
260  vf->dmpi=ff_vf_get_image(vf->next,mpi->imgfmt,
261  mpi->type, mpi->flags | MP_IMGFLAG_READABLE, mpi->width, mpi->height);
262  mpi->planes[0]=vf->dmpi->planes[0];
263  mpi->stride[0]=vf->dmpi->stride[0];
264  mpi->width=vf->dmpi->width;
265  if(mpi->flags&MP_IMGFLAG_PLANAR){
266  mpi->planes[1]=vf->dmpi->planes[1];
267  mpi->planes[2]=vf->dmpi->planes[2];
268  mpi->stride[1]=vf->dmpi->stride[1];
269  mpi->stride[2]=vf->dmpi->stride[2];
270  }
271  mpi->flags|=MP_IMGFLAG_DIRECT;
272 }
273 
274 static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){
275  mp_image_t *dmpi;
276 
277  if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
278  // no DR, so get a new image! hope we'll get DR buffer:
279  dmpi=ff_vf_get_image(vf->next,mpi->imgfmt,
280  MP_IMGTYPE_TEMP,
281  MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_PREFER_ALIGNED_STRIDE,
282  mpi->width,mpi->height);
283  ff_vf_clone_mpi_attributes(dmpi, mpi);
284  }else{
285  dmpi=vf->dmpi;
286  }
287 
288  vf->priv->mpeg2= mpi->qscale_type;
289  if(vf->priv->log2_count || !(mpi->flags&MP_IMGFLAG_DIRECT)){
290  if(mpi->qscale || vf->priv->qp){
291  filter(vf->priv, dmpi->planes, mpi->planes, dmpi->stride, mpi->stride, mpi->w, mpi->h, mpi->qscale, mpi->qstride);
292  }else{
293  memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h, dmpi->stride[0], mpi->stride[0]);
294  memcpy_pic(dmpi->planes[1], mpi->planes[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, dmpi->stride[1], mpi->stride[1]);
295  memcpy_pic(dmpi->planes[2], mpi->planes[2], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, dmpi->stride[2], mpi->stride[2]);
296  }
297  }
298 
299 #if HAVE_MMX
300  if(ff_gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t");
301 #endif
302 #if HAVE_MMX2
303  if(ff_gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t");
304 #endif
305 
306  return ff_vf_next_put_image(vf,dmpi, pts);
307 }
308 
309 static void uninit(struct vf_instance *vf){
310  int i;
311  if(!vf->priv) return;
312 
313  for(i=0; i<3; i++){
314  free(vf->priv->temp[i]);
315  vf->priv->temp[i]= NULL;
316  free(vf->priv->src[i]);
317  vf->priv->src[i]= NULL;
318  }
319  for(i=0; i<BLOCK*BLOCK; i++){
320  av_freep(&vf->priv->avctx_enc[i]);
321  }
322 
323  free(vf->priv);
324  vf->priv=NULL;
325 }
326 
327 //===========================================================================//
328 static int query_format(struct vf_instance *vf, unsigned int fmt){
329  switch(fmt){
330  case IMGFMT_YV12:
331  case IMGFMT_I420:
332  case IMGFMT_IYUV:
333  case IMGFMT_Y800:
334  case IMGFMT_Y8:
335  return ff_vf_next_query_format(vf,fmt);
336  }
337  return 0;
338 }
339 
340 static int control(struct vf_instance *vf, int request, void* data){
341  switch(request){
342  case VFCTRL_QUERY_MAX_PP_LEVEL:
343  return 8;
344  case VFCTRL_SET_PP_LEVEL:
345  vf->priv->log2_count= *((unsigned int*)data);
346  //FIXME we have to realloc a few things here
347  return CONTROL_TRUE;
348  }
349  return ff_vf_next_control(vf,request,data);
350 }
351 
352 static int vf_open(vf_instance_t *vf, char *args){
353 
354  int log2c=-1;
355 
356  vf->config=config;
357  vf->put_image=put_image;
358  vf->get_image=get_image;
359  vf->query_format=query_format;
360  vf->uninit=uninit;
361  vf->control= control;
362  vf->priv=malloc(sizeof(struct vf_priv_s));
363  memset(vf->priv, 0, sizeof(struct vf_priv_s));
364 
365  ff_init_avcodec();
366 
367  vf->priv->log2_count= 4;
368 
369  if (args) sscanf(args, "%d:%d:%d", &log2c, &vf->priv->qp, &vf->priv->mode);
370 
371  if( log2c >=0 && log2c <=8 )
372  vf->priv->log2_count = log2c;
373 
374  if(vf->priv->qp < 0)
375  vf->priv->qp = 0;
376 
377 // #if HAVE_MMX
378 // if(ff_gCpuCaps.hasMMX){
379 // store_slice= store_slice_mmx;
380 // }
381 // #endif
382 
383  return 1;
384 }
385 
386 const vf_info_t ff_vf_info_uspp = {
387  "ultra simple/slow postprocess",
388  "uspp",
389  "Michael Niedermayer",
390  "",
391  vf_open,
392  NULL
393 };
BLOCK
#define BLOCK
Definition: vf_uspp.c:44
AVCodecContext::codec
const struct AVCodec * codec
Definition: libavcodec/avcodec.h:1143
mp_image::imgfmt
unsigned int imgfmt
Definition: mp_image.h:130
config
static int config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt)
Definition: vf_uspp.c:213
img_format.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
vf_instance::get_image
void(* get_image)(struct vf_instance *vf, mp_image_t *mpi)
Definition: vf.h:66
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: libavcodec/utils.c:2378
mp_image::qscale_type
int qscale_type
Definition: mp_image.h:139
mp_image::qscale
char * qscale
Definition: mp_image.h:135
fmt
const char * fmt
Definition: avisynth_c.h:669
query_format
static int query_format(struct vf_instance *vf, unsigned int fmt)
Definition: vf_uspp.c:328
VFCTRL_SET_PP_LEVEL
#define VFCTRL_SET_PP_LEVEL
Definition: vf.h:99
mem.h
memory handling functions
vf_priv_s::stride
int stride
Definition: vf_ow.c:59
vf_instance::control
int(* control)(struct vf_instance *vf, int request, void *data)
Definition: vf.h:62
AVCodecContext::coded_frame
AVFrame * coded_frame
the picture in the bitstream
Definition: libavcodec/avcodec.h:2567
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: libavcodec/avcodec.h:1385
y1
y1
Definition: lab5.m:33
ff_vf_get_image
mp_image_t * ff_vf_get_image(vf_instance_t *vf, unsigned int outfmt, int mp_imgtype, int mp_imgflag, int w, int h)
Definition: vf_mp.c:380
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: libavcodec/avcodec.h:1330
ff_vf_info_uspp
const vf_info_t ff_vf_info_uspp
Definition: vf_uspp.c:386
AVS_Value
Definition: avisynth_c.h:503
x1
x1
Definition: genspecsines3.m:7
MP_IMGFLAG_PRESERVE
#define MP_IMGFLAG_PRESERVE
Definition: mp_image.h:46
vf_priv_s::temp_stride
int temp_stride
Definition: vf_fspp.c:94
IMGFMT_YV12
#define IMGFMT_YV12
Definition: img_format.h:119
CONTROL_TRUE
#define CONTROL_TRUE
Definition: mpc_info.h:37
vf_instance::uninit
void(* uninit)(struct vf_instance *vf)
Definition: vf.h:74
MP_IMGFLAG_READABLE
#define MP_IMGFLAG_READABLE
Definition: mp_image.h:55
IMGFMT_Y8
#define IMGFMT_Y8
Definition: img_format.h:124
vf_priv_s::frame
AVFrame * frame
Definition: vf_mcdeint.c:90
store_slice_c
static void store_slice_c(uint8_t *dst, int16_t *src, int dst_stride, int src_stride, int width, int height, int log2_scale)
Definition: vf_uspp.c:118
w
output residual component w
Definition: code Kat/hpsmodel.m:23
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: libavcodec/avcodec.h:1253
av_freep
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
ff_vf_next_config
int ff_vf_next_config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt)
Definition: vf_mp.c:584
d
set threshold d
Definition: extra/f0detectionyin.m:6
av_helpers.h
mp_image::width
int width
Definition: mp_image.h:131
vf_instance::put_image
int(* put_image)(struct vf_instance *vf, mp_image_t *mpi, double pts)
Definition: vf.h:68
uint8_t
uint8_t
Definition: audio_convert.c:194
vf_priv_s::mpeg2
int mpeg2
Definition: vf_fspp.c:96
vf_priv_s::outbuf_size
int outbuf_size
Definition: vf_mcdeint.c:87
offset
static const uint8_t offset[511][2]
Definition: vf_uspp.c:58
vf_info_s
Definition: vf.h:31
mp_image::planes
unsigned char * planes[MP_MAX_PLANES]
Definition: mp_image.h:133
mp_image::stride
int stride[MP_MAX_PLANES]
Definition: mp_image.h:134
vf_priv_s::width
int width
Definition: vf_fil.c:32
mp_image.h
mp_image::qstride
int qstride
Definition: mp_image.h:136
vf_priv_s::mode
int mode
Definition: vf_ilpack.c:38
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
cpucaps_s::hasMMX2
int hasMMX2
Definition: cpudetect.h:34
vf_priv_s::temp
int16_t * temp
Definition: vf_fspp.c:99
MP_IMGTYPE_TEMP
#define MP_IMGTYPE_TEMP
Definition: mp_image.h:104
vf_instance::query_format
int(* query_format)(struct vf_instance *vf, unsigned int fmt)
Definition: vf.h:64
vf_priv_s::qp_stride
int qp_stride
Definition: vf_qp.c:43
vf_priv_s::qp
int qp
Definition: vf_fspp.c:95
data
Spectrum Plot time data
Definition: FFT of a Simple Sinusoid.m:14
ff_vf_next_control
int ff_vf_next_control(struct vf_instance *vf, int request, void *data)
Definition: vf_mp.c:613
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:162
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: libavcodec/avcodec.h:1222
IMGFMT_IYUV
#define IMGFMT_IYUV
Definition: img_format.h:121
CODEC_FLAG_QSCALE
#define CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: libavcodec/avcodec.h:693
get_image
static void get_image(struct vf_instance *vf, mp_image_t *mpi)
Definition: vf_uspp.c:257
avcodec.h
external API header
CODEC_FLAG_LOW_DELAY
#define CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: libavcodec/avcodec.h:713
vf_priv_s::src
uint8_t * src
Definition: vf_fspp.c:98
put_image
static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
Definition: vf_uspp.c:274
vf_priv_s::outbuf
uint8_t * outbuf
Definition: vf_mcdeint.c:88
avcodec_alloc_frame
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
Definition: libavcodec/utils.c:951
vf_priv_s
Definition: vf_dint.c:31
AVRational
struct AVRational AVRational
rational number numerator/denominator
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: libavcodec/avcodec.h:2409
MP_IMGFLAG_PREFER_ALIGNED_STRIDE
#define MP_IMGFLAG_PREFER_ALIGNED_STRIDE
Definition: mp_image.h:61
mp_msg.h
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: libavcodec/options.c:148
AVCodecContext::width
int width
picture width / height.
Definition: libavcodec/avcodec.h:1302
vf_priv_s::frame_dec
AVFrame * frame_dec
Definition: vf_mcdeint.c:91
uninit
static void uninit(struct vf_instance *vf)
Definition: vf_uspp.c:309
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:185
ff_init_avcodec
void ff_init_avcodec(void)
Definition: vf_mp.c:287
STORE
#define STORE(pos)
__attribute__
static const uint8_t __attribute__((aligned(8)))
Definition: vf_uspp.c:47
mp_image::chroma_y_shift
int chroma_y_shift
Definition: mp_image.h:145
cpucaps_s::hasMMX
int hasMMX
Definition: cpudetect.h:33
ff_vf_clone_mpi_attributes
void ff_vf_clone_mpi_attributes(mp_image_t *dst, mp_image_t *src)
Definition: vf_mp.c:293
VFCTRL_QUERY_MAX_PP_LEVEL
#define VFCTRL_QUERY_MAX_PP_LEVEL
Definition: vf.h:98
vf_instance::next
struct vf_instance * next
Definition: vf.h:84
avcodec_encode_video
int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVFrame *pict)
Definition: libavcodec/utils.c:1678
NULL
NULL
Definition: eval.c:55
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
AV_CODEC_ID_SNOW
Definition: libavcodec/avcodec.h:294
memcpy_pic
#define memcpy_pic(d, s, b, h, ds, ss)
Definition: fastmemcpy.h:62
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:62
index
int index
Definition: gxfenc.c:89
control
static int control(struct vf_instance *vf, int request, void *data)
Definition: vf_uspp.c:340
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
IMGFMT_Y800
#define IMGFMT_Y800
Definition: img_format.h:123
vf_priv_s::dmpi
mp_image_t * dmpi
Definition: libmpcodecs/vf_tinterlace.c:37
mp_image::w
int w
Definition: mp_image.h:132
avcodec_open2
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: libavcodec/utils.c:1034
vf_instance::config
int(* config)(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt)
Definition: vf.h:59
filter
static void filter(struct vf_priv_s *p, uint8_t *dst[3], uint8_t *src[3], int dst_stride[3], int src_stride[3], int width, int height, uint8_t *qp_store, int qp_stride)
Definition: vf_uspp.c:142
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: libavcodec/avcodec.h:1208
flags
static int flags
Definition: cpu.c:23
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
mp_image::height
int height
Definition: mp_image.h:131
mp_image::type
unsigned char type
Definition: mp_image.h:127
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: libavcodec/avcodec.h:1321
vf_priv_s::avctx_enc
AVCodecContext * avctx_enc
Definition: vf_mcdeint.c:89
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:68
MP_IMGFLAG_PLANAR
#define MP_IMGFLAG_PLANAR
Definition: mp_image.h:76
fast_memcpy
void * fast_memcpy(void *to, const void *from, size_t len)
vf_open
static int vf_open(vf_instance_t *vf, char *args)
Definition: vf_uspp.c:352
y
function y
Definition: D.m:1
ff_vf_next_put_image
int ff_vf_next_put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
Definition: vf_mp.c:539
vf_priv_s::log2_count
int log2_count
Definition: vf_fspp.c:93
dst
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
mp_image::chroma_x_shift
int chroma_x_shift
Definition: mp_image.h:144
ff_gCpuCaps
CpuCaps ff_gCpuCaps
Definition: vf_mp.c:193
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:169
MP_IMGFLAG_ACCEPT_STRIDE
#define MP_IMGFLAG_ACCEPT_STRIDE
Definition: mp_image.h:63
vf_instance::priv
struct vf_priv_s * priv
Definition: vf.h:86
count
void INT64 INT64 count
Definition: avisynth_c.h:594
MP_IMGFLAG_DIRECT
#define MP_IMGFLAG_DIRECT
Definition: mp_image.h:91
norm_qscale
static int norm_qscale(int qscale, int type)
Definition: vf.h:154
IMGFMT_I420
#define IMGFMT_I420
Definition: img_format.h:120
mp_image::h
int h
Definition: mp_image.h:132
mp_image
Definition: mp_image.h:125
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: libavcodec/avcodec.h:2404
ff_vf_next_query_format
int ff_vf_next_query_format(struct vf_instance *vf, unsigned int fmt)
Definition: vf_mp.c:371
vf_instance
Definition: vf.h:56
mp_image::flags
unsigned int flags
Definition: mp_image.h:126
vf_priv_s::height
int height
Definition: vf_fil.c:31
vf_instance::dmpi
mp_image_t * dmpi
Definition: vf.h:85
free
MUSIC TECHNOLOGY GROUP UNIVERSITAT POMPEU FABRA Free Non Commercial Binary License Agreement UNIVERSITAT POMPEU OR INDICATING ACCEPTANCE BY SELECTING THE ACCEPT BUTTON ON ANY DOWNLOAD OR INSTALL YOU ACCEPT THE TERMS OF THE LICENSE SUMMARY TABLE Software MELODIA Melody Extraction vamp plug in Licensor Music Technology Group Universitat Pompeu Plaça de la Spain Permitted purposes Non commercial internal research and validation and educational purposes only All commercial uses in a production either internal or are prohibited by this license and require an additional commercial exploitation license TERMS AND CONDITIONS SOFTWARE Software means the software programs identified herein in binary any other machine readable any updates or error corrections provided by and any user programming guides and other documentation provided to you by UPF under this Agreement LICENSE Subject to the terms and conditions of this UPF grants you a royalty free
Definition: MELODIA - License.txt:16
Generated on Fri Dec 20 2024 06:56:09 for FFmpeg by   doxygen 1.8.11