9 #if !defined(INFINITY) && defined(HUGE_VAL)
10 #define INFINITY HUGE_VAL
18 #include "codec-cfg.h"
25 #include "img_format.h"
29 extern char* passtmpfile
;
31 //===========================================================================//
33 #ifdef USE_LIBAVCODEC_SO
34 #include <ffmpeg/avcodec.h>
36 #include "libavcodec/avcodec.h"
39 extern int avcodec_inited
;
42 static char *lavc_param_vcodec
= "mpeg4";
43 static int lavc_param_vbitrate
= -1;
44 static int lavc_param_vrate_tolerance
= 1000*8;
45 static int lavc_param_mb_decision
= 0; /* default is realtime encoding */
46 static int lavc_param_v4mv
= 0;
47 static int lavc_param_vme
= 4;
48 static float lavc_param_vqscale
= -1;
49 static int lavc_param_vqmin
= 2;
50 static int lavc_param_vqmax
= 31;
51 static int lavc_param_mb_qmin
= 2;
52 static int lavc_param_mb_qmax
= 31;
53 static float lavc_param_lmin
= 2;
54 static float lavc_param_lmax
= 31;
55 static float lavc_param_mb_lmin
= 2;
56 static float lavc_param_mb_lmax
= 31;
57 static int lavc_param_vqdiff
= 3;
58 static float lavc_param_vqcompress
= 0.5;
59 static float lavc_param_vqblur
= 0.5;
60 static float lavc_param_vb_qfactor
= 1.25;
61 static float lavc_param_vb_qoffset
= 1.25;
62 static float lavc_param_vi_qfactor
= 0.8;
63 static float lavc_param_vi_qoffset
= 0.0;
64 static int lavc_param_vmax_b_frames
= 0;
65 static int lavc_param_keyint
= -1;
66 static int lavc_param_vpass
= 0;
67 static int lavc_param_vrc_strategy
= 0;
68 static int lavc_param_vb_strategy
= 0;
69 static int lavc_param_luma_elim_threshold
= 0;
70 static int lavc_param_chroma_elim_threshold
= 0;
71 static int lavc_param_packet_size
= 0;
72 static int lavc_param_strict
= -1;
73 static int lavc_param_data_partitioning
= 0;
74 static int lavc_param_gray
=0;
75 static float lavc_param_rc_qsquish
=1.0;
76 static float lavc_param_rc_qmod_amp
=0;
77 static int lavc_param_rc_qmod_freq
=0;
78 static char *lavc_param_rc_override_string
=NULL
;
79 static char *lavc_param_rc_eq
="tex^qComp";
80 static int lavc_param_rc_buffer_size
=0;
81 static float lavc_param_rc_buffer_aggressivity
=1.0;
82 static int lavc_param_rc_max_rate
=0;
83 static int lavc_param_rc_min_rate
=0;
84 static float lavc_param_rc_initial_cplx
=0;
85 static float lavc_param_rc_initial_buffer_occupancy
=0.9;
86 static int lavc_param_mpeg_quant
=0;
87 static int lavc_param_fdct
=0;
88 static int lavc_param_idct
=0;
89 static char* lavc_param_aspect
= NULL
;
90 static int lavc_param_autoaspect
= 0;
91 static float lavc_param_lumi_masking
= 0.0;
92 static float lavc_param_dark_masking
= 0.0;
93 static float lavc_param_temporal_cplx_masking
= 0.0;
94 static float lavc_param_spatial_cplx_masking
= 0.0;
95 static float lavc_param_p_masking
= 0.0;
96 static float lavc_param_border_masking
= 0.0;
97 static int lavc_param_normalize_aqp
= 0;
98 static int lavc_param_interlaced_dct
= 0;
99 static int lavc_param_prediction_method
= FF_PRED_LEFT
;
100 static int lavc_param_format
= IMGFMT_YV12
;
101 static int lavc_param_debug
= 0;
102 static int lavc_param_psnr
= 0;
103 static int lavc_param_me_pre_cmp
= 0;
104 static int lavc_param_me_cmp
= 0;
105 static int lavc_param_me_sub_cmp
= 0;
106 static int lavc_param_mb_cmp
= 0;
108 static int lavc_param_ildct_cmp
= FF_CMP_VSAD
;
110 static int lavc_param_pre_dia_size
= 0;
111 static int lavc_param_dia_size
= 0;
112 static int lavc_param_qpel
= 0;
113 static int lavc_param_trell
= 0;
114 static int lavc_param_bit_exact
= 0;
115 static int lavc_param_aic
= 0;
116 static int lavc_param_aiv
= 0;
117 static int lavc_param_umv
= 0;
118 static int lavc_param_obmc
= 0;
119 static int lavc_param_loop
= 0;
120 static int lavc_param_last_pred
= 0;
121 static int lavc_param_pre_me
= 1;
122 static int lavc_param_me_subpel_quality
= 8;
123 static int lavc_param_me_range
= 0;
124 static int lavc_param_ibias
= FF_DEFAULT_QUANT_BIAS
;
125 static int lavc_param_pbias
= FF_DEFAULT_QUANT_BIAS
;
126 static int lavc_param_coder
= 0;
127 static int lavc_param_context
= 0;
128 static char *lavc_param_intra_matrix
= NULL
;
129 static char *lavc_param_inter_matrix
= NULL
;
130 static int lavc_param_cbp
= 0;
131 static int lavc_param_mv0
= 0;
132 static int lavc_param_noise_reduction
= 0;
133 static int lavc_param_qns
= 0;
134 static int lavc_param_qp_rd
= 0;
135 static int lavc_param_inter_threshold
= 0;
136 static int lavc_param_sc_threshold
= 0;
137 static int lavc_param_ss
= 0;
138 static int lavc_param_top
= -1;
139 static int lavc_param_alt
= 0;
140 static int lavc_param_ilme
= 0;
141 static int lavc_param_nssew
= 8;
142 static int lavc_param_closed_gop
= 0;
143 static int lavc_param_dc_precision
= 8;
144 static int lavc_param_threads
= 1;
145 static int lavc_param_turbo
= 0;
146 static int lavc_param_brd_scale
= 0;
147 static int lavc_param_bidir_refine
= 0;
148 static int lavc_param_sc_factor
= 1;
149 static int lavc_param_video_global_header
= 0;
150 static int lavc_param_mv0_threshold
= 256;
151 static int lavc_param_refs
= 1;
152 static int lavc_param_b_sensitivity
= 40;
154 char *lavc_param_acodec
= "mp2";
155 int lavc_param_atag
= 0;
156 int lavc_param_abitrate
= 224;
157 int lavc_param_audio_global_header
= 0;
159 #include "m_option.h"
161 #ifdef USE_LIBAVCODEC
162 m_option_t lavcopts_conf
[]={
163 {"acodec", &lavc_param_acodec
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
164 {"abitrate", &lavc_param_abitrate
, CONF_TYPE_INT
, CONF_RANGE
, 1, 1000, NULL
},
165 {"atag", &lavc_param_atag
, CONF_TYPE_INT
, CONF_RANGE
, 0, 0xffff, NULL
},
166 {"vcodec", &lavc_param_vcodec
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
167 {"vbitrate", &lavc_param_vbitrate
, CONF_TYPE_INT
, CONF_RANGE
, 4, 24000000, NULL
},
168 {"vratetol", &lavc_param_vrate_tolerance
, CONF_TYPE_INT
, CONF_RANGE
, 4, 24000000, NULL
},
169 {"vhq", &lavc_param_mb_decision
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
170 {"mbd", &lavc_param_mb_decision
, CONF_TYPE_INT
, CONF_RANGE
, 0, 9, NULL
},
171 {"v4mv", &lavc_param_v4mv
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
172 {"vme", &lavc_param_vme
, CONF_TYPE_INT
, CONF_RANGE
, 0, 8, NULL
},
173 {"vqscale", &lavc_param_vqscale
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 255.0, NULL
},
174 {"vqmin", &lavc_param_vqmin
, CONF_TYPE_INT
, CONF_RANGE
, 1, 31, NULL
},
175 {"vqmax", &lavc_param_vqmax
, CONF_TYPE_INT
, CONF_RANGE
, 1, 31, NULL
},
176 {"mbqmin", &lavc_param_mb_qmin
, CONF_TYPE_INT
, CONF_RANGE
, 1, 31, NULL
},
177 {"mbqmax", &lavc_param_mb_qmax
, CONF_TYPE_INT
, CONF_RANGE
, 1, 31, NULL
},
178 {"lmin", &lavc_param_lmin
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.01, 255.0, NULL
},
179 {"lmax", &lavc_param_lmax
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.01, 255.0, NULL
},
180 {"mblmin", &lavc_param_mb_lmin
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.01, 255.0, NULL
},
181 {"mblmax", &lavc_param_mb_lmax
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.01, 255.0, NULL
},
182 {"vqdiff", &lavc_param_vqdiff
, CONF_TYPE_INT
, CONF_RANGE
, 1, 31, NULL
},
183 {"vqcomp", &lavc_param_vqcompress
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 1.0, NULL
},
184 {"vqblur", &lavc_param_vqblur
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 1.0, NULL
},
185 {"vb_qfactor", &lavc_param_vb_qfactor
, CONF_TYPE_FLOAT
, CONF_RANGE
, -31.0, 31.0, NULL
},
186 {"vmax_b_frames", &lavc_param_vmax_b_frames
, CONF_TYPE_INT
, CONF_RANGE
, 0, FF_MAX_B_FRAMES
, NULL
},
187 {"vpass", &lavc_param_vpass
, CONF_TYPE_INT
, CONF_RANGE
, 0, 3, NULL
},
188 {"vrc_strategy", &lavc_param_vrc_strategy
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2, NULL
},
189 {"vb_strategy", &lavc_param_vb_strategy
, CONF_TYPE_INT
, CONF_RANGE
, 0, 10, NULL
},
190 {"vb_qoffset", &lavc_param_vb_qoffset
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 31.0, NULL
},
191 {"vlelim", &lavc_param_luma_elim_threshold
, CONF_TYPE_INT
, CONF_RANGE
, -99, 99, NULL
},
192 {"vcelim", &lavc_param_chroma_elim_threshold
, CONF_TYPE_INT
, CONF_RANGE
, -99, 99, NULL
},
193 {"vpsize", &lavc_param_packet_size
, CONF_TYPE_INT
, CONF_RANGE
, 0, 100000000, NULL
},
194 {"vstrict", &lavc_param_strict
, CONF_TYPE_INT
, CONF_RANGE
, -99, 99, NULL
},
195 {"vdpart", &lavc_param_data_partitioning
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_PART
, NULL
},
196 {"keyint", &lavc_param_keyint
, CONF_TYPE_INT
, 0, 0, 0, NULL
},
197 {"gray", &lavc_param_gray
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_PART
, NULL
},
198 {"mpeg_quant", &lavc_param_mpeg_quant
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
199 {"vi_qfactor", &lavc_param_vi_qfactor
, CONF_TYPE_FLOAT
, CONF_RANGE
, -31.0, 31.0, NULL
},
200 {"vi_qoffset", &lavc_param_vi_qoffset
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 31.0, NULL
},
201 {"vqsquish", &lavc_param_rc_qsquish
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 99.0, NULL
},
202 {"vqmod_amp", &lavc_param_rc_qmod_amp
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 99.0, NULL
},
203 {"vqmod_freq", &lavc_param_rc_qmod_freq
, CONF_TYPE_INT
, 0, 0, 0, NULL
},
204 {"vrc_eq", &lavc_param_rc_eq
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
205 {"vrc_override", &lavc_param_rc_override_string
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
206 {"vrc_maxrate", &lavc_param_rc_max_rate
, CONF_TYPE_INT
, CONF_RANGE
, 0, 24000000, NULL
},
207 {"vrc_minrate", &lavc_param_rc_min_rate
, CONF_TYPE_INT
, CONF_RANGE
, 0, 24000000, NULL
},
208 {"vrc_buf_size", &lavc_param_rc_buffer_size
, CONF_TYPE_INT
, CONF_RANGE
, 4, 24000000, NULL
},
209 {"vrc_buf_aggressivity", &lavc_param_rc_buffer_aggressivity
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 99.0, NULL
},
210 {"vrc_init_cplx", &lavc_param_rc_initial_cplx
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 9999999.0, NULL
},
211 {"vrc_init_occupancy", &lavc_param_rc_initial_buffer_occupancy
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 1.0, NULL
},
212 {"vfdct", &lavc_param_fdct
, CONF_TYPE_INT
, CONF_RANGE
, 0, 10, NULL
},
213 {"aspect", &lavc_param_aspect
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
214 {"autoaspect", &lavc_param_autoaspect
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
215 {"lumi_mask", &lavc_param_lumi_masking
, CONF_TYPE_FLOAT
, CONF_RANGE
, -1.0, 1.0, NULL
},
216 {"tcplx_mask", &lavc_param_temporal_cplx_masking
, CONF_TYPE_FLOAT
, CONF_RANGE
, -1.0, 1.0, NULL
},
217 {"scplx_mask", &lavc_param_spatial_cplx_masking
, CONF_TYPE_FLOAT
, CONF_RANGE
, -1.0, 1.0, NULL
},
218 {"p_mask", &lavc_param_p_masking
, CONF_TYPE_FLOAT
, CONF_RANGE
, -1.0, 1.0, NULL
},
219 {"naq", &lavc_param_normalize_aqp
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
220 {"dark_mask", &lavc_param_dark_masking
, CONF_TYPE_FLOAT
, CONF_RANGE
, -1.0, 1.0, NULL
},
221 {"ildct", &lavc_param_interlaced_dct
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
222 {"idct", &lavc_param_idct
, CONF_TYPE_INT
, CONF_RANGE
, 0, 20, NULL
},
223 {"pred", &lavc_param_prediction_method
, CONF_TYPE_INT
, CONF_RANGE
, 0, 20, NULL
},
224 {"format", &lavc_param_format
, CONF_TYPE_IMGFMT
, 0, 0, 0, NULL
},
225 {"debug", &lavc_param_debug
, CONF_TYPE_INT
, CONF_RANGE
, 0, 100000000, NULL
},
226 {"psnr", &lavc_param_psnr
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_PSNR
, NULL
},
227 {"precmp", &lavc_param_me_pre_cmp
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
228 {"cmp", &lavc_param_me_cmp
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
229 {"subcmp", &lavc_param_me_sub_cmp
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
230 {"mbcmp", &lavc_param_mb_cmp
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
232 {"ildctcmp", &lavc_param_ildct_cmp
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
234 {"bit_exact", &lavc_param_bit_exact
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_BITEXACT
, NULL
},
235 {"predia", &lavc_param_pre_dia_size
, CONF_TYPE_INT
, CONF_RANGE
, -2000, 2000, NULL
},
236 {"dia", &lavc_param_dia_size
, CONF_TYPE_INT
, CONF_RANGE
, -2000, 2000, NULL
},
237 {"qpel", &lavc_param_qpel
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_QPEL
, NULL
},
238 {"trell", &lavc_param_trell
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_TRELLIS_QUANT
, NULL
},
239 {"last_pred", &lavc_param_last_pred
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
240 {"preme", &lavc_param_pre_me
, CONF_TYPE_INT
, CONF_RANGE
, 0, 2000, NULL
},
241 {"subq", &lavc_param_me_subpel_quality
, CONF_TYPE_INT
, CONF_RANGE
, 0, 8, NULL
},
242 {"me_range", &lavc_param_me_range
, CONF_TYPE_INT
, CONF_RANGE
, 0, 16000, NULL
},
243 #ifdef CODEC_FLAG_H263P_AIC
244 {"aic", &lavc_param_aic
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_H263P_AIC
, NULL
},
245 {"umv", &lavc_param_umv
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_H263P_UMV
, NULL
},
247 #ifdef CODEC_FLAG_H263P_AIV
248 {"aiv", &lavc_param_aiv
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_H263P_AIV
, NULL
},
250 #ifdef CODEC_FLAG_OBMC
251 {"obmc", &lavc_param_obmc
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_OBMC
, NULL
},
253 #ifdef CODEC_FLAG_LOOP_FILTER
254 {"loop", &lavc_param_loop
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_LOOP_FILTER
, NULL
},
256 {"ibias", &lavc_param_ibias
, CONF_TYPE_INT
, CONF_RANGE
, -512, 512, NULL
},
257 {"pbias", &lavc_param_pbias
, CONF_TYPE_INT
, CONF_RANGE
, -512, 512, NULL
},
258 {"coder", &lavc_param_coder
, CONF_TYPE_INT
, CONF_RANGE
, 0, 10, NULL
},
259 {"context", &lavc_param_context
, CONF_TYPE_INT
, CONF_RANGE
, 0, 10, NULL
},
260 {"intra_matrix", &lavc_param_intra_matrix
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
261 {"inter_matrix", &lavc_param_inter_matrix
, CONF_TYPE_STRING
, 0, 0, 0, NULL
},
262 {"cbp", &lavc_param_cbp
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_CBP_RD
, NULL
},
263 {"mv0", &lavc_param_mv0
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_MV0
, NULL
},
264 {"nr", &lavc_param_noise_reduction
, CONF_TYPE_INT
, CONF_RANGE
, 0, 1000000, NULL
},
265 #ifdef CODEC_FLAG_QP_RD
266 {"qprd", &lavc_param_qp_rd
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_QP_RD
, NULL
},
268 #ifdef CODEC_FLAG_H263P_SLICE_STRUCT
269 {"ss", &lavc_param_ss
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_H263P_SLICE_STRUCT
, NULL
},
271 #ifdef CODEC_FLAG_ALT_SCAN
272 {"alt", &lavc_param_alt
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_ALT_SCAN
, NULL
},
274 #ifdef CODEC_FLAG_INTERLACED_ME
275 {"ilme", &lavc_param_ilme
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_INTERLACED_ME
, NULL
},
277 #ifdef CODEC_FLAG_CLOSED_GOP
278 {"cgop", &lavc_param_closed_gop
, CONF_TYPE_FLAG
, 0, 0, CODEC_FLAG_CLOSED_GOP
, NULL
},
280 {"dc", &lavc_param_dc_precision
, CONF_TYPE_INT
, CONF_RANGE
, 8, 11, NULL
},
281 {"border_mask", &lavc_param_border_masking
, CONF_TYPE_FLOAT
, CONF_RANGE
, 0.0, 1.0, NULL
},
282 {"inter_threshold", &lavc_param_inter_threshold
, CONF_TYPE_INT
, CONF_RANGE
, -1000000, 1000000, NULL
},
283 {"sc_threshold", &lavc_param_sc_threshold
, CONF_TYPE_INT
, CONF_RANGE
, -1000000000, 1000000000, NULL
},
284 {"top", &lavc_param_top
, CONF_TYPE_INT
, CONF_RANGE
, -1, 1, NULL
},
285 {"qns", &lavc_param_qns
, CONF_TYPE_INT
, CONF_RANGE
, 0, 1000000, NULL
},
286 {"nssew", &lavc_param_nssew
, CONF_TYPE_INT
, CONF_RANGE
, 0, 1000000, NULL
},
287 {"threads", &lavc_param_threads
, CONF_TYPE_INT
, CONF_RANGE
, 1, 8, NULL
},
288 {"turbo", &lavc_param_turbo
, CONF_TYPE_FLAG
, 0, 0, 1, NULL
},
289 {"brd_scale", &lavc_param_brd_scale
, CONF_TYPE_INT
, CONF_RANGE
, 0, 10, NULL
},
290 {"bidir_refine", &lavc_param_bidir_refine
, CONF_TYPE_INT
, CONF_RANGE
, 0, 4, NULL
},
291 {"sc_factor", &lavc_param_sc_factor
, CONF_TYPE_INT
, CONF_RANGE
, 1, INT_MAX
, NULL
},
292 {"vglobal", &lavc_param_video_global_header
, CONF_TYPE_INT
, CONF_RANGE
, 0, INT_MAX
, NULL
},
293 {"aglobal", &lavc_param_audio_global_header
, CONF_TYPE_INT
, CONF_RANGE
, 0, INT_MAX
, NULL
},
294 {"mv0_threshold", &lavc_param_mv0_threshold
, CONF_TYPE_INT
, CONF_RANGE
, 0, INT_MAX
, NULL
},
295 {"refs", &lavc_param_refs
, CONF_TYPE_INT
, CONF_RANGE
, 1, 16, NULL
},
296 {"b_sensitivity", &lavc_param_b_sensitivity
, CONF_TYPE_INT
, CONF_RANGE
, 1, INT_MAX
, NULL
},
297 {NULL
, NULL
, 0, 0, 0, 0, NULL
}
303 AVCodecContext
*context
;
309 #define stats_file (vf->priv->stats_file)
310 #define mux_v (vf->priv->mux)
311 #define lavc_venc_context (vf->priv->context)
313 static int encode_frame(struct vf_instance_s
* vf
, AVFrame
*pic
, double pts
);
315 static int config(struct vf_instance_s
* vf
,
316 int width
, int height
, int d_width
, int d_height
,
317 unsigned int flags
, unsigned int outfmt
){
321 mux_v
->bih
->biWidth
=width
;
322 mux_v
->bih
->biHeight
=height
;
323 mux_v
->bih
->biSizeImage
=mux_v
->bih
->biWidth
*mux_v
->bih
->biHeight
*(mux_v
->bih
->biBitCount
/8);
325 mp_msg(MSGT_MENCODER
, MSGL_INFO
,"videocodec: libavcodec (%dx%d fourcc=%x [%.4s])\n",
326 mux_v
->bih
->biWidth
, mux_v
->bih
->biHeight
, mux_v
->bih
->biCompression
,
327 (char *)&mux_v
->bih
->biCompression
);
329 lavc_venc_context
->width
= width
;
330 lavc_venc_context
->height
= height
;
331 if (lavc_param_vbitrate
> 16000) /* != -1 */
332 lavc_venc_context
->bit_rate
= lavc_param_vbitrate
;
333 else if (lavc_param_vbitrate
>= 0) /* != -1 */
334 lavc_venc_context
->bit_rate
= lavc_param_vbitrate
*1000;
336 lavc_venc_context
->bit_rate
= 800000; /* default */
338 mux_v
->avg_rate
= lavc_venc_context
->bit_rate
;
340 lavc_venc_context
->bit_rate_tolerance
= lavc_param_vrate_tolerance
*1000;
341 lavc_venc_context
->time_base
= (AVRational
){mux_v
->h
.dwScale
, mux_v
->h
.dwRate
};
342 lavc_venc_context
->qmin
= lavc_param_vqmin
;
343 lavc_venc_context
->qmax
= lavc_param_vqmax
;
344 lavc_venc_context
->mb_qmin
= lavc_param_mb_qmin
;
345 lavc_venc_context
->mb_qmax
= lavc_param_mb_qmax
;
346 lavc_venc_context
->lmin
= (int)(FF_QP2LAMBDA
* lavc_param_lmin
+ 0.5);
347 lavc_venc_context
->lmax
= (int)(FF_QP2LAMBDA
* lavc_param_lmax
+ 0.5);
348 lavc_venc_context
->mb_lmin
= (int)(FF_QP2LAMBDA
* lavc_param_mb_lmin
+ 0.5);
349 lavc_venc_context
->mb_lmax
= (int)(FF_QP2LAMBDA
* lavc_param_mb_lmax
+ 0.5);
350 lavc_venc_context
->max_qdiff
= lavc_param_vqdiff
;
351 lavc_venc_context
->qcompress
= lavc_param_vqcompress
;
352 lavc_venc_context
->qblur
= lavc_param_vqblur
;
353 lavc_venc_context
->max_b_frames
= lavc_param_vmax_b_frames
;
354 lavc_venc_context
->b_quant_factor
= lavc_param_vb_qfactor
;
355 lavc_venc_context
->rc_strategy
= lavc_param_vrc_strategy
;
356 lavc_venc_context
->b_frame_strategy
= lavc_param_vb_strategy
;
357 lavc_venc_context
->b_quant_offset
= (int)(FF_QP2LAMBDA
* lavc_param_vb_qoffset
+ 0.5);
358 lavc_venc_context
->luma_elim_threshold
= lavc_param_luma_elim_threshold
;
359 lavc_venc_context
->chroma_elim_threshold
= lavc_param_chroma_elim_threshold
;
360 lavc_venc_context
->rtp_payload_size
= lavc_param_packet_size
;
361 if(lavc_param_packet_size
)lavc_venc_context
->rtp_mode
=1;
362 lavc_venc_context
->strict_std_compliance
= lavc_param_strict
;
363 lavc_venc_context
->i_quant_factor
= lavc_param_vi_qfactor
;
364 lavc_venc_context
->i_quant_offset
= (int)(FF_QP2LAMBDA
* lavc_param_vi_qoffset
+ 0.5);
365 lavc_venc_context
->rc_qsquish
= lavc_param_rc_qsquish
;
366 lavc_venc_context
->rc_qmod_amp
= lavc_param_rc_qmod_amp
;
367 lavc_venc_context
->rc_qmod_freq
= lavc_param_rc_qmod_freq
;
368 lavc_venc_context
->rc_eq
= lavc_param_rc_eq
;
371 lavc_venc_context
->rc_max_rate
= lavc_param_rc_max_rate
*1000;
372 lavc_venc_context
->rc_min_rate
= lavc_param_rc_min_rate
*1000;
375 lavc_venc_context
->rc_buffer_size
= lavc_param_rc_buffer_size
*1000;
377 lavc_venc_context
->rc_initial_buffer_occupancy
=
378 lavc_venc_context
->rc_buffer_size
*
379 lavc_param_rc_initial_buffer_occupancy
;
380 lavc_venc_context
->rc_buffer_aggressivity
= lavc_param_rc_buffer_aggressivity
;
381 lavc_venc_context
->rc_initial_cplx
= lavc_param_rc_initial_cplx
;
382 lavc_venc_context
->debug
= lavc_param_debug
;
383 lavc_venc_context
->last_predictor_count
= lavc_param_last_pred
;
384 lavc_venc_context
->pre_me
= lavc_param_pre_me
;
385 lavc_venc_context
->me_pre_cmp
= lavc_param_me_pre_cmp
;
386 lavc_venc_context
->pre_dia_size
= lavc_param_pre_dia_size
;
387 lavc_venc_context
->me_subpel_quality
= lavc_param_me_subpel_quality
;
388 lavc_venc_context
->me_range
= lavc_param_me_range
;
389 lavc_venc_context
->intra_quant_bias
= lavc_param_ibias
;
390 lavc_venc_context
->inter_quant_bias
= lavc_param_pbias
;
391 lavc_venc_context
->coder_type
= lavc_param_coder
;
392 lavc_venc_context
->context_model
= lavc_param_context
;
393 lavc_venc_context
->scenechange_threshold
= lavc_param_sc_threshold
;
394 lavc_venc_context
->noise_reduction
= lavc_param_noise_reduction
;
395 lavc_venc_context
->quantizer_noise_shaping
= lavc_param_qns
;
396 lavc_venc_context
->inter_threshold
= lavc_param_inter_threshold
;
397 lavc_venc_context
->nsse_weight
= lavc_param_nssew
;
398 if (lavc_param_intra_matrix
)
402 lavc_venc_context
->intra_matrix
=
403 av_malloc(sizeof(*lavc_venc_context
->intra_matrix
)*64);
406 while ((tmp
= strsep(&lavc_param_intra_matrix
, ",")) && (i
< 64))
408 if (!tmp
|| (tmp
&& !strlen(tmp
)))
410 lavc_venc_context
->intra_matrix
[i
++] = atoi(tmp
);
414 av_freep(&lavc_venc_context
->intra_matrix
);
416 mp_msg(MSGT_MENCODER
, MSGL_V
, "Using user specified intra matrix\n");
418 if (lavc_param_inter_matrix
)
422 lavc_venc_context
->inter_matrix
=
423 av_malloc(sizeof(*lavc_venc_context
->inter_matrix
)*64);
426 while ((tmp
= strsep(&lavc_param_inter_matrix
, ",")) && (i
< 64))
428 if (!tmp
|| (tmp
&& !strlen(tmp
)))
430 lavc_venc_context
->inter_matrix
[i
++] = atoi(tmp
);
434 av_freep(&lavc_venc_context
->inter_matrix
);
436 mp_msg(MSGT_MENCODER
, MSGL_V
, "Using user specified inter matrix\n");
439 p
= lavc_param_rc_override_string
;
442 int e
=sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
444 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"error parsing vrc_q\n");
447 lavc_venc_context
->rc_override
=
448 realloc(lavc_venc_context
->rc_override
, sizeof(RcOverride
)*(i
+1));
449 lavc_venc_context
->rc_override
[i
].start_frame
= start
;
450 lavc_venc_context
->rc_override
[i
].end_frame
= end
;
452 lavc_venc_context
->rc_override
[i
].qscale
= q
;
453 lavc_venc_context
->rc_override
[i
].quality_factor
= 1.0;
456 lavc_venc_context
->rc_override
[i
].qscale
= 0;
457 lavc_venc_context
->rc_override
[i
].quality_factor
= -q
/100.0;
462 lavc_venc_context
->rc_override_count
=i
;
464 lavc_venc_context
->mpeg_quant
=lavc_param_mpeg_quant
;
466 lavc_venc_context
->dct_algo
= lavc_param_fdct
;
467 lavc_venc_context
->idct_algo
= lavc_param_idct
;
469 lavc_venc_context
->lumi_masking
= lavc_param_lumi_masking
;
470 lavc_venc_context
->temporal_cplx_masking
= lavc_param_temporal_cplx_masking
;
471 lavc_venc_context
->spatial_cplx_masking
= lavc_param_spatial_cplx_masking
;
472 lavc_venc_context
->p_masking
= lavc_param_p_masking
;
473 lavc_venc_context
->dark_masking
= lavc_param_dark_masking
;
474 lavc_venc_context
->border_masking
= lavc_param_border_masking
;
476 if (lavc_param_aspect
!= NULL
)
478 int par_width
, par_height
, e
;
481 e
= sscanf (lavc_param_aspect
, "%d/%d", &par_width
, &par_height
);
484 ratio
= (float)par_width
/ (float)par_height
;
486 e
= sscanf (lavc_param_aspect
, "%f", &ratio
);
489 if (e
&& ratio
> 0.1 && ratio
< 10.0) {
490 lavc_venc_context
->sample_aspect_ratio
= av_d2q(ratio
* height
/ width
, 255);
491 mp_dbg(MSGT_MENCODER
, MSGL_DBG2
, "sample_aspect_ratio: %d/%d\n",
492 lavc_venc_context
->sample_aspect_ratio
.num
,
493 lavc_venc_context
->sample_aspect_ratio
.den
);
494 mux_v
->aspect
= ratio
;
495 mp_dbg(MSGT_MENCODER
, MSGL_DBG2
, "aspect_ratio: %f\n", ratio
);
497 mp_dbg(MSGT_MENCODER
, MSGL_ERR
, "aspect ratio: cannot parse \"%s\"\n", lavc_param_aspect
);
501 else if (lavc_param_autoaspect
) {
502 lavc_venc_context
->sample_aspect_ratio
= av_d2q((float)d_width
/d_height
*height
/ width
, 255);
503 mux_v
->aspect
= (float)d_width
/d_height
;
506 /* keyframe interval */
507 if (lavc_param_keyint
>= 0) /* != -1 */
508 lavc_venc_context
->gop_size
= lavc_param_keyint
;
510 lavc_venc_context
->gop_size
= 250; /* default */
512 lavc_venc_context
->flags
= 0;
513 if (lavc_param_mb_decision
)
515 mp_msg(MSGT_MENCODER
, MSGL_INFO
, MSGTR_MPCODECS_HighQualityEncodingSelected
);
516 lavc_venc_context
->mb_decision
= lavc_param_mb_decision
;
519 lavc_venc_context
->me_cmp
= lavc_param_me_cmp
;
520 lavc_venc_context
->me_sub_cmp
= lavc_param_me_sub_cmp
;
521 lavc_venc_context
->mb_cmp
= lavc_param_mb_cmp
;
523 lavc_venc_context
->ildct_cmp
= lavc_param_ildct_cmp
;
525 lavc_venc_context
->dia_size
= lavc_param_dia_size
;
526 lavc_venc_context
->flags
|= lavc_param_qpel
;
527 lavc_venc_context
->flags
|= lavc_param_trell
;
528 lavc_venc_context
->flags
|= lavc_param_bit_exact
;
529 lavc_venc_context
->flags
|= lavc_param_aic
;
530 lavc_venc_context
->flags
|= lavc_param_aiv
;
531 lavc_venc_context
->flags
|= lavc_param_umv
;
532 lavc_venc_context
->flags
|= lavc_param_obmc
;
533 lavc_venc_context
->flags
|= lavc_param_loop
;
534 lavc_venc_context
->flags
|= lavc_param_v4mv
? CODEC_FLAG_4MV
: 0;
535 lavc_venc_context
->flags
|= lavc_param_data_partitioning
;
536 lavc_venc_context
->flags
|= lavc_param_cbp
;
537 lavc_venc_context
->flags
|= lavc_param_mv0
;
538 lavc_venc_context
->flags
|= lavc_param_qp_rd
;
539 lavc_venc_context
->flags
|= lavc_param_ss
;
540 lavc_venc_context
->flags
|= lavc_param_alt
;
541 lavc_venc_context
->flags
|= lavc_param_ilme
;
542 #ifdef CODEC_FLAG_CLOSED_GOP
543 lavc_venc_context
->flags
|= lavc_param_closed_gop
;
545 if(lavc_param_gray
) lavc_venc_context
->flags
|= CODEC_FLAG_GRAY
;
547 if(lavc_param_normalize_aqp
) lavc_venc_context
->flags
|= CODEC_FLAG_NORMALIZE_AQP
;
548 if(lavc_param_interlaced_dct
) lavc_venc_context
->flags
|= CODEC_FLAG_INTERLACED_DCT
;
549 lavc_venc_context
->flags
|= lavc_param_psnr
;
550 lavc_venc_context
->intra_dc_precision
= lavc_param_dc_precision
- 8;
551 lavc_venc_context
->prediction_method
= lavc_param_prediction_method
;
552 lavc_venc_context
->brd_scale
= lavc_param_brd_scale
;
553 lavc_venc_context
->bidir_refine
= lavc_param_bidir_refine
;
554 lavc_venc_context
->scenechange_factor
= lavc_param_sc_factor
;
555 if((lavc_param_video_global_header
&1)
556 /*|| (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))*/){
557 lavc_venc_context
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
559 if(lavc_param_video_global_header
&2){
560 lavc_venc_context
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
562 lavc_venc_context
->mv0_threshold
= lavc_param_mv0_threshold
;
563 lavc_venc_context
->refs
= lavc_param_refs
;
564 lavc_venc_context
->b_sensitivity
= lavc_param_b_sensitivity
;
566 switch(lavc_param_format
)
569 lavc_venc_context
->pix_fmt
= PIX_FMT_YUV420P
;
572 lavc_venc_context
->pix_fmt
= PIX_FMT_YUV422P
;
575 lavc_venc_context
->pix_fmt
= PIX_FMT_YUV444P
;
578 lavc_venc_context
->pix_fmt
= PIX_FMT_YUV411P
;
581 lavc_venc_context
->pix_fmt
= PIX_FMT_YUV410P
;
584 lavc_venc_context
->pix_fmt
= PIX_FMT_RGB32
;
587 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"%s is not a supported format\n", vo_format_name(lavc_param_format
));
592 /* lavc internal 2pass bitrate control */
593 switch(lavc_param_vpass
){
596 lavc_venc_context
->flags
|= CODEC_FLAG_PASS2
;
597 stats_file
= fopen(passtmpfile
, "rb");
598 if(stats_file
==NULL
){
599 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"2pass failed: filename=%s\n", passtmpfile
);
602 fseek(stats_file
, 0, SEEK_END
);
603 size
= ftell(stats_file
);
604 fseek(stats_file
, 0, SEEK_SET
);
606 lavc_venc_context
->stats_in
= av_malloc(size
+ 1);
607 lavc_venc_context
->stats_in
[size
]=0;
609 if(fread(lavc_venc_context
->stats_in
, size
, 1, stats_file
)<1){
610 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"2pass failed: reading from filename=%s\n", passtmpfile
);
613 if(lavc_param_vpass
== 2)
619 lavc_venc_context
->flags
|= CODEC_FLAG_PASS1
;
620 stats_file
= fopen(passtmpfile
, "wb");
621 if(stats_file
==NULL
){
622 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"2pass failed: filename=%s\n", passtmpfile
);
625 if(lavc_param_turbo
&& (lavc_param_vpass
== 1)) {
626 /* uses SAD comparison functions instead of other hungrier */
627 lavc_venc_context
->me_pre_cmp
= 0;
628 lavc_venc_context
->me_cmp
= 0;
629 lavc_venc_context
->me_sub_cmp
= 0;
630 lavc_venc_context
->mb_cmp
= 2;
632 /* Disables diamond motion estimation */
633 lavc_venc_context
->pre_dia_size
= 0;
634 lavc_venc_context
->dia_size
= 1;
636 lavc_venc_context
->quantizer_noise_shaping
= 0; // qns=0
637 lavc_venc_context
->noise_reduction
= 0; // nr=0
638 lavc_venc_context
->mb_decision
= 0; // mbd=0 ("realtime" encoding)
640 lavc_venc_context
->flags
&= ~CODEC_FLAG_QPEL
;
641 lavc_venc_context
->flags
&= ~CODEC_FLAG_4MV
;
642 lavc_venc_context
->flags
&= ~CODEC_FLAG_TRELLIS_QUANT
;
643 lavc_venc_context
->flags
&= ~CODEC_FLAG_CBP_RD
;
644 lavc_venc_context
->flags
&= ~CODEC_FLAG_QP_RD
;
645 lavc_venc_context
->flags
&= ~CODEC_FLAG_MV0
;
651 lavc_venc_context
->me_method
= ME_ZERO
+lavc_param_vme
;
653 /* fixed qscale :p */
654 if (lavc_param_vqscale
>= 0.0)
656 mp_msg(MSGT_MENCODER
, MSGL_INFO
, MSGTR_MPCODECS_UsingConstantQscale
, lavc_param_vqscale
);
657 lavc_venc_context
->flags
|= CODEC_FLAG_QSCALE
;
658 lavc_venc_context
->global_quality
=
659 vf
->priv
->pic
->quality
= (int)(FF_QP2LAMBDA
* lavc_param_vqscale
+ 0.5);
662 if(lavc_param_threads
> 1)
663 avcodec_thread_init(lavc_venc_context
, lavc_param_threads
);
665 if (avcodec_open(lavc_venc_context
, vf
->priv
->codec
) != 0) {
666 mp_msg(MSGT_MENCODER
,MSGL_ERR
,MSGTR_CantOpenCodec
);
670 if (lavc_venc_context
->codec
->encode
== NULL
) {
671 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"avcodec init failed (ctx->codec->encode == NULL)!\n");
675 /* free second pass buffer, its not needed anymore */
676 av_freep(&lavc_venc_context
->stats_in
);
677 if(lavc_venc_context
->bits_per_sample
)
678 mux_v
->bih
->biBitCount
= lavc_venc_context
->bits_per_sample
;
679 if(lavc_venc_context
->extradata_size
){
680 mux_v
->bih
= realloc(mux_v
->bih
, sizeof(BITMAPINFOHEADER
) + lavc_venc_context
->extradata_size
);
681 memcpy(mux_v
->bih
+ 1, lavc_venc_context
->extradata
, lavc_venc_context
->extradata_size
);
682 mux_v
->bih
->biSize
= sizeof(BITMAPINFOHEADER
) + lavc_venc_context
->extradata_size
;
685 mux_v
->decoder_delay
= lavc_venc_context
->max_b_frames
? 1 : 0;
690 static int control(struct vf_instance_s
* vf
, int request
, void* data
){
693 case VFCTRL_FLUSH_FRAMES
:
694 if(vf
->priv
->codec
->capabilities
& CODEC_CAP_DELAY
)
695 while(encode_frame(vf
, NULL
, MP_NOPTS_VALUE
) > 0);
698 return CONTROL_UNKNOWN
;
702 static int query_format(struct vf_instance_s
* vf
, unsigned int fmt
){
707 if(lavc_param_format
== IMGFMT_YV12
)
708 return VFCAP_CSP_SUPPORTED
| VFCAP_ACCEPT_STRIDE
;
711 if(lavc_param_format
== IMGFMT_411P
)
712 return VFCAP_CSP_SUPPORTED
| VFCAP_ACCEPT_STRIDE
;
715 if(lavc_param_format
== IMGFMT_422P
)
716 return VFCAP_CSP_SUPPORTED
| VFCAP_ACCEPT_STRIDE
;
719 if(lavc_param_format
== IMGFMT_444P
)
720 return VFCAP_CSP_SUPPORTED
| VFCAP_ACCEPT_STRIDE
;
723 if(lavc_param_format
== IMGFMT_YVU9
)
724 return VFCAP_CSP_SUPPORTED
| VFCAP_ACCEPT_STRIDE
;
727 if(lavc_param_format
== IMGFMT_BGR32
)
728 return VFCAP_CSP_SUPPORTED
| VFCAP_ACCEPT_STRIDE
;
734 static double psnr(double d
){
735 if(d
==0) return INFINITY
;
736 return -10.0*log(d
)/log(10);
739 static int put_image(struct vf_instance_s
* vf
, mp_image_t
*mpi
, double pts
){
740 AVFrame
*pic
= vf
->priv
->pic
;
742 pic
->data
[0]=mpi
->planes
[0];
743 pic
->data
[1]=mpi
->planes
[1];
744 pic
->data
[2]=mpi
->planes
[2];
745 pic
->linesize
[0]=mpi
->stride
[0];
746 pic
->linesize
[1]=mpi
->stride
[1];
747 pic
->linesize
[2]=mpi
->stride
[2];
749 if(lavc_param_interlaced_dct
){
750 if((mpi
->fields
& MP_IMGFIELD_ORDERED
) && (mpi
->fields
& MP_IMGFIELD_INTERLACED
))
751 pic
->top_field_first
= !!(mpi
->fields
& MP_IMGFIELD_TOP_FIRST
);
753 pic
->top_field_first
= 1;
755 if(lavc_param_top
!=-1)
756 pic
->top_field_first
= lavc_param_top
;
759 return (encode_frame(vf
, pic
, pts
) >= 0);
762 static int encode_frame(struct vf_instance_s
* vf
, AVFrame
*pic
, double pts
){
763 const char pict_type_char
[5]= {'?', 'I', 'P', 'B', 'S'};
769 pic
->opaque
= malloc(sizeof(pts
));
770 memcpy(pic
->opaque
, &pts
, sizeof(pts
));
772 if(pts
!= MP_NOPTS_VALUE
)
773 pic
->pts
= floor(pts
/ av_q2d(lavc_venc_context
->time_base
) + 0.5);
775 pic
->pts
= MP_NOPTS_VALUE
;
778 out_size
= avcodec_encode_video(lavc_venc_context
, mux_v
->buffer
, mux_v
->buffer_size
,
781 if(pts
!= MP_NOPTS_VALUE
)
782 dts
= pts
- lavc_venc_context
->delay
* av_q2d(lavc_venc_context
->time_base
);
786 pts
= lavc_venc_context
->coded_frame
->opaque
?
787 *(double*)lavc_venc_context
->coded_frame
->opaque
790 if(lavc_venc_context
->coded_frame
->pts
!= MP_NOPTS_VALUE
)
791 pts
= lavc_venc_context
->coded_frame
->pts
* av_q2d(lavc_venc_context
->time_base
);
794 assert(MP_NOPTS_VALUE
== AV_NOPTS_VALUE
);
796 //fprintf(stderr, "ve_lavc %f/%f\n", dts, pts);
798 ++mux_v
->encoder_delay
;
802 muxer_write_chunk(mux_v
,out_size
,lavc_venc_context
->coded_frame
->key_frame
?0x10:0,
804 free(lavc_venc_context
->coded_frame
->opaque
);
805 lavc_venc_context
->coded_frame
->opaque
= NULL
;
807 /* store psnr / pict size / type / qscale */
809 static FILE *fvstats
=NULL
;
811 double f
= lavc_venc_context
->width
*lavc_venc_context
->height
*255.0*255.0;
819 today
= localtime(&today2
);
820 sprintf(filename
, "psnr_%02d%02d%02d.log", today
->tm_hour
,
821 today
->tm_min
, today
->tm_sec
);
822 fvstats
= fopen(filename
,"w");
825 lavc_param_psnr
=0; // disable block
826 mp_msg(MSGT_MENCODER
,MSGL_ERR
,"Can't open %s for writing. Check its permissions.\n",filename
);
832 // average MB quantizer
833 q
= lavc_venc_context
->coded_frame
->qscale_table
;
836 int w
= (lavc_venc_context
->width
+15) >> 4;
837 int h
= (lavc_venc_context
->height
+15) >> 4;
838 for( y
= 0; y
< h
; y
++ ) {
839 for( x
= 0; x
< w
; x
++ )
840 quality
+= (double)*(q
+x
);
841 q
+= lavc_venc_context
->coded_frame
->qstride
;
845 quality
= lavc_venc_context
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
;
847 fprintf(fvstats
, "%6d, %2.2f, %6d, %2.2f, %2.2f, %2.2f, %2.2f %c\n",
848 lavc_venc_context
->coded_frame
->coded_picture_number
,
851 psnr(lavc_venc_context
->coded_frame
->error
[0]/f
),
852 psnr(lavc_venc_context
->coded_frame
->error
[1]*4/f
),
853 psnr(lavc_venc_context
->coded_frame
->error
[2]*4/f
),
854 psnr((lavc_venc_context
->coded_frame
->error
[0]+lavc_venc_context
->coded_frame
->error
[1]+lavc_venc_context
->coded_frame
->error
[2])/(f
*1.5)),
855 pict_type_char
[lavc_venc_context
->coded_frame
->pict_type
]
858 /* store stats if there are any */
859 if(lavc_venc_context
->stats_out
&& stats_file
)
860 fprintf(stats_file
, "%s", lavc_venc_context
->stats_out
);
864 static void uninit(struct vf_instance_s
* vf
){
867 double f
= lavc_venc_context
->width
*lavc_venc_context
->height
*255.0*255.0;
868 f
*= lavc_venc_context
->coded_frame
->coded_picture_number
;
870 mp_msg(MSGT_MENCODER
, MSGL_INFO
, "PSNR: Y:%2.2f, Cb:%2.2f, Cr:%2.2f, All:%2.2f\n",
871 psnr(lavc_venc_context
->error
[0]/f
),
872 psnr(lavc_venc_context
->error
[1]*4/f
),
873 psnr(lavc_venc_context
->error
[2]*4/f
),
874 psnr((lavc_venc_context
->error
[0]+lavc_venc_context
->error
[1]+lavc_venc_context
->error
[2])/(f
*1.5))
878 av_freep(&lavc_venc_context
->intra_matrix
);
879 av_freep(&lavc_venc_context
->inter_matrix
);
881 avcodec_close(lavc_venc_context
);
883 if(stats_file
) fclose(stats_file
);
885 /* free rc_override */
886 av_freep(&lavc_venc_context
->rc_override
);
888 av_freep(&vf
->priv
->context
);
891 //===========================================================================//
893 static int vf_open(vf_instance_t
*vf
, char* args
){
896 vf
->default_caps
=VFCAP_CONSTANT
;
898 vf
->query_format
=query_format
;
899 vf
->put_image
=put_image
;
900 vf
->priv
=malloc(sizeof(struct vf_priv_s
));
901 memset(vf
->priv
,0,sizeof(struct vf_priv_s
));
902 vf
->priv
->mux
=(muxer_stream_t
*)args
;
904 /* XXX: hack: some of the MJPEG decoder DLL's needs exported huffman
905 table, so we define a zero-table, also lavc mjpeg encoder is putting
906 huffman tables into the stream, so no problem */
907 if (lavc_param_vcodec
&& !strcasecmp(lavc_param_vcodec
, "mjpeg"))
909 mux_v
->bih
=malloc(sizeof(BITMAPINFOHEADER
)+28);
910 memset(mux_v
->bih
, 0, sizeof(BITMAPINFOHEADER
)+28);
911 mux_v
->bih
->biSize
=sizeof(BITMAPINFOHEADER
)+28;
913 else if (lavc_param_vcodec
&& (!strcasecmp(lavc_param_vcodec
, "huffyuv")
914 || !strcasecmp(lavc_param_vcodec
, "ffvhuff")))
916 /* XXX: hack: huffyuv needs to store huffman tables (allthough we dunno the size yet ...) */
917 mux_v
->bih
=malloc(sizeof(BITMAPINFOHEADER
)+1000);
918 memset(mux_v
->bih
, 0, sizeof(BITMAPINFOHEADER
)+1000);
919 mux_v
->bih
->biSize
=sizeof(BITMAPINFOHEADER
)+1000;
921 else if (lavc_param_vcodec
&& !strcasecmp(lavc_param_vcodec
, "asv1"))
923 mux_v
->bih
=malloc(sizeof(BITMAPINFOHEADER
)+8);
924 memset(mux_v
->bih
, 0, sizeof(BITMAPINFOHEADER
)+8);
925 mux_v
->bih
->biSize
=sizeof(BITMAPINFOHEADER
)+8;
927 else if (lavc_param_vcodec
&& !strcasecmp(lavc_param_vcodec
, "asv2"))
929 mux_v
->bih
=malloc(sizeof(BITMAPINFOHEADER
)+8);
930 memset(mux_v
->bih
, 0, sizeof(BITMAPINFOHEADER
)+8);
931 mux_v
->bih
->biSize
=sizeof(BITMAPINFOHEADER
)+8;
933 else if (lavc_param_vcodec
&& !strcasecmp(lavc_param_vcodec
, "wmv2"))
935 mux_v
->bih
=malloc(sizeof(BITMAPINFOHEADER
)+4);
936 memset(mux_v
->bih
, 0, sizeof(BITMAPINFOHEADER
)+4);
937 mux_v
->bih
->biSize
=sizeof(BITMAPINFOHEADER
)+4;
941 mux_v
->bih
=malloc(sizeof(BITMAPINFOHEADER
));
942 memset(mux_v
->bih
, 0, sizeof(BITMAPINFOHEADER
));
943 mux_v
->bih
->biSize
=sizeof(BITMAPINFOHEADER
);
945 mux_v
->bih
->biWidth
=0;
946 mux_v
->bih
->biHeight
=0;
947 mux_v
->bih
->biPlanes
=1;
948 mux_v
->bih
->biBitCount
=24;
949 if (!lavc_param_vcodec
)
951 printf("No libavcodec codec specified! It's required!\n");
955 if (!strcasecmp(lavc_param_vcodec
, "mpeg1") || !strcasecmp(lavc_param_vcodec
, "mpeg1video"))
956 mux_v
->bih
->biCompression
= mmioFOURCC('m', 'p', 'g', '1');
957 else if (!strcasecmp(lavc_param_vcodec
, "mpeg2") || !strcasecmp(lavc_param_vcodec
, "mpeg2video"))
958 mux_v
->bih
->biCompression
= mmioFOURCC('m', 'p', 'g', '2');
959 else if (!strcasecmp(lavc_param_vcodec
, "h263") || !strcasecmp(lavc_param_vcodec
, "h263p"))
960 mux_v
->bih
->biCompression
= mmioFOURCC('h', '2', '6', '3');
961 else if (!strcasecmp(lavc_param_vcodec
, "rv10"))
962 mux_v
->bih
->biCompression
= mmioFOURCC('R', 'V', '1', '0');
963 else if (!strcasecmp(lavc_param_vcodec
, "mjpeg"))
964 mux_v
->bih
->biCompression
= mmioFOURCC('M', 'J', 'P', 'G');
965 else if (!strcasecmp(lavc_param_vcodec
, "ljpeg"))
966 mux_v
->bih
->biCompression
= mmioFOURCC('L', 'J', 'P', 'G');
967 else if (!strcasecmp(lavc_param_vcodec
, "mpeg4"))
968 mux_v
->bih
->biCompression
= mmioFOURCC('F', 'M', 'P', '4');
969 else if (!strcasecmp(lavc_param_vcodec
, "msmpeg4"))
970 mux_v
->bih
->biCompression
= mmioFOURCC('d', 'i', 'v', '3');
971 else if (!strcasecmp(lavc_param_vcodec
, "msmpeg4v2"))
972 mux_v
->bih
->biCompression
= mmioFOURCC('M', 'P', '4', '2');
973 else if (!strcasecmp(lavc_param_vcodec
, "wmv1"))
974 mux_v
->bih
->biCompression
= mmioFOURCC('W', 'M', 'V', '1');
975 else if (!strcasecmp(lavc_param_vcodec
, "wmv2"))
976 mux_v
->bih
->biCompression
= mmioFOURCC('W', 'M', 'V', '2');
977 else if (!strcasecmp(lavc_param_vcodec
, "huffyuv"))
978 mux_v
->bih
->biCompression
= mmioFOURCC('H', 'F', 'Y', 'U');
979 else if (!strcasecmp(lavc_param_vcodec
, "ffvhuff"))
980 mux_v
->bih
->biCompression
= mmioFOURCC('F', 'F', 'V', 'H');
981 else if (!strcasecmp(lavc_param_vcodec
, "asv1"))
982 mux_v
->bih
->biCompression
= mmioFOURCC('A', 'S', 'V', '1');
983 else if (!strcasecmp(lavc_param_vcodec
, "asv2"))
984 mux_v
->bih
->biCompression
= mmioFOURCC('A', 'S', 'V', '2');
985 else if (!strcasecmp(lavc_param_vcodec
, "ffv1"))
986 mux_v
->bih
->biCompression
= mmioFOURCC('F', 'F', 'V', '1');
987 else if (!strcasecmp(lavc_param_vcodec
, "snow"))
988 mux_v
->bih
->biCompression
= mmioFOURCC('S', 'N', 'O', 'W');
989 else if (!strcasecmp(lavc_param_vcodec
, "flv"))
990 mux_v
->bih
->biCompression
= mmioFOURCC('F', 'L', 'V', '1');
992 mux_v
->bih
->biCompression
= mmioFOURCC(lavc_param_vcodec
[0],
993 lavc_param_vcodec
[1], lavc_param_vcodec
[2], lavc_param_vcodec
[3]); /* FIXME!!! */
995 if (!avcodec_inited
){
997 avcodec_register_all();
1001 vf
->priv
->codec
= (AVCodec
*)avcodec_find_encoder_by_name(lavc_param_vcodec
);
1002 if (!vf
->priv
->codec
) {
1003 mp_msg(MSGT_MENCODER
,MSGL_ERR
,MSGTR_MissingLAVCcodec
, lavc_param_vcodec
);
1007 vf
->priv
->pic
= avcodec_alloc_frame();
1008 vf
->priv
->context
= avcodec_alloc_context();
1013 vf_info_t ve_info_lavc
= {
1014 "libavcodec encoder",
1016 "A'rpi, Alex, Michael",
1017 "for internal use by mencoder",
1021 //===========================================================================//