5550
|
1 #include <stdio.h>
|
|
2 #include <stdlib.h>
|
|
3 #include <string.h>
|
|
4
|
|
5 #include "../config.h"
|
|
6 #include "../mp_msg.h"
|
|
7
|
|
8 #ifdef HAVE_DIVX4ENCORE
|
|
9
|
|
10 #include "codec-cfg.h"
|
|
11 #include "stream.h"
|
|
12 #include "demuxer.h"
|
|
13 #include "stheader.h"
|
|
14
|
|
15 #include "aviwrite.h"
|
|
16
|
|
17 #include "../libvo/img_format.h"
|
|
18 #include "../mp_image.h"
|
|
19 #include "vf.h"
|
|
20
|
|
21 //===========================================================================//
|
|
22
|
|
23 #include "divx4_vbr.h"
|
|
24
|
|
25 extern int pass;
|
|
26 extern char* passtmpfile;
|
|
27
|
|
28 #include <encore2.h>
|
|
29
|
|
30 ENC_PARAM divx4_param;
|
|
31 int divx4_crispness;
|
|
32
|
|
33 #include "cfgparser.h"
|
|
34
|
|
35 struct config divx4opts_conf[]={
|
|
36 {"br", &divx4_param.bitrate, CONF_TYPE_INT, CONF_RANGE, 4, 24000000, NULL},
|
|
37 {"rc_period", &divx4_param.rc_period, CONF_TYPE_INT, 0,0,0, NULL},
|
|
38 {"rc_reaction_period", &divx4_param.rc_reaction_period, CONF_TYPE_INT, 0,0,0, NULL},
|
|
39 {"rc_reaction_ratio", &divx4_param.rc_reaction_ratio, CONF_TYPE_INT, 0,0,0, NULL},
|
|
40 {"min_quant", &divx4_param.min_quantizer, CONF_TYPE_INT, CONF_RANGE,0,32, NULL},
|
|
41 {"max_quant", &divx4_param.max_quantizer, CONF_TYPE_INT, CONF_RANGE,0,32, NULL},
|
|
42 {"key", &divx4_param.max_key_interval, CONF_TYPE_INT, CONF_MIN,0,0, NULL},
|
|
43 {"deinterlace", &divx4_param.deinterlace, CONF_TYPE_FLAG, 0,0,1, NULL},
|
|
44 {"q", &divx4_param.quality, CONF_TYPE_INT, CONF_RANGE, 1, 5, NULL},
|
|
45 {"crispness", &divx4_crispness, CONF_TYPE_INT, CONF_RANGE,0,100, NULL},
|
|
46 {"help", "TODO: divx4opts help!\n", CONF_TYPE_PRINT, CONF_NOCFG, 0, 0, NULL},
|
|
47 {NULL, NULL, 0, 0, 0, 0, NULL}
|
|
48 };
|
|
49
|
|
50 struct vf_priv_s {
|
|
51 aviwrite_stream_t* mux;
|
|
52 ENC_RESULT enc_result;
|
|
53 ENC_FRAME enc_frame;
|
|
54 void* enc_handle;
|
|
55 };
|
|
56
|
|
57 #define mux_v (vf->priv->mux)
|
|
58
|
|
59 static int config(struct vf_instance_s* vf,
|
|
60 int width, int height, int d_width, int d_height,
|
|
61 unsigned int flags, unsigned int outfmt){
|
|
62
|
|
63 mux_v->bih->biWidth=width;
|
|
64 mux_v->bih->biHeight=height;
|
|
65
|
|
66 divx4_param.x_dim=width;
|
|
67 divx4_param.y_dim=height;
|
|
68 divx4_param.framerate=(float)mux_v->h.dwRate/mux_v->h.dwScale;
|
|
69 mux_v->bih->biSizeImage=mux_v->bih->biWidth*mux_v->bih->biHeight*3;
|
|
70
|
|
71 if(!divx4_param.bitrate) divx4_param.bitrate=800000;
|
|
72 else if(divx4_param.bitrate<=16000) divx4_param.bitrate*=1000;
|
|
73 if(!divx4_param.quality) divx4_param.quality=5; // the quality of compression ( 1 - fastest, 5 - best )
|
|
74
|
|
75 divx4_param.handle=NULL;
|
|
76 encore(NULL,ENC_OPT_INIT,&divx4_param,NULL);
|
|
77 vf->priv->enc_handle=divx4_param.handle;
|
|
78 switch(outfmt){
|
|
79 case IMGFMT_YV12: vf->priv->enc_frame.colorspace=ENC_CSP_YV12; break;
|
|
80 case IMGFMT_IYUV:
|
|
81 case IMGFMT_I420: vf->priv->enc_frame.colorspace=ENC_CSP_I420; break;
|
|
82 case IMGFMT_YUY2: vf->priv->enc_frame.colorspace=ENC_CSP_YUY2; break;
|
|
83 case IMGFMT_UYVY: vf->priv->enc_frame.colorspace=ENC_CSP_UYVY; break;
|
|
84 case IMGFMT_RGB24:
|
|
85 case IMGFMT_BGR24:
|
|
86 vf->priv->enc_frame.colorspace=ENC_CSP_RGB24; break;
|
|
87 default:
|
|
88 mp_msg(MSGT_MENCODER,MSGL_ERR,"divx4: unsupported picture format (%s)!\n",
|
|
89 vo_format_name(outfmt));
|
|
90 return 0;
|
|
91 }
|
|
92
|
|
93 switch(pass){
|
|
94 case 1:
|
|
95 if (VbrControl_init_2pass_vbr_analysis(passtmpfile, divx4_param.quality) == -1){
|
|
96 mp_msg(MSGT_MENCODER,MSGL_ERR,"2pass failed: filename=%s\n", passtmpfile);
|
|
97 pass=0;
|
|
98 }
|
|
99 break;
|
|
100 case 2:
|
|
101 if (VbrControl_init_2pass_vbr_encoding(passtmpfile,
|
|
102 divx4_param.bitrate,
|
|
103 divx4_param.framerate,
|
|
104 divx4_crispness,
|
|
105 divx4_param.quality) == -1){
|
|
106 mp_msg(MSGT_MENCODER,MSGL_ERR,"2pass failed: filename=%s\n", passtmpfile);
|
|
107 pass=0;
|
|
108 }
|
|
109 break;
|
|
110 }
|
|
111
|
|
112 return 1;
|
|
113 }
|
|
114
|
|
115 static int control(struct vf_instance_s* vf, int request, void* data){
|
|
116
|
|
117 return CONTROL_UNKNOWN;
|
|
118 }
|
|
119
|
|
120 static int query_format(struct vf_instance_s* vf, unsigned int fmt){
|
|
121 switch(fmt){
|
|
122 case IMGFMT_YV12:
|
|
123 case IMGFMT_IYUV:
|
|
124 case IMGFMT_I420:
|
|
125 return 3; // no conversion
|
|
126 case IMGFMT_YUY2:
|
|
127 case IMGFMT_UYVY:
|
|
128 case IMGFMT_RGB24:
|
|
129 case IMGFMT_BGR24:
|
|
130 return 1; // conversion
|
|
131 }
|
|
132 return 0;
|
|
133 }
|
|
134
|
|
135 static void put_image(struct vf_instance_s* vf, mp_image_t *mpi){
|
|
136 ENC_RESULT enc_result;
|
|
137 vf->priv->enc_frame.image=mpi->planes[0];
|
|
138 vf->priv->enc_frame.bitstream=mux_v->buffer;
|
|
139 vf->priv->enc_frame.length=mux_v->buffer_size;
|
|
140 vf->priv->enc_frame.mvs=NULL;
|
|
141 if(pass==2){ // handle 2-pass:
|
|
142 vf->priv->enc_frame.quant = VbrControl_get_quant();
|
|
143 vf->priv->enc_frame.intra = VbrControl_get_intra();
|
|
144 encore(vf->priv->enc_handle,ENC_OPT_ENCODE_VBR,&vf->priv->enc_frame,&enc_result);
|
|
145 VbrControl_update_2pass_vbr_encoding(enc_result.motion_bits,
|
|
146 enc_result.texture_bits,
|
|
147 enc_result.total_bits);
|
|
148 } else {
|
|
149 vf->priv->enc_frame.quant=0;
|
|
150 vf->priv->enc_frame.intra=0;
|
|
151 encore(vf->priv->enc_handle,ENC_OPT_ENCODE,&vf->priv->enc_frame,&enc_result);
|
|
152 if(pass==1){
|
|
153 VbrControl_update_2pass_vbr_analysis(enc_result.is_key_frame,
|
|
154 enc_result.motion_bits,
|
|
155 enc_result.texture_bits,
|
|
156 enc_result.total_bits,
|
|
157 enc_result.quantizer);
|
|
158 }
|
|
159 }
|
|
160 mencoder_write_frame(mux_v,vf->priv->enc_frame.length,enc_result.is_key_frame?0x10:0);
|
|
161 }
|
|
162
|
|
163 //===========================================================================//
|
|
164
|
|
165 static int vf_open(vf_instance_t *vf, char* args){
|
|
166 vf->config=config;
|
|
167 vf->control=control;
|
|
168 vf->query_format=query_format;
|
|
169 vf->put_image=put_image;
|
|
170 vf->priv=malloc(sizeof(struct vf_priv_s));
|
|
171 memset(vf->priv,0,sizeof(struct vf_priv_s));
|
|
172 vf->priv->mux=args;
|
|
173
|
|
174 mux_v->bih=malloc(sizeof(BITMAPINFOHEADER));
|
|
175 mux_v->bih->biSize=sizeof(BITMAPINFOHEADER);
|
|
176 mux_v->bih->biWidth=0;
|
|
177 mux_v->bih->biHeight=0;
|
|
178 mux_v->bih->biPlanes=1;
|
|
179 mux_v->bih->biBitCount=24;
|
|
180 mux_v->bih->biCompression=mmioFOURCC('d','i','v','x');
|
|
181
|
|
182 return 1;
|
|
183 }
|
|
184
|
|
185 vf_info_t ve_info_divx4 = {
|
|
186 "divx4 encoder",
|
|
187 "divx4",
|
|
188 "A'rpi",
|
|
189 "for internal use by mencoder",
|
|
190 vf_open
|
|
191 };
|
|
192
|
|
193 //===========================================================================//
|
|
194 #endif
|