Mercurial > mplayer.hg

comparison libmpcodecs/vf_uspp.c @ 16946:47c5e9846cd3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ultra simple&slow pp filter, yes yet another spp like filter :) this one does actually compress&decompress the video at various shifts with lavc while the other spp filters are doing optimized intra only filtering limitations: mpeg4 is hardcoded, all options too, pretty trivial to change though, even filtering with non dct codecs like snow could be tried ... the qscale/qp is only taken fron the first MB of each image and then used for the whole image (would needs some small changes to lavc to let the user set the qscales for the mbs themselfs but iam to lazy ...) this needs ALOT of cpu time and memory especially at uspp=8 ...
author michael
date Tue, 08 Nov 2005 13:15:19 +0000
parents
children 6ff3379a0862
comparison
equal deleted inserted replaced
16945:c17943eb7d55 16946:47c5e9846cd3
1 /*
2 Copyright (C) 2005 Michael Niedermayer <michaelni@gmx.at>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <inttypes.h>
23 #include <math.h>
24
25 #include "../config.h"
26
27 #ifdef USE_LIBAVCODEC
28
29 #include "../mp_msg.h"
30 #include "../cpudetect.h"
31
32 #ifdef USE_LIBAVCODEC_SO
33 #include <ffmpeg/avcodec.h>
34 #include <ffmpeg/dsputil.h>
35 #else
36 #include "../libavcodec/avcodec.h"
37 #include "../libavcodec/dsputil.h"
38 #endif
39
40 #ifdef HAVE_MALLOC_H
41 #include <malloc.h>
42 #endif
43
44 #include "img_format.h"
45 #include "mp_image.h"
46 #include "vf.h"
47 #include "../libvo/fastmemcpy.h"
48
49 #define XMIN(a,b) ((a) < (b) ? (a) : (b))
50
51 #define BLOCK 16
52
53 //===========================================================================//
54 static const uint8_t __attribute__((aligned(8))) dither[8][8]={
55 { 0*4, 48*4, 12*4, 60*4, 3*4, 51*4, 15*4, 63*4, },
56 { 32*4, 16*4, 44*4, 28*4, 35*4, 19*4, 47*4, 31*4, },
57 { 8*4, 56*4, 4*4, 52*4, 11*4, 59*4, 7*4, 55*4, },
58 { 40*4, 24*4, 36*4, 20*4, 43*4, 27*4, 39*4, 23*4, },
59 { 2*4, 50*4, 14*4, 62*4, 1*4, 49*4, 13*4, 61*4, },
60 { 34*4, 18*4, 46*4, 30*4, 33*4, 17*4, 45*4, 29*4, },
61 { 10*4, 58*4, 6*4, 54*4, 9*4, 57*4, 5*4, 53*4, },
62 { 42*4, 26*4, 38*4, 22*4, 41*4, 25*4, 37*4, 21*4, },
63 };
64
65 static const uint8_t offset[511][2]= {
66 { 0, 0},
67 { 0, 0}, { 8, 8},
68 { 0, 0}, { 4, 4}, {12, 8}, { 8,12},
69 { 0, 0}, {10, 2}, { 4, 4}, {14, 6}, { 8, 8}, { 2,10}, {12,12}, { 6,14},
70
71 { 0, 0}, {10, 2}, { 4, 4}, {14, 6}, { 8, 8}, { 2,10}, {12,12}, { 6,14},
72 { 5, 1}, {15, 3}, { 9, 5}, { 3, 7}, {13, 9}, { 7,11}, { 1,13}, {11,15},
73
74 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 5, 1}, {13, 1}, { 5, 9}, {13, 9},
75 { 2, 2}, {10, 2}, { 2,10}, {10,10}, { 7, 3}, {15, 3}, { 7,11}, {15,11},
76 { 4, 4}, {12, 4}, { 4,12}, {12,12}, { 1, 5}, { 9, 5}, { 1,13}, { 9,13},
77 { 6, 6}, {14, 6}, { 6,14}, {14,14}, { 3, 7}, {11, 7}, { 3,15}, {11,15},
78
79 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 4, 0}, {12, 0}, { 4, 8}, {12, 8},
80 { 1, 1}, { 9, 1}, { 1, 9}, { 9, 9}, { 5, 1}, {13, 1}, { 5, 9}, {13, 9},
81 { 3, 2}, {11, 2}, { 3,10}, {11,10}, { 7, 2}, {15, 2}, { 7,10}, {15,10},
82 { 2, 3}, {10, 3}, { 2,11}, {10,11}, { 6, 3}, {14, 3}, { 6,11}, {14,11},
83 { 0, 4}, { 8, 4}, { 0,12}, { 8,12}, { 4, 4}, {12, 4}, { 4,12}, {12,12},
84 { 1, 5}, { 9, 5}, { 1,13}, { 9,13}, { 5, 5}, {13, 5}, { 5,13}, {13,13},
85 { 3, 6}, {11, 6}, { 3,14}, {11,14}, { 7, 6}, {15, 6}, { 7,14}, {15,14},
86 { 2, 7}, {10, 7}, { 2,15}, {10,15}, { 6, 7}, {14, 7}, { 6,15}, {14,15},
87
88 { 0, 0}, { 8, 0}, { 0, 8}, { 8, 8}, { 0, 2}, { 8, 2}, { 0,10}, { 8,10},
89 { 0, 4}, { 8, 4}, { 0,12}, { 8,12}, { 0, 6}, { 8, 6}, { 0,14}, { 8,14},
90 { 1, 1}, { 9, 1}, { 1, 9}, { 9, 9}, { 1, 3}, { 9, 3}, { 1,11}, { 9,11},
91 { 1, 5}, { 9, 5}, { 1,13}, { 9,13}, { 1, 7}, { 9, 7}, { 1,15}, { 9,15},
92 { 2, 0}, {10, 0}, { 2, 8}, {10, 8}, { 2, 2}, {10, 2}, { 2,10}, {10,10},
93 { 2, 4}, {10, 4}, { 2,12}, {10,12}, { 2, 6}, {10, 6}, { 2,14}, {10,14},
94 { 3, 1}, {11, 1}, { 3, 9}, {11, 9}, { 3, 3}, {11, 3}, { 3,11}, {11,11},
95 { 3, 5}, {11, 5}, { 3,13}, {11,13}, { 3, 7}, {11, 7}, { 3,15}, {11,15},
96 { 4, 0}, {12, 0}, { 4, 8}, {12, 8}, { 4, 2}, {12, 2}, { 4,10}, {12,10},
97 { 4, 4}, {12, 4}, { 4,12}, {12,12}, { 4, 6}, {12, 6}, { 4,14}, {12,14},
98 { 5, 1}, {13, 1}, { 5, 9}, {13, 9}, { 5, 3}, {13, 3}, { 5,11}, {13,11},
99 { 5, 5}, {13, 5}, { 5,13}, {13,13}, { 5, 7}, {13, 7}, { 5,15}, {13,15},
100 { 6, 0}, {14, 0}, { 6, 8}, {14, 8}, { 6, 2}, {14, 2}, { 6,10}, {14,10},
101 { 6, 4}, {14, 4}, { 6,12}, {14,12}, { 6, 6}, {14, 6}, { 6,14}, {14,14},
102 { 7, 1}, {15, 1}, { 7, 9}, {15, 9}, { 7, 3}, {15, 3}, { 7,11}, {15,11},
103 { 7, 5}, {15, 5}, { 7,13}, {15,13}, { 7, 7}, {15, 7}, { 7,15}, {15,15},
104
105 { 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}, { 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,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},
106 };
107
108 struct vf_priv_s {
109 int log2_count;
110 int qp;
111 int mode;
112 int mpeg2;
113 int temp_stride[3];
114 uint8_t *src[3];
115 int16_t *temp[3];
116 int outbuf_size;
117 uint8_t *outbuf;
118 AVCodecContext *avctx_enc[BLOCK*BLOCK];
119 AVCodecContext *avctx_dec[BLOCK*BLOCK];
120 AVFrame *frame;
121 AVFrame *frame_dec;
122 };
123
124 static void store_slice_c(uint8_t *dst, int16_t *src, int dst_stride, int src_stride, int width, int height, int log2_scale){
125 int y, x;
126
127 #define STORE(pos) \
128 temp= ((src[x + y*src_stride + pos]<<log2_scale) + d[pos])>>8;\
129 if(temp & 0x100) temp= ~(temp>>31);\
130 dst[x + y*dst_stride + pos]= temp;
131
132 for(y=0; y<height; y++){
133 const uint8_t *d= dither[y&7];
134 for(x=0; x<width; x+=8){
135 int temp;
136 STORE(0);
137 STORE(1);
138 STORE(2);
139 STORE(3);
140 STORE(4);
141 STORE(5);
142 STORE(6);
143 STORE(7);
144 }
145 }
146 }
147
148 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){
149 int x, y, i, j;
150 const int count= 1<<p->log2_count;
151
152 for(i=0; i<3; i++){
153 int is_chroma= !!i;
154 int w= width >>is_chroma;
155 int h= height>>is_chroma;
156 int stride= p->temp_stride[i];
157
158 if (!src[i] || !dst[i])
159 continue; // HACK avoid crash for Y8 colourspace
160 for(y=0; y<h; y++){
161 int index= BLOCK + BLOCK*stride + y*stride;
162 memcpy(p->src[i] + index, src[i] + y*src_stride[i], w);
163 for(x=0; x<BLOCK; x++){
164 p->src[i][index - x - 1]= p->src[i][index + x ];
165 p->src[i][index + w + x ]= p->src[i][index + w - x - 1];
166 }
167 }
168 for(y=0; y<BLOCK; y++){
169 memcpy(p->src[i] + ( BLOCK-1-y)*stride, p->src[i] + ( y+BLOCK )*stride, stride);
170 memcpy(p->src[i] + (h+BLOCK +y)*stride, p->src[i] + (h-y+BLOCK-1)*stride, stride);
171 }
172
173 p->frame->linesize[i]= stride;
174 memset(p->temp[i], 0, (h+2*BLOCK)*stride*sizeof(int16_t));
175 }
176
177 if(p->qp)
178 p->frame->quality= p->qp * FF_QP2LAMBDA;
179 else
180 p->frame->quality= (qp_store[0] * FF_QP2LAMBDA)>>p->mpeg2;
181 // init per MB qscale stuff FIXME
182
183 for(i=0; i<count; i++){
184 const int x1= offset[i+count-1][0];
185 const int y1= offset[i+count-1][1];
186 int offset, out_size, got_picture;
187 p->frame->data[0]= p->src[0] + x1 + y1 * p->frame->linesize[0];
188 p->frame->data[1]= p->src[1] + x1/2 + y1/2 * p->frame->linesize[1];
189 p->frame->data[2]= p->src[2] + x1/2 + y1/2 * p->frame->linesize[2];
190
191 out_size = avcodec_encode_video(p->avctx_enc[i], p->outbuf, p->outbuf_size, p->frame);
192 avcodec_decode_video(p->avctx_dec[i], p->frame_dec, &got_picture, p->outbuf, out_size);
193
194 offset= (BLOCK-x1) + (BLOCK-y1)*p->frame_dec->linesize[0];
195 //FIXME optimize
196 for(y=0; y<height; y++){
197 for(x=0; x<width; x++){
198 p->temp[0][ x + y*p->temp_stride[0] ] += p->frame_dec->data[0][ x + y*p->frame_dec->linesize[0] + offset ];
199 }
200 }
201 offset= (BLOCK-x1/2) + (BLOCK-y1/2)*p->frame_dec->linesize[1];
202 for(y=0; y<height/2; y++){
203 for(x=0; x<width/2; x++){
204 p->temp[1][ x + y*p->temp_stride[1] ] += p->frame_dec->data[1][ x + y*p->frame_dec->linesize[1] + offset ];
205 p->temp[2][ x + y*p->temp_stride[2] ] += p->frame_dec->data[2][ x + y*p->frame_dec->linesize[2] + offset ];
206 }
207 }
208 }
209
210 for(j=0; j<3; j++){
211 int is_chroma= !!j;
212 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);
213 }
214 }
215
216 static int config(struct vf_instance_s* vf,
217 int width, int height, int d_width, int d_height,
218 unsigned int flags, unsigned int outfmt){
219 int i;
220 AVCodec *dec= avcodec_find_decoder(CODEC_ID_MPEG4);
221 AVCodec *enc= avcodec_find_encoder(CODEC_ID_MPEG4);
222
223 for(i=0; i<3; i++){
224 int is_chroma= !!i;
225 int w= ((width >>is_chroma) + 4*BLOCK-1) & (~(2*BLOCK-1));
226 int h= ((height>>is_chroma) + 4*BLOCK-1) & (~(2*BLOCK-1));
227
228 vf->priv->temp_stride[i]= w;
229 vf->priv->temp[i]= malloc(vf->priv->temp_stride[i]*h*sizeof(int16_t));
230 vf->priv->src [i]= malloc(vf->priv->temp_stride[i]*h*sizeof(uint8_t));
231 }
232 for(i=0; i< (1<<vf->priv->log2_count); i++){
233 AVCodecContext *avctx_enc;
234
235 avctx_enc=
236 vf->priv->avctx_enc[i]= avcodec_alloc_context();
237 vf->priv->avctx_dec[i]= avcodec_alloc_context();
238 avctx_enc->width = width + BLOCK;
239 avctx_enc->height = height + BLOCK;
240 avctx_enc->time_base= (AVRational){1,25}; // meaningless
241 avctx_enc->gop_size = 300;
242 avctx_enc->max_b_frames= 0;
243 avctx_enc->pix_fmt = PIX_FMT_YUV420P;
244 avctx_enc->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
245 avcodec_open(avctx_enc, enc);
246 avcodec_open(vf->priv->avctx_dec[i], dec);
247
248 }
249 vf->priv->frame= avcodec_alloc_frame();
250 vf->priv->frame_dec= avcodec_alloc_frame();
251
252 vf->priv->outbuf_size= (width + BLOCK)*(height + BLOCK)*10;
253 vf->priv->outbuf= malloc(vf->priv->outbuf_size);
254
255 return vf_next_config(vf,width,height,d_width,d_height,flags,outfmt);
256 }
257
258 static void get_image(struct vf_instance_s* vf, mp_image_t *mpi){
259 if(mpi->flags&MP_IMGFLAG_PRESERVE) return; // don't change
260 // ok, we can do pp in-place (or pp disabled):
261 vf->dmpi=vf_get_image(vf->next,mpi->imgfmt,
262 mpi->type, mpi->flags | MP_IMGFLAG_READABLE, mpi->width, mpi->height);
263 mpi->planes[0]=vf->dmpi->planes[0];
264 mpi->stride[0]=vf->dmpi->stride[0];
265 mpi->width=vf->dmpi->width;
266 if(mpi->flags&MP_IMGFLAG_PLANAR){
267 mpi->planes[1]=vf->dmpi->planes[1];
268 mpi->planes[2]=vf->dmpi->planes[2];
269 mpi->stride[1]=vf->dmpi->stride[1];
270 mpi->stride[2]=vf->dmpi->stride[2];
271 }
272 mpi->flags|=MP_IMGFLAG_DIRECT;
273 }
274
275 static int put_image(struct vf_instance_s* vf, mp_image_t *mpi){
276 mp_image_t *dmpi;
277
278 if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
279 // no DR, so get a new image! hope we'll get DR buffer:
280 dmpi=vf_get_image(vf->next,mpi->imgfmt,
281 MP_IMGTYPE_TEMP,
282 MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_PREFER_ALIGNED_STRIDE,
283 mpi->width,mpi->height);
284 vf_clone_mpi_attributes(dmpi, mpi);
285 }else{
286 dmpi=vf->dmpi;
287 }
288
289 vf->priv->mpeg2= mpi->qscale_type;
290 if(vf->priv->log2_count || !(mpi->flags&MP_IMGFLAG_DIRECT)){
291 if(mpi->qscale || vf->priv->qp){
292 filter(vf->priv, dmpi->planes, mpi->planes, dmpi->stride, mpi->stride, mpi->w, mpi->h, mpi->qscale, mpi->qstride);
293 }else{
294 memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h, dmpi->stride[0], mpi->stride[0]);
295 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]);
296 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]);
297 }
298 }
299
300 #ifdef HAVE_MMX
301 if(gCpuCaps.hasMMX) asm volatile ("emms\n\t");
302 #endif
303 #ifdef HAVE_MMX2
304 if(gCpuCaps.hasMMX2) asm volatile ("sfence\n\t");
305 #endif
306
307 return vf_next_put_image(vf,dmpi);
308 }
309
310 static void uninit(struct vf_instance_s* vf){
311 int i;
312 if(!vf->priv) return;
313
314 for(i=0; i<3; i++){
315 if(vf->priv->temp[i]) free(vf->priv->temp[i]);
316 vf->priv->temp[i]= NULL;
317 if(vf->priv->src[i]) free(vf->priv->src[i]);
318 vf->priv->src[i]= NULL;
319 }
320 for(i=0; i<BLOCK*BLOCK; i++){
321 av_freep(&vf->priv->avctx_enc[i]);
322 av_freep(&vf->priv->avctx_dec[i]);
323 }
324
325 free(vf->priv);
326 vf->priv=NULL;
327 }
328
329 //===========================================================================//
330 static int query_format(struct vf_instance_s* vf, unsigned int fmt){
331 switch(fmt){
332 case IMGFMT_YV12:
333 case IMGFMT_I420:
334 case IMGFMT_IYUV:
335 case IMGFMT_Y800:
336 case IMGFMT_Y8:
337 return vf_next_query_format(vf,fmt);
338 }
339 return 0;
340 }
341
342 static unsigned int fmt_list[]={
343 IMGFMT_YV12,
344 IMGFMT_I420,
345 IMGFMT_IYUV,
346 IMGFMT_Y800,
347 IMGFMT_Y8,
348 0
349 };
350
351 static int control(struct vf_instance_s* vf, int request, void* data){
352 switch(request){
353 case VFCTRL_QUERY_MAX_PP_LEVEL:
354 return 8;
355 case VFCTRL_SET_PP_LEVEL:
356 vf->priv->log2_count= *((unsigned int*)data);
357 //FIXME we have to realloc a few things here
358 return CONTROL_TRUE;
359 }
360 return vf_next_control(vf,request,data);
361 }
362
363 static int open(vf_instance_t *vf, char* args){
364
365 int log2c=-1;
366
367 vf->config=config;
368 vf->put_image=put_image;
369 vf->get_image=get_image;
370 vf->query_format=query_format;
371 vf->uninit=uninit;
372 vf->control= control;
373 vf->priv=malloc(sizeof(struct vf_priv_s));
374 memset(vf->priv, 0, sizeof(struct vf_priv_s));
375
376 avcodec_init();
377 avcodec_register_all();
378
379 vf->priv->log2_count= 4;
380
381 if (args) sscanf(args, "%d:%d:%d", &log2c, &vf->priv->qp, &vf->priv->mode);
382
383 if( log2c >=0 && log2c <=8 )
384 vf->priv->log2_count = log2c;
385
386 if(vf->priv->qp < 0)
387 vf->priv->qp = 0;
388
389 // #ifdef HAVE_MMX
390 // if(gCpuCaps.hasMMX){
391 // store_slice= store_slice_mmx;
392 // }
393 // #endif
394
395 return 1;
396 }
397
398 vf_info_t vf_info_uspp = {
399 "ultra simple/slow postprocess",
400 "uspp",
401 "Michael Niedermayer",
402 "",
403 open,
404 NULL
405 };
406
407 #endif //USE_LIBAVCODEC