?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
printf -> mp_msg
[mplayer/glamo.git] / mencoder.c
bloba7095d700bb9b9cc048dfd461d6e8397a1c65b82
1 #define VCODEC_COPY 0
2 #define VCODEC_FRAMENO 1
3 // real codecs:
4 #define VCODEC_DIVX4 2
5 #define VCODEC_LIBAVCODEC 4
6 #define VCODEC_VFW 7
7 #define VCODEC_LIBDV 8
8 #define VCODEC_XVID 9
9 #define VCODEC_QTVIDEO 10
10 #define VCODEC_NUV 11
11 #define VCODEC_RAW 12
12
13 #define ACODEC_COPY 0
14 #define ACODEC_PCM 1
15 #define ACODEC_VBRMP3 2
16 #define ACODEC_NULL 3
17 #define ACODEC_LAVC 4
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <signal.h>
23 #ifdef __MINGW32__
24 #define SIGQUIT 3
25 #endif
26 #include <sys/time.h>
27
28 #include "config.h"
29
30 #include "version.h"
31 #include "mp_msg.h"
32 #include "help_mp.h"
33
34 #include "cpudetect.h"
35
36 #include "codec-cfg.h"
37 #include "m_option.h"
38 #include "m_config.h"
39 #include "parser-mecmd.h"
40
41 #include "libmpdemux/stream.h"
42 #include "libmpdemux/demuxer.h"
43 #include "libmpdemux/stheader.h"
44 #include "libmpdemux/mp3_hdr.h"
45 #include "libmpdemux/muxer.h"
46
47
48 #include "libvo/video_out.h"
49
50 #include "libao2/afmt.h"
51
52 #include "libmpcodecs/mp_image.h"
53 #include "libmpcodecs/dec_audio.h"
54 #include "libmpcodecs/dec_video.h"
55 #include "libmpcodecs/vf.h"
56
57 // for MPEGLAYER3WAVEFORMAT:
58 #include "loader/wine/mmreg.h"
59
60 #ifdef HAVE_MP3LAME
61 #undef CDECL
62 #include <lame/lame.h>
63 #endif
64
65 #include <inttypes.h>
66
67 #include "libvo/fastmemcpy.h"
68
69 #include "osdep/timer.h"
70
71 #ifdef USE_LIBAVCODEC
72 // for lavc audio encoding
73
74 #ifdef USE_LIBAVCODEC_SO
75 #include <ffmpeg/avcodec.h>
76 #else
77 #include "libavcodec/avcodec.h"
78 #endif
79
80 static AVCodec *lavc_acodec;
81 static AVCodecContext *lavc_actx = NULL;
82 extern char *lavc_param_acodec;
83 extern int lavc_param_abitrate;
84 extern int lavc_param_atag;
85 // tmp buffer for lavc audio encoding (to free!!!!!)
86 static void *lavc_abuf = NULL;
87 extern int avcodec_inited;
88
89 static uint32_t lavc_find_atag(char *codec);
90 #endif
91
92 int vo_doublebuffering=0;
93 int vo_directrendering=0;
94 int vo_config_count=0;
95 int forced_subs_only=0;
96
97 //--------------------------
98
99 // cache2:
100 int stream_cache_size=-1;
101 #ifdef USE_STREAM_CACHE
102 extern int cache_fill_status;
103 #else
104 #define cache_fill_status 0
105 #endif
106
107 int audio_id=-1;
108 int video_id=-1;
109 int dvdsub_id=-1;
110 int vobsub_id=-1;
111 char* audio_lang=NULL;
112 char* dvdsub_lang=NULL;
113 static char* spudec_ifo=NULL;
114
115 static char** audio_codec_list=NULL; // override audio codec
116 static char** video_codec_list=NULL; // override video codec
117 static char** audio_fm_list=NULL; // override audio codec family
118 static char** video_fm_list=NULL; // override video codec family
119
120 static int out_audio_codec=-1;
121 static int out_video_codec=-1;
122
123 int out_file_format=MUXER_TYPE_AVI; // default to AVI
124
125 // audio stream skip/resync functions requires only for seeking.
126 // (they should be implemented in the audio codec layer)
127 //void skip_audio_frame(sh_audio_t *sh_audio){}
128 //void resync_audio_stream(sh_audio_t *sh_audio){}
129
130 int verbose=0; // must be global!
131 int quiet=0;
132 double video_time_usage=0;
133 double vout_time_usage=0;
134 double max_video_time_usage=0;
135 double max_vout_time_usage=0;
136 double cur_video_time_usage=0;
137 double cur_vout_time_usage=0;
138 int benchmark=0;
139
140 // A-V sync:
141 int delay_corrected=1;
142 static float default_max_pts_correction=-1;//0.01f;
143 static float max_pts_correction=0;//default_max_pts_correction;
144 static float c_total=0;
145
146 static float audio_preload=0.5;
147 static float audio_delay=0.0;
148 static int audio_density=2;
149
150 float force_fps=0;
151 static float force_ofps=0; // set to 24 for inverse telecine
152 static int skip_limit=-1;
153
154 static int force_srate=0;
155 static int audio_output_format=0;
156
157 char *vobsub_out=NULL;
158 unsigned int vobsub_out_index=0;
159 char *vobsub_out_id=NULL;
160
161 char* out_filename="test.avi";
162
163 char *force_fourcc=NULL;
164
165 char* passtmpfile="divx2pass.log";
166
167 static int play_n_frames=-1;
168 static int play_n_frames_mf=-1;
169
170 #include "libvo/font_load.h"
171 #include "libvo/sub.h"
172
173 // sub:
174 char *font_name=NULL;
175 #ifdef HAVE_FONTCONFIG
176 extern int font_fontconfig;
177 #endif
178 float font_factor=0.75;
179 char **sub_name=NULL;
180 float sub_delay=0;
181 float sub_fps=0;
182 int sub_auto = 0;
183 int subcc_enabled=0;
184 int suboverlap_enabled = 1;
185
186 #ifdef USE_SUB
187 static sub_data* subdata=NULL;
188 float sub_last_pts = -303;
189 #endif
190
191 int auto_expand=1;
192
193 // infos are empty by default
194 char *info_name=NULL;
195 char *info_artist=NULL;
196 char *info_genre=NULL;
197 char *info_subject=NULL;
198 char *info_copyright=NULL;
199 char *info_sourceform=NULL;
200 char *info_comment=NULL;
201
202
203
204 //char *out_audio_codec=NULL; // override audio codec
205 //char *out_video_codec=NULL; // override video codec
206
207 //#include "libmpeg2/mpeg2.h"
208 //#include "libmpeg2/mpeg2_internal.h"
209
210 #ifdef HAVE_MP3LAME
211 int lame_param_quality=0; // best
212 int lame_param_algqual=5; // same as old default
213 int lame_param_vbr=vbr_default;
214 int lame_param_mode=-1; // unset
215 int lame_param_padding=-1; // unset
216 int lame_param_br=-1; // unset
217 int lame_param_ratio=-1; // unset
218 float lame_param_scale=-1; // unset
219 int lame_param_lowpassfreq = 0; //auto
220 int lame_param_highpassfreq = 0; //auto
221
222 #if HAVE_MP3LAME >= 392
223 int lame_param_fast=0; // unset
224 static char* lame_param_preset=NULL; // unset
225 static int lame_presets_set( lame_t gfp, int fast, int cbr, const char* preset_name );
226 static void lame_presets_longinfo_dm ( FILE* msgfp );
227 #endif
228 #endif
229
230 //static int vo_w=0, vo_h=0;
231
232 //-------------------------- config stuff:
233
234 m_config_t* mconfig;
235
236 extern int m_config_parse_config_file(m_config_t* config, char *conffile);
237
238 static int cfg_inc_verbose(m_option_t *conf){ ++verbose; return 0;}
239
240 static int cfg_include(m_option_t *conf, char *filename){
241 return m_config_parse_config_file(mconfig, filename);
242 }
243
244 static char *seek_to_sec=NULL;
245 static off_t seek_to_byte=0;
246
247 static int parse_end_at(m_option_t *conf, const char* param);
248 //static uint8_t* flip_upside_down(uint8_t* dst, const uint8_t* src, int width, int height);
249
250 #include "get_path.c"
251
252 #include "cfg-mplayer-def.h"
253 #include "cfg-mencoder.h"
254
255 #ifdef USE_DVDREAD
256 #include "spudec.h"
257 #endif
258 #include "vobsub.h"
259
260 /* FIXME */
261 static void mencoder_exit(int level, char *how)
262 {
263 if (how)
264 printf("Exiting... (%s)\n", how);
265 else
266 printf("Exiting...\n");
267
268 exit(level);
269 }
270
271 void parse_cfgfiles( m_config_t* conf )
272 {
273 char *conffile;
274 if ((conffile = get_path("mencoder")) == NULL) {
275 mp_msg(MSGT_CPLAYER,MSGL_ERR,MSGTR_GetpathProblem);
276 } else {
277 if (m_config_parse_config_file(conf, conffile) < 0)
278 mencoder_exit(1,"configfile error");
279 free(conffile);
280 }
281 }
282
283
284 //---------------------------------------------------------------------------
285
286 static int dec_audio(sh_audio_t *sh_audio,unsigned char* buffer,int total){
287 int size=0;
288 int at_eof=0;
289 while(size<total && !at_eof){
290 int len=total-size;
291 if(len>MAX_OUTBURST) len=MAX_OUTBURST;
292 if(len>sh_audio->a_out_buffer_size) len=sh_audio->a_out_buffer_size;
293 if(len>sh_audio->a_out_buffer_len){
294 int ret=decode_audio(sh_audio,
295 &sh_audio->a_out_buffer[sh_audio->a_out_buffer_len],
296 len-sh_audio->a_out_buffer_len,
297 sh_audio->a_out_buffer_size-sh_audio->a_out_buffer_len);
298 if(ret>0) sh_audio->a_out_buffer_len+=ret; else at_eof=1;
299 }
300 if(len>sh_audio->a_out_buffer_len) len=sh_audio->a_out_buffer_len;
301 memcpy(buffer+size,sh_audio->a_out_buffer,len);
302 sh_audio->a_out_buffer_len-=len; size+=len;
303 if(sh_audio->a_out_buffer_len>0)
304 memcpy(sh_audio->a_out_buffer,&sh_audio->a_out_buffer[len],sh_audio->a_out_buffer_len);
305 }
306 return size;
307 }
308
309 //---------------------------------------------------------------------------
310
311 static int at_eof=0;
312 static int interrupted=0;
313
314 enum end_at_type_t {END_AT_NONE, END_AT_TIME, END_AT_SIZE};
315 static enum end_at_type_t end_at_type = END_AT_NONE;
316 static double end_at;
317
318 static void exit_sighandler(int x){
319 at_eof=1;
320 interrupted=2; /* 1 means error */
321 }
322
323 static muxer_t* muxer=NULL;
324 static FILE* muxer_f=NULL;
325
326 extern void print_wave_header(WAVEFORMATEX *h);
327
328 int main(int argc,char* argv[]){
329
330 stream_t* stream=NULL;
331 demuxer_t* demuxer=NULL;
332 stream_t* stream2=NULL;
333 demuxer_t* demuxer2=NULL;
334 demux_stream_t *d_audio=NULL;
335 demux_stream_t *d_video=NULL;
336 demux_stream_t *d_dvdsub=NULL;
337 sh_audio_t *sh_audio=NULL;
338 sh_video_t *sh_video=NULL;
339 int file_format=DEMUXER_TYPE_UNKNOWN;
340 int i;
341 void *vobsub_writer=NULL;
342
343 uint32_t ptimer_start;
344 uint32_t audiorate=0;
345 uint32_t videorate=0;
346 uint32_t audiosamples=1;
347 uint32_t videosamples=1;
348 uint32_t skippedframes=0;
349 uint32_t duplicatedframes=0;
350 uint32_t badframes=0;
351
352 muxer_stream_t* mux_a=NULL;
353 muxer_stream_t* mux_v=NULL;
354 off_t muxer_f_size=0;
355
356 #ifdef HAVE_MP3LAME
357 lame_global_flags *lame;
358 #endif
359
360 double v_pts_corr=0;
361 double v_timer_corr=0;
362
363 m_entry_t* filelist = NULL;
364 char* filename=NULL;
365 char* frameno_filename="frameno.avi";
366
367 int decoded_frameno=0;
368 int next_frameno=-1;
369
370 unsigned int timer_start;
371
372 mp_msg_init();
373 mp_msg_set_level(MSGL_STATUS);
374 mp_msg(MSGT_CPLAYER,MSGL_INFO, "MEncoder " VERSION " (C) 2000-2004 MPlayer Team\n\n");
375
376 /* Test for cpu capabilities (and corresponding OS support) for optimizing */
377 GetCpuCaps(&gCpuCaps);
378 #ifdef ARCH_X86
379 mp_msg(MSGT_CPLAYER,MSGL_INFO,"CPUflags: Type: %d MMX: %d MMX2: %d 3DNow: %d 3DNow2: %d SSE: %d SSE2: %d\n",
380 gCpuCaps.cpuType,gCpuCaps.hasMMX,gCpuCaps.hasMMX2,
381 gCpuCaps.has3DNow, gCpuCaps.has3DNowExt,
382 gCpuCaps.hasSSE, gCpuCaps.hasSSE2);
383 #ifdef RUNTIME_CPUDETECT
384 mp_msg(MSGT_CPLAYER,MSGL_INFO, MSGTR_CompiledWithRuntimeDetection);
385 #else
386 mp_msg(MSGT_CPLAYER,MSGL_INFO, MSGTR_CompiledWithCPUExtensions);
387 #ifdef HAVE_MMX
388 mp_msg(MSGT_CPLAYER,MSGL_INFO," MMX");
389 #endif
390 #ifdef HAVE_MMX2
391 mp_msg(MSGT_CPLAYER,MSGL_INFO," MMX2");
392 #endif
393 #ifdef HAVE_3DNOW
394 mp_msg(MSGT_CPLAYER,MSGL_INFO," 3DNow");
395 #endif
396 #ifdef HAVE_3DNOWEX
397 mp_msg(MSGT_CPLAYER,MSGL_INFO," 3DNowEx");
398 #endif
399 #ifdef HAVE_SSE
400 mp_msg(MSGT_CPLAYER,MSGL_INFO," SSE");
401 #endif
402 #ifdef HAVE_SSE2
403 mp_msg(MSGT_CPLAYER,MSGL_INFO," SSE2");
404 #endif
405 mp_msg(MSGT_CPLAYER,MSGL_INFO,"\n\n");
406 #endif
407 #endif
408
409 InitTimer();
410
411 // check codec.conf
412 if(!codecs_file || !parse_codec_cfg(codecs_file)){
413 if(!parse_codec_cfg(get_path("codecs.conf"))){
414 if(!parse_codec_cfg(MPLAYER_CONFDIR "/codecs.conf")){
415 if(!parse_codec_cfg(NULL)){
416 mp_msg(MSGT_MENCODER,MSGL_HINT,MSGTR_CopyCodecsConf);
417 mencoder_exit(1,NULL);
418 }
419 mp_msg(MSGT_MENCODER,MSGL_INFO,MSGTR_BuiltinCodecsConf);
420 }
421 }
422 }
423
424 // FIXME: get rid of -dvd and other tricky options
425 stream2=open_stream(frameno_filename,0,&i);
426 if(stream2){
427 demuxer2=demux_open(stream2,DEMUXER_TYPE_AVI,-1,-1,-2,NULL);
428 if(demuxer2) printf(MSGTR_UsingPass3ControllFile,frameno_filename);
429 else mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_FormatNotRecognized);
430 }
431
432 mconfig = m_config_new();
433 m_config_register_options(mconfig,mencoder_opts);
434 parse_cfgfiles(mconfig);
435 filelist = m_config_parse_me_command_line(mconfig, argc, argv);
436 if(!filelist) mencoder_exit(1, "error parsing cmdline");
437 m_entry_set_options(mconfig,&filelist[0]);
438 filename = filelist[0].name;
439
440 if(!filename){
441 printf(MSGTR_MissingFilename);
442 mencoder_exit(1,NULL);
443 }
444
445 mp_msg_set_level(verbose+MSGL_STATUS);
446
447 // check font
448 #ifdef USE_OSD
449 #ifdef HAVE_FREETYPE
450 init_freetype();
451 #endif
452 #ifdef HAVE_FONTCONFIG
453 if(!font_fontconfig)
454 {
455 #endif
456 if(font_name){
457 vo_font=read_font_desc(font_name,font_factor,verbose>1);
458 if(!vo_font) mp_msg(MSGT_CPLAYER,MSGL_ERR,MSGTR_CantLoadFont,font_name);
459 } else {
460 // try default:
461 vo_font=read_font_desc(get_path("font/font.desc"),font_factor,verbose>1);
462 if(!vo_font)
463 vo_font=read_font_desc(MPLAYER_DATADIR "/font/font.desc",font_factor,verbose>1);
464 }
465 #ifdef HAVE_FONTCONFIG
466 }
467 #endif
468 #endif
469
470 vo_init_osd();
471
472 stream=open_stream(filename,0,&file_format);
473
474 if(!stream){
475 printf(MSGTR_CannotOpenFile_Device);
476 mencoder_exit(1,NULL);
477 }
478
479 printf("success: format: %d data: 0x%X - 0x%X\n",file_format, (int)(stream->start_pos),(int)(stream->end_pos));
480
481 #ifdef USE_DVDREAD
482 if(stream->type==STREAMTYPE_DVD){
483 if(audio_lang && audio_id==-1) audio_id=dvd_aid_from_lang(stream,audio_lang);
484 if(dvdsub_lang && dvdsub_id==-1) dvdsub_id=dvd_sid_from_lang(stream,dvdsub_lang);
485 }
486 #endif
487
488 stream->start_pos+=seek_to_byte;
489
490 if(stream_cache_size>0) stream_enable_cache(stream,stream_cache_size*1024,0,0);
491
492 if(demuxer2) audio_id=-2; /* do NOT read audio packets... */
493
494 //demuxer=demux_open(stream,file_format,video_id,audio_id,dvdsub_id);
495 demuxer=demux_open(stream,file_format,audio_id,video_id,dvdsub_id,filename);
496 if(!demuxer){
497 mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_FormatNotRecognized);
498 printf(MSGTR_CannotOpenDemuxer);
499 mencoder_exit(1,NULL);
500 }
501
502 d_audio=demuxer2 ? demuxer2->audio : demuxer->audio;
503 d_video=demuxer->video;
504 d_dvdsub=demuxer->sub;
505 sh_audio=d_audio->sh;
506 sh_video=d_video->sh;
507
508 if(!sh_video)
509 {
510 mp_msg(MSGT_CPLAYER,MSGL_FATAL,"Video stream is mandatory!\n");
511 mencoder_exit(1,NULL);
512 }
513
514 if(!video_read_properties(sh_video)){
515 printf(MSGTR_CannotReadVideoProperties);
516 mencoder_exit(1,NULL);
517 }
518
519 mp_msg(MSGT_MENCODER,MSGL_INFO,"[V] filefmt:%d fourcc:0x%X size:%dx%d fps:%5.2f ftime:=%6.4f\n",
520 demuxer->file_format,sh_video->format, sh_video->disp_w,sh_video->disp_h,
521 sh_video->fps,sh_video->frametime
522 );
523
524 if(force_fps){
525 sh_video->fps=force_fps;
526 sh_video->frametime=1.0f/sh_video->fps;
527 mp_msg(MSGT_MENCODER,MSGL_INFO,"input fps will be interpreted as %5.2f instead\n", sh_video->fps);
528 }
529
530 if(sh_audio && out_audio_codec<0){
531 if(audio_id==-2)
532 mp_msg(MSGT_MENCODER,MSGL_ERR,"This demuxer doesn't support -nosound yet.\n");
533 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_NoAudioEncoderSelected);
534 mencoder_exit(1,NULL);
535 }
536 if(sh_video && out_video_codec<0){
537 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_NoVideoEncoderSelected);
538 mencoder_exit(1,NULL);
539 }
540
541 if(sh_audio && (out_audio_codec || seek_to_sec || !sh_audio->wf)){
542 // Go through the codec.conf and find the best codec...
543 mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
544 if(!init_best_audio_codec(sh_audio,audio_codec_list,audio_fm_list)){
545 sh_audio=d_audio->sh=NULL; // failed to init :(
546 }
547 mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
548 }
549
550 // set up video encoder:
551
552 if (vobsub_out) {
553 unsigned int palette[16], width, height;
554 unsigned char tmp[3] = { 0, 0, 0 };
555 if (spudec_ifo && vobsub_parse_ifo(NULL,spudec_ifo, palette, &width, &height, 1, dvdsub_id, tmp) >= 0)
556 vobsub_writer = vobsub_out_open(vobsub_out, palette, sh_video->disp_w, sh_video->disp_h,
557 vobsub_out_id?vobsub_out_id:(char *)tmp, vobsub_out_index);
558 #ifdef USE_DVDREAD
559 if (vobsub_writer == NULL) {
560 char tmp[3];
561 if (vobsub_out_id == NULL && stream->type == STREAMTYPE_DVD) {
562 int i;
563 dvd_priv_t *dvd = (dvd_priv_t*)stream->priv;
564 for (i = 0; i < dvd->nr_of_subtitles; ++i)
565 if (dvd->subtitles[i].id == dvdsub_id) {
566 tmp[0] = (dvd->subtitles[i].language >> 8) & 0xff;
567 tmp[1] = dvd->subtitles[i].language & 0xff;
568 tmp[2] = 0;
569 vobsub_out_id = tmp;
570 break;
571 }
572 }
573 vobsub_writer=vobsub_out_open(vobsub_out, stream->type==STREAMTYPE_DVD?((dvd_priv_t *)(stream->priv))->cur_pgc->palette:NULL,
574 sh_video->disp_w, sh_video->disp_h, vobsub_out_id, vobsub_out_index);
575 }
576 #endif
577 }
578 else {
579 if (spudec_ifo) {
580 unsigned int palette[16], width, height;
581 if (vobsub_parse_ifo(NULL,spudec_ifo, palette, &width, &height, 1, -1, NULL) >= 0)
582 vo_spudec=spudec_new_scaled(palette, sh_video->disp_w, sh_video->disp_h);
583 }
584 #ifdef USE_DVDREAD
585 if (vo_spudec==NULL) {
586 vo_spudec=spudec_new_scaled(stream->type==STREAMTYPE_DVD?((dvd_priv_t *)(stream->priv))->cur_pgc->palette:NULL,
587 sh_video->disp_w, sh_video->disp_h);
588 }
589 #endif
590 }
591
592 #ifdef USE_SUB
593 // after reading video params we should load subtitles because
594 // we know fps so now we can adjust subtitles time to ~6 seconds AST
595 // check .sub
596 // current_module="read_subtitles_file";
597 if(sub_name && sub_name[0]){
598 subdata=sub_read_file(sub_name[0], sh_video->fps);
599 if(!subdata) mp_msg(MSGT_CPLAYER,MSGL_ERR,MSGTR_CantLoadSub,sub_name[0]);
600 } else
601 if(sub_auto) { // auto load sub file ...
602 subdata=sub_read_file( filename ? sub_filenames( get_path("sub/"), filename )[0]
603 : "default.sub", sh_video->fps );
604 }
605 #endif
606
607 // Apply current settings for forced subs
608 spudec_set_forced_subs_only(vo_spudec,forced_subs_only);
609
610 // set up output file:
611 muxer_f=fopen(out_filename,"wb");
612 if(!muxer_f) {
613 printf(MSGTR_CannotOpenOutputFile, out_filename);
614 mencoder_exit(1,NULL);
615 }
616
617 muxer=muxer_new_muxer(out_file_format,muxer_f);
618
619 // ============= VIDEO ===============
620
621 mux_v=muxer_new_stream(muxer,MUXER_TYPE_VIDEO);
622
623 mux_v->buffer_size=0x200000; // 2MB
624 mux_v->buffer=malloc(mux_v->buffer_size);
625
626 mux_v->source=sh_video;
627
628 mux_v->h.dwSampleSize=0; // VBR
629 #ifdef USE_LIBAVCODEC
630 {
631 AVRational q= av_d2q(force_ofps?force_ofps:sh_video->fps, 30000);
632 mux_v->h.dwScale= q.den;
633 mux_v->h.dwRate = q.num;
634 }
635 #else
636 mux_v->h.dwScale=10000;
637 mux_v->h.dwRate=mux_v->h.dwScale*(force_ofps?force_ofps:sh_video->fps);
638 #endif
639
640 mux_v->codec=out_video_codec;
641
642 mux_v->bih=NULL;
643 sh_video->codec=NULL;
644 sh_video->video_out=NULL;
645 sh_video->vfilter=NULL; // fixme!
646
647 switch(mux_v->codec){
648 case VCODEC_COPY:
649 if (sh_video->bih)
650 mux_v->bih=sh_video->bih;
651 else
652 {
653 mux_v->bih=malloc(sizeof(BITMAPINFOHEADER));
654 mux_v->bih->biSize=sizeof(BITMAPINFOHEADER);
655 mux_v->bih->biWidth=sh_video->disp_w;
656 mux_v->bih->biHeight=sh_video->disp_h;
657 mux_v->bih->biCompression=sh_video->format;
658 mux_v->bih->biPlanes=1;
659 mux_v->bih->biBitCount=24; // FIXME!!!
660 mux_v->bih->biSizeImage=mux_v->bih->biWidth*mux_v->bih->biHeight*(mux_v->bih->biBitCount/8);
661 }
662 printf("videocodec: framecopy (%dx%d %dbpp fourcc=%x)\n",
663 mux_v->bih->biWidth, mux_v->bih->biHeight,
664 mux_v->bih->biBitCount, mux_v->bih->biCompression);
665 break;
666 case VCODEC_FRAMENO:
667 mux_v->bih=malloc(sizeof(BITMAPINFOHEADER));
668 mux_v->bih->biSize=sizeof(BITMAPINFOHEADER);
669 mux_v->bih->biWidth=sh_video->disp_w;
670 mux_v->bih->biHeight=sh_video->disp_h;
671 mux_v->bih->biPlanes=1;
672 mux_v->bih->biBitCount=24;
673 mux_v->bih->biCompression=mmioFOURCC('F','r','N','o');
674 mux_v->bih->biSizeImage=mux_v->bih->biWidth*mux_v->bih->biHeight*(mux_v->bih->biBitCount/8);
675 break;
676 default:
677
678 switch(mux_v->codec){
679 case VCODEC_DIVX4:
680 sh_video->vfilter=vf_open_encoder(NULL,"divx4",(char *)mux_v); break;
681 case VCODEC_LIBAVCODEC:
682 sh_video->vfilter=vf_open_encoder(NULL,"lavc",(char *)mux_v); break;
683 case VCODEC_RAW:
684 sh_video->vfilter=vf_open_encoder(NULL,"raw",(char *)mux_v); break;
685 case VCODEC_VFW:
686 sh_video->vfilter=vf_open_encoder(NULL,"vfw",(char *)mux_v); break;
687 case VCODEC_LIBDV:
688 sh_video->vfilter=vf_open_encoder(NULL,"libdv",(char *)mux_v); break;
689 case VCODEC_XVID:
690 sh_video->vfilter=vf_open_encoder(NULL,"xvid",(char *)mux_v); break;
691 case VCODEC_QTVIDEO:
692 sh_video->vfilter=vf_open_encoder(NULL,"qtvideo",(char *)mux_v); break;
693 case VCODEC_NUV:
694 sh_video->vfilter=vf_open_encoder(NULL,"nuv",(char *)mux_v); break;
695
696 }
697 if(!mux_v->bih || !sh_video->vfilter){
698 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_EncoderOpenFailed);
699 mencoder_exit(1,NULL);
700 }
701 // append 'expand' filter, it fixes stride problems and renders osd:
702 if (auto_expand) {
703 char* vf_args[] = { "osd", "1", NULL };
704 sh_video->vfilter=vf_open_filter(sh_video->vfilter,"expand",vf_args);
705 }
706 sh_video->vfilter=append_filters(sh_video->vfilter);
707
708 mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
709 init_best_video_codec(sh_video,video_codec_list,video_fm_list);
710 mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
711 if(!sh_video->inited) mencoder_exit(1,NULL);
712
713 }
714
715 /* force output fourcc to .. */
716 if ((force_fourcc != NULL) && (strlen(force_fourcc) >= 4))
717 {
718 mux_v->bih->biCompression = mmioFOURCC(force_fourcc[0], force_fourcc[1],
719 force_fourcc[2], force_fourcc[3]);
720 printf(MSGTR_ForcingOutputFourcc,
721 mux_v->bih->biCompression, (char *)&mux_v->bih->biCompression);
722 }
723
724 //if(demuxer->file_format!=DEMUXER_TYPE_AVI) pts_from_bps=0; // it must be 0 for mpeg/asf!
725
726 // ============= AUDIO ===============
727 if(sh_audio){
728
729 mux_a=muxer_new_stream(muxer,MUXER_TYPE_AUDIO);
730
731 mux_a->buffer_size=0x100000; //16384;
732 mux_a->buffer=malloc(mux_a->buffer_size);
733 if (!mux_a->buffer)
734 mencoder_exit(1,"memory allocation failed");
735
736 mux_a->source=sh_audio;
737
738 mux_a->codec=out_audio_codec;
739
740 switch(mux_a->codec){
741 case ACODEC_COPY:
742 if (sh_audio->wf){
743 mux_a->wf=sh_audio->wf;
744 if(!sh_audio->i_bps) sh_audio->i_bps=mux_a->wf->nAvgBytesPerSec;
745 } else {
746 mux_a->wf = malloc(sizeof(WAVEFORMATEX));
747 mux_a->wf->nBlockAlign = 1; //mux_a->h.dwSampleSize;
748 mux_a->wf->wFormatTag = sh_audio->format;
749 mux_a->wf->nChannels = sh_audio->channels;
750 mux_a->wf->nSamplesPerSec = sh_audio->samplerate;
751 mux_a->wf->nAvgBytesPerSec=sh_audio->i_bps; //mux_a->h.dwSampleSize*mux_a->wf->nSamplesPerSec;
752 mux_a->wf->wBitsPerSample = 16; // FIXME
753 mux_a->wf->cbSize=0; // FIXME for l3codeca.acm
754 }
755 if(sh_audio->audio.dwScale){
756 mux_a->h.dwSampleSize=sh_audio->audio.dwSampleSize;
757 mux_a->h.dwScale=sh_audio->audio.dwScale;
758 mux_a->h.dwRate=sh_audio->audio.dwRate;
759 // mux_a->h.dwStart=sh_audio->audio.dwStart;
760 } else {
761 mux_a->h.dwSampleSize=mux_a->wf->nBlockAlign;
762 mux_a->h.dwScale=mux_a->h.dwSampleSize;
763 mux_a->h.dwRate=mux_a->wf->nAvgBytesPerSec;
764 }
765 printf("audiocodec: framecopy (format=%x chans=%d rate=%ld bits=%d bps=%ld sample=%ld)\n",
766 mux_a->wf->wFormatTag, mux_a->wf->nChannels, mux_a->wf->nSamplesPerSec,
767 mux_a->wf->wBitsPerSample, mux_a->wf->nAvgBytesPerSec, mux_a->h.dwSampleSize);
768 break;
769 case ACODEC_PCM:
770 printf("CBR PCM audio selected\n");
771 mux_a->h.dwScale=1;
772 mux_a->h.dwRate=force_srate?force_srate:sh_audio->samplerate;
773 mux_a->wf=malloc(sizeof(WAVEFORMATEX));
774 mux_a->wf->wFormatTag=0x1; // PCM
775 mux_a->wf->nChannels=audio_output_channels?audio_output_channels:sh_audio->channels;
776 mux_a->h.dwSampleSize=2*mux_a->wf->nChannels;
777 mux_a->wf->nBlockAlign=mux_a->h.dwSampleSize;
778 mux_a->wf->nSamplesPerSec=mux_a->h.dwRate;
779 mux_a->wf->nAvgBytesPerSec=mux_a->h.dwSampleSize*mux_a->wf->nSamplesPerSec;
780 mux_a->wf->wBitsPerSample=16;
781 mux_a->wf->cbSize=0; // FIXME for l3codeca.acm
782 // setup filter:
783 if(!init_audio_filters(sh_audio,
784 sh_audio->samplerate,
785 sh_audio->channels, sh_audio->sample_format, sh_audio->samplesize,
786 mux_a->wf->nSamplesPerSec, mux_a->wf->nChannels,
787 (mux_a->wf->wBitsPerSample==8)? AFMT_U8:AFMT_S16_LE,
788 mux_a->wf->wBitsPerSample/8,
789 16384, mux_a->wf->nAvgBytesPerSec)){
790 mp_msg(MSGT_CPLAYER,MSGL_ERR,"Couldn't find matching filter / ao format!\n");
791 }
792 break;
793 #ifdef HAVE_MP3LAME
794 case ACODEC_VBRMP3:
795 printf("MP3 audio selected\n");
796 mux_a->h.dwSampleSize=0; // VBR
797 mux_a->h.dwRate=force_srate?force_srate:sh_audio->samplerate;
798 mux_a->h.dwScale=(mux_a->h.dwRate<32000)?576:1152; // samples/frame
799 if(sizeof(MPEGLAYER3WAVEFORMAT)!=30) mp_msg(MSGT_MENCODER,MSGL_WARN,"sizeof(MPEGLAYER3WAVEFORMAT)==%d!=30, maybe broken C compiler?\n",sizeof(MPEGLAYER3WAVEFORMAT));
800 mux_a->wf=malloc(sizeof(MPEGLAYER3WAVEFORMAT)); // should be 30
801 mux_a->wf->wFormatTag=0x55; // MP3
802 mux_a->wf->nChannels= (lame_param_mode<0) ? sh_audio->channels :
803 ((lame_param_mode==3) ? 1 : 2);
804 mux_a->wf->nSamplesPerSec=mux_a->h.dwRate;
805 mux_a->wf->nAvgBytesPerSec=192000/8; // FIXME!
806 mux_a->wf->nBlockAlign=(mux_a->h.dwRate<32000)?576:1152; // required for l3codeca.acm + WMP 6.4
807 mux_a->wf->wBitsPerSample=0; //16;
808 // from NaNdub: (requires for l3codeca.acm)
809 mux_a->wf->cbSize=12;
810 ((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->wID=1;
811 ((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->fdwFlags=2;
812 ((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->nBlockSize=(mux_a->h.dwRate<32000)?576:1152; // ???
813 ((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->nFramesPerBlock=1;
814 ((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->nCodecDelay=0;
815 // setup filter:
816 if(!init_audio_filters(sh_audio,
817 sh_audio->samplerate,
818 sh_audio->channels, sh_audio->sample_format, sh_audio->samplesize,
819 mux_a->wf->nSamplesPerSec, mux_a->wf->nChannels,
820 #ifdef WORDS_BIGENDIAN
821 AFMT_S16_BE, 2,
822 #else
823 AFMT_S16_LE, 2,
824 #endif
825 4608, mux_a->h.dwRate*mux_a->wf->nChannels*2)){
826 mp_msg(MSGT_CPLAYER,MSGL_ERR,"Couldn't find matching filter / ao format!\n");
827 }
828 break;
829 #endif
830 #ifdef USE_LIBAVCODEC
831 case ACODEC_LAVC:
832 if(!lavc_param_acodec)
833 {
834 mp_msg(MSGT_MENCODER, MSGL_FATAL, "Audio LAVC, Missing codec name!\n");
835 exit(1);
836 }
837
838 if(!avcodec_inited){
839 avcodec_init();
840 avcodec_register_all();
841 avcodec_inited=1;
842 }
843
844 lavc_acodec = avcodec_find_encoder_by_name(lavc_param_acodec);
845 if (!lavc_acodec)
846 {
847 mp_msg(MSGT_MENCODER, MSGL_FATAL, "Audio LAVC, couldn't find encoder for codec %s\n", lavc_param_acodec);
848 exit(1);
849 }
850
851 lavc_actx = avcodec_alloc_context();
852 if(lavc_actx == NULL)
853 {
854 mp_msg(MSGT_MENCODER, MSGL_FATAL, "Audio LAVC, couldn't allocate context!\n");
855 exit(1);
856 }
857
858 if(lavc_param_atag == 0)
859 lavc_param_atag = lavc_find_atag(lavc_param_acodec);
860
861 // put sample parameters
862 lavc_actx->channels = audio_output_channels ? audio_output_channels : sh_audio->channels;
863 lavc_actx->sample_rate = force_srate ? force_srate : sh_audio->samplerate;
864 lavc_actx->bit_rate = lavc_param_abitrate * 1000;
865
866 /*
867 * Special case for imaadpcm.
868 * The bitrate is only dependant on samplerate.
869 * We have to known frame_size and block_align in advance,
870 * so I just copied the code from libavcodec/adpcm.c
871 *
872 * However, ms imaadpcm uses a block_align of 2048,
873 * lavc defaults to 1024
874 */
875 if(lavc_param_atag == 0x11) {
876 int blkalign = 2048;
877 int framesize = (blkalign - 4 * lavc_actx->channels) * 8 / (4 * lavc_actx->channels) + 1;
878 lavc_actx->bit_rate = lavc_actx->sample_rate*8*blkalign/framesize;
879 }
880
881 if(avcodec_open(lavc_actx, lavc_acodec) < 0)
882 {
883 mp_msg(MSGT_MENCODER, MSGL_FATAL, "Couldn't open codec %s, br=%d\n", lavc_param_acodec, lavc_param_abitrate);
884 exit(1);
885 }
886
887 if(lavc_param_atag == 0x11) {
888 lavc_actx->block_align = 2048;
889 lavc_actx->frame_size = (lavc_actx->block_align - 4 * lavc_actx->channels) * 8 / (4 * lavc_actx->channels) + 1;
890 }
891
892 lavc_abuf = malloc(lavc_actx->frame_size * 2 * lavc_actx->channels);
893 if(lavc_abuf == NULL)
894 {
895 fprintf(stderr, "Couldn't allocate %d bytes\n", lavc_actx->frame_size * 2 * lavc_actx->channels);
896 exit(1);
897 }
898
899 mux_a->wf = malloc(sizeof(WAVEFORMATEX)+lavc_actx->extradata_size+256);
900 mux_a->wf->wFormatTag = lavc_param_atag;
901 mux_a->wf->nChannels = lavc_actx->channels;
902 mux_a->wf->nSamplesPerSec = lavc_actx->sample_rate;
903 mux_a->wf->nAvgBytesPerSec = (lavc_actx->bit_rate / 8);
904 mux_a->h.dwRate = mux_a->wf->nAvgBytesPerSec;
905 if (lavc_actx->block_align) {
906 mux_a->h.dwSampleSize = mux_a->h.dwScale = lavc_actx->block_align;
907 } else {
908 mux_a->h.dwScale = (mux_a->wf->nAvgBytesPerSec * lavc_actx->frame_size)/ mux_a->wf->nSamplesPerSec; /* for cbr */
909
910 if ((mux_a->wf->nAvgBytesPerSec *
911 lavc_actx->frame_size) % mux_a->wf->nSamplesPerSec) {
912 mux_a->h.dwScale = lavc_actx->frame_size;
913 mux_a->h.dwRate = lavc_actx->sample_rate;
914 mux_a->h.dwSampleSize = 0; // Blocksize not constant
915 } else {
916 mux_a->h.dwSampleSize = mux_a->h.dwScale;
917 }
918 }
919 mux_a->wf->nBlockAlign = mux_a->h.dwScale;
920 mux_a->h.dwSuggestedBufferSize = audio_preload*mux_a->wf->nAvgBytesPerSec;
921 mux_a->h.dwSuggestedBufferSize -= mux_a->h.dwSuggestedBufferSize % mux_a->wf->nBlockAlign;
922
923 switch (lavc_param_atag) {
924 case 0x11: /* imaadpcm */
925 mux_a->wf->wBitsPerSample = 4;
926 mux_a->wf->cbSize = 2;
927 /*
928 * Magic imaadpcm values, currently probably only valid
929 * for 48KHz Stereo
930 */
931 ((unsigned char*)mux_a->wf)[sizeof(WAVEFORMATEX)] = 0xf9;
932 ((unsigned char*)mux_a->wf)[sizeof(WAVEFORMATEX)+1] = 0x07;
933 break;
934 case 0x55: /* mp3 */
935 mux_a->wf->cbSize = 12;
936 mux_a->wf->wBitsPerSample = 0; /* does not apply */
937 ((MPEGLAYER3WAVEFORMAT *) (mux_a->wf))->wID = 1;
938 ((MPEGLAYER3WAVEFORMAT *) (mux_a->wf))->fdwFlags = 2;
939 ((MPEGLAYER3WAVEFORMAT *) (mux_a->wf))->nBlockSize = mux_a->wf->nBlockAlign;
940 ((MPEGLAYER3WAVEFORMAT *) (mux_a->wf))->nFramesPerBlock = 1;
941 ((MPEGLAYER3WAVEFORMAT *) (mux_a->wf))->nCodecDelay = 0;
942 break;
943 default:
944 mux_a->wf->wBitsPerSample = 0; /* Unknown */
945 if (lavc_actx->extradata && (lavc_actx->extradata_size > 0))
946 {
947 memcpy(mux_a->wf+sizeof(WAVEFORMATEX), lavc_actx->extradata,
948 lavc_actx->extradata_size);
949 mux_a->wf->cbSize = lavc_actx->extradata_size;
950 }
951 else
952 mux_a->wf->cbSize = 0;
953 break;
954 }
955
956 // Fix allocation
957 mux_a->wf = realloc(mux_a->wf, sizeof(WAVEFORMATEX)+mux_a->wf->cbSize);
958
959 // setup filter:
960 if (!init_audio_filters(
961 sh_audio,
962 sh_audio->samplerate, sh_audio->channels,
963 sh_audio->sample_format, sh_audio->samplesize,
964 mux_a->wf->nSamplesPerSec, mux_a->wf->nChannels,
965 AFMT_S16_NE, 2,
966 mux_a->h.dwSuggestedBufferSize,
967 mux_a->h.dwSuggestedBufferSize*2)) {
968 mp_msg(MSGT_CPLAYER, MSGL_ERR, "Couldn't find matching filter / ao format!\n");
969 exit(1);
970 }
971
972 mp_msg(MSGT_MENCODER, MSGL_V, "FRAME_SIZE: %d, BUFFER_SIZE: %d, TAG: 0x%x\n", lavc_actx->frame_size, lavc_actx->frame_size * 2 * lavc_actx->channels, mux_a->wf->wFormatTag);
973
974 break;
975 #endif
976 }
977
978 if (verbose>1) print_wave_header(mux_a->wf);
979
980 if(audio_delay!=0.0){
981 mux_a->h.dwStart=audio_delay*mux_a->h.dwRate/mux_a->h.dwScale;
982 printf("Setting AUDIO DELAY to %5.3f\n",mux_a->h.dwStart*mux_a->h.dwScale/(float)mux_a->h.dwRate);
983 }
984
985 } // if(sh_audio)
986
987 printf(MSGTR_WritingAVIHeader);
988 if (muxer->cont_write_header) muxer_write_header(muxer);
989
990 decoded_frameno=0;
991
992 if(sh_audio)
993 switch(mux_a->codec){
994 #ifdef HAVE_MP3LAME
995 case ACODEC_VBRMP3:
996
997 lame=lame_init();
998 lame_set_bWriteVbrTag(lame,0);
999 lame_set_in_samplerate(lame,mux_a->wf->nSamplesPerSec);
1000 //lame_set_in_samplerate(lame,sh_audio->samplerate); // if resampling done by lame
1001 lame_set_num_channels(lame,mux_a->wf->nChannels);
1002 lame_set_out_samplerate(lame,mux_a->wf->nSamplesPerSec);
1003 lame_set_quality(lame,lame_param_algqual); // 0 = best q
1004 if(lame_param_vbr){ // VBR:
1005 lame_set_VBR(lame,lame_param_vbr); // vbr mode
1006 lame_set_VBR_q(lame,lame_param_quality+1); // 1 = best vbr q 6=~128k
1007 if(lame_param_br>0) lame_set_VBR_mean_bitrate_kbps(lame,lame_param_br);
1008 } else { // CBR:
1009 if(lame_param_br>0) lame_set_brate(lame,lame_param_br);
1010 }
1011 if(lame_param_mode>=0) lame_set_mode(lame,lame_param_mode); // j-st
1012 if(lame_param_ratio>0) lame_set_compression_ratio(lame,lame_param_ratio);
1013 if(lame_param_scale>0) {
1014 printf("Setting audio input gain to %f\n", lame_param_scale);
1015 lame_set_scale(lame,lame_param_scale);
1016 }
1017 if(lame_param_lowpassfreq>=-1) lame_set_lowpassfreq(lame,lame_param_lowpassfreq);
1018 if(lame_param_highpassfreq>=-1) lame_set_highpassfreq(lame,lame_param_highpassfreq);
1019 #if HAVE_MP3LAME >= 392
1020 if(lame_param_preset != NULL){
1021 printf ("\npreset=%s\n\n",lame_param_preset);
1022 lame_presets_set(lame,lame_param_fast, (lame_param_vbr==0), lame_param_preset);
1023 }
1024 #endif
1025 lame_init_params(lame);
1026 if(verbose>0){
1027 lame_print_config(lame);
1028 lame_print_internals(lame);
1029 }
1030 break;
1031 #endif
1032 }
1033
1034 signal(SIGINT,exit_sighandler); // Interrupt from keyboard
1035 signal(SIGQUIT,exit_sighandler); // Quit from keyboard
1036 signal(SIGTERM,exit_sighandler); // kill
1037
1038 timer_start=GetTimerMS();
1039
1040 if (seek_to_sec) {
1041 int a,b; float d;
1042
1043 if (sscanf(seek_to_sec, "%d:%d:%f", &a,&b,&d)==3)
1044 d += 3600*a + 60*b;
1045 else if (sscanf(seek_to_sec, "%d:%f", &a, &d)==2)
1046 d += 60*a;
1047 else
1048 sscanf(seek_to_sec, "%f", &d);
1049
1050 demux_seek(demuxer, d, 1);
1051 // there is 2 way to handle the -ss option in 3-pass mode:
1052 // > 1. do the first pass for the whole file, and use -ss for 2nd/3rd pases only
1053 // > 2. do all the 3 passes with the same -ss value
1054 // this line enables behaviour 1. (and kills 2. at the same time):
1055 // if(demuxer2) demux_seek(demuxer2, d, 1);
1056 }
1057
1058 if (out_file_format == MUXER_TYPE_MPEG)
1059 {
1060 if (audio_preload > 0.4) {
1061 fprintf(stderr,"Limiting audio preload to 0.4s\n");
1062 audio_preload = 0.4;
1063 }
1064 if (audio_density < 4) {
1065 fprintf(stderr,"Increasing audio density to 4\n");
1066 audio_density = 4;
1067 }
1068 }
1069
1070 if(file_format == DEMUXER_TYPE_TV)
1071 {
1072 fprintf(stderr,"Forcing audio preload to 0, max pts correction to 0\n");
1073 audio_preload = 0.0;
1074 default_max_pts_correction = 0;
1075 }
1076
1077 play_n_frames=play_n_frames_mf;
1078
1079 while(!at_eof){
1080
1081 float frame_time=0;
1082 int blit_frame=0;
1083 float a_pts=0;
1084 float v_pts=0;
1085 unsigned char* start=NULL;
1086 int in_size;
1087 int skip_flag=0; // 1=skip -1=duplicate
1088
1089 if((end_at_type == END_AT_SIZE && end_at <= ftello(muxer_f)) ||
1090 (end_at_type == END_AT_TIME && end_at < sh_video->timer))
1091 break;
1092
1093 if(play_n_frames>=0){
1094 --play_n_frames;
1095 if(play_n_frames<0) break;
1096 }
1097
1098 if(sh_audio){
1099 // get audio:
1100 while(mux_a->timer-audio_preload<mux_v->timer){
1101 int len=0;
1102
1103 ptimer_start = GetTimerMS();
1104
1105 #ifdef USE_LIBAVCODEC
1106 if(mux_a->codec == ACODEC_LAVC){
1107 int size, rd_len;
1108
1109 size = lavc_actx->frame_size * 2 * mux_a->wf->nChannels;
1110
1111 rd_len = dec_audio(sh_audio, lavc_abuf, size);
1112 if(rd_len != size)
1113 break;
1114
1115 // Encode one frame
1116 mux_a->buffer_len += avcodec_encode_audio(lavc_actx, mux_a->buffer + mux_a->buffer_len, size, lavc_abuf);
1117 if (mux_a->h.dwSampleSize) { /* CBR */
1118 /*
1119 * work around peculiar lame behaviour
1120 */
1121 if (mux_a->buffer_len < mux_a->wf->nBlockAlign) {
1122 len = 0;
1123 } else {
1124 len = mux_a->wf->nBlockAlign*(mux_a->buffer_len/mux_a->wf->nBlockAlign);
1125 }
1126 } else { /* VBR */
1127 len = mux_a->buffer_len;
1128 }
1129 if (mux_v->timer == 0) mux_a->h.dwInitialFrames++;
1130 }
1131 #endif
1132 if(mux_a->h.dwSampleSize){
1133 // CBR - copy 0.5 sec of audio
1134 switch(mux_a->codec){
1135 case ACODEC_COPY: // copy
1136 len=mux_a->wf->nAvgBytesPerSec/audio_density;
1137 len/=mux_a->h.dwSampleSize;if(len<1) len=1;
1138 len*=mux_a->h.dwSampleSize;
1139 len=demux_read_data(sh_audio->ds,mux_a->buffer,len);
1140 break;
1141 case ACODEC_PCM:
1142 len=mux_a->h.dwSampleSize*(mux_a->h.dwRate/audio_density);
1143 len=dec_audio(sh_audio,mux_a->buffer,len);
1144 break;
1145 }
1146 } else {
1147 // VBR - encode/copy an audio frame
1148 switch(mux_a->codec){
1149 case ACODEC_COPY: // copy
1150 len=ds_get_packet(sh_audio->ds,(unsigned char**) &mux_a->buffer);
1151 // printf("VBR audio framecopy not yet implemented!\n");
1152 break;
1153 #ifdef HAVE_MP3LAME
1154 case ACODEC_VBRMP3:
1155 while(mux_a->buffer_len<4){
1156 unsigned char tmp[2304];
1157 int len=dec_audio(sh_audio,tmp,2304);
1158 if(len<=0) break; // eof
1159 /* mono encoding, a bit tricky */
1160 if (mux_a->wf->nChannels == 1)
1161 {
1162 len = lame_encode_buffer(lame, (short *)tmp, (short *)tmp, len/2,
1163 mux_a->buffer+mux_a->buffer_len, mux_a->buffer_size-mux_a->buffer_len);
1164 }
1165 else
1166 {
1167 len=lame_encode_buffer_interleaved(lame,
1168 (short *)tmp,len/4,
1169 mux_a->buffer+mux_a->buffer_len,mux_a->buffer_size-mux_a->buffer_len);
1170 }
1171 if(len<0) break; // error
1172 mux_a->buffer_len+=len;
1173 }
1174 if(mux_a->buffer_len<4) break;
1175 len=mp_decode_mp3_header(mux_a->buffer);
1176 //printf("%d\n",len);
1177 if(len<=0) break; // bad frame!
1178 // printf("[%d]\n",mp_mp3_get_lsf(mux_a->buffer));
1179 while(mux_a->buffer_len<len){
1180 unsigned char tmp[2304];
1181 int len=dec_audio(sh_audio,tmp,2304);
1182 if(len<=0) break; // eof
1183 /* mono encoding, a bit tricky */
1184 if (mux_a->wf->nChannels == 1)
1185 {
1186 len = lame_encode_buffer(lame, (short *)tmp, (short *)tmp, len/2,
1187 mux_a->buffer+mux_a->buffer_len, mux_a->buffer_size-mux_a->buffer_len);
1188 }
1189 else
1190 {
1191 len=lame_encode_buffer_interleaved(lame,
1192 (short *)tmp,len/4,
1193 mux_a->buffer+mux_a->buffer_len,mux_a->buffer_size-mux_a->buffer_len);
1194 }
1195 if(len<0) break; // error
1196 mux_a->buffer_len+=len;
1197 }
1198 break;
1199 #endif
1200 }
1201 }
1202 if(len<=0) break; // EOF?
1203 muxer_write_chunk(mux_a,len,0x10);
1204 if(!mux_a->h.dwSampleSize && mux_a->timer>0)
1205 mux_a->wf->nAvgBytesPerSec=0.5f+(double)mux_a->size/mux_a->timer; // avg bps (VBR)
1206 if(mux_a->buffer_len>=len){
1207 mux_a->buffer_len-=len;
1208 memcpy(mux_a->buffer,mux_a->buffer+len,mux_a->buffer_len);
1209 }
1210
1211
1212 audiosamples++;
1213 audiorate+= (GetTimerMS() - ptimer_start);
1214 }
1215 }
1216
1217 // get video frame!
1218
1219 in_size=video_read_frame(sh_video,&frame_time,&start,force_fps);
1220 if(in_size<0){ at_eof=1; break; }
1221 sh_video->timer+=frame_time; ++decoded_frameno;
1222
1223 v_timer_corr-=frame_time-(float)mux_v->h.dwScale/mux_v->h.dwRate;
1224
1225 if(demuxer2){ // 3-pass encoding, read control file (frameno.avi)
1226 // find our frame:
1227 while(next_frameno<decoded_frameno){
1228 int* start;
1229 int len=ds_get_packet(demuxer2->video,(unsigned char**) &start);
1230 if(len<0){ at_eof=1;break;}
1231 if(len==0) --skip_flag; else // duplicate
1232 if(len==4) next_frameno=start[0];
1233 }
1234 if(at_eof) break;
1235 // if(skip_flag) printf("!!!!!!!!!!!!\n");
1236 skip_flag=next_frameno-decoded_frameno;
1237 // find next frame:
1238 while(next_frameno<=decoded_frameno){
1239 int* start;
1240 int len=ds_get_packet(demuxer2->video,(unsigned char**) &start);
1241 if(len<0){ at_eof=1;break;}
1242 if(len==0) --skip_flag; else // duplicate
1243 if(len==4) next_frameno=start[0];
1244 }
1245 // if(at_eof) break;
1246 // printf("Current fno=%d requested=%d skip=%d \n",decoded_frameno,fno,skip_flag);
1247 } else {
1248
1249 // check frame duplicate/drop:
1250
1251 //printf("\r### %5.3f ###\n",v_timer_corr);
1252
1253 if(v_timer_corr>=(float)mux_v->h.dwScale/mux_v->h.dwRate &&
1254 (skip_limit<0 || skip_flag<skip_limit) ){
1255 v_timer_corr-=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1256 ++skip_flag; // skip
1257 } else
1258 while(v_timer_corr<=-(float)mux_v->h.dwScale/mux_v->h.dwRate &&
1259 (skip_limit<0 || (-skip_flag)<skip_limit) ){
1260 v_timer_corr+=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1261 --skip_flag; // dup
1262 }
1263
1264 while( (v_pts_corr<=-(float)mux_v->h.dwScale/mux_v->h.dwRate && skip_flag>0)
1265 || (v_pts_corr<=-2*(float)mux_v->h.dwScale/mux_v->h.dwRate) ){
1266 v_pts_corr+=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1267 --skip_flag; // dup
1268 }
1269 if( (v_pts_corr>=(float)mux_v->h.dwScale/mux_v->h.dwRate && skip_flag<0)
1270 || (v_pts_corr>=2*(float)mux_v->h.dwScale/mux_v->h.dwRate) )
1271 if(skip_flag<=0){ // we can't skip more than 1 frame now
1272 v_pts_corr-=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1273 ++skip_flag; // skip
1274 }
1275
1276 } // demuxer2
1277
1278 ptimer_start = GetTimerMS();
1279
1280 switch(mux_v->codec){
1281 case VCODEC_COPY:
1282 mux_v->buffer=start;
1283 if(skip_flag<=0) muxer_write_chunk(mux_v,in_size,(sh_video->ds->flags&1)?0x10:0);
1284 break;
1285 case VCODEC_FRAMENO:
1286 mux_v->buffer=(unsigned char *)&decoded_frameno; // tricky
1287 if(skip_flag<=0) muxer_write_chunk(mux_v,sizeof(int),0x10);
1288 break;
1289 default:
1290 // decode_video will callback down to ve_*.c encoders, through the video filters
1291 blit_frame=decode_video(sh_video,start,in_size,(skip_flag>0)?1:0);
1292 if(!blit_frame){
1293 badframes++;
1294 if(skip_flag<=0){
1295 // unwanted skipping of a frame, what to do?
1296 if(skip_limit==0){
1297 // skipping not allowed -> write empty frame:
1298 muxer_write_chunk(mux_v,0,0);
1299 } else {
1300 // skipping allowed -> skip it and distriubute timer error:
1301 v_timer_corr-=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1302 }
1303 }
1304 }
1305 }
1306
1307 videosamples++;
1308 videorate+=(GetTimerMS() - ptimer_start);
1309
1310 if(skip_flag<0){
1311 // duplicate frame
1312 if(file_format != DEMUXER_TYPE_TV && !verbose) printf(MSGTR_DuplicateFrames,-skip_flag);
1313 while(skip_flag<0){
1314 duplicatedframes++;
1315 muxer_write_chunk(mux_v,0,0);
1316 ++skip_flag;
1317 }
1318 } else
1319 if(skip_flag>0){
1320 // skip frame
1321 if(file_format != DEMUXER_TYPE_TV && !verbose) printf(MSGTR_SkipFrame);
1322 skippedframes++;
1323 --skip_flag;
1324 }
1325
1326 if(sh_audio && !demuxer2){
1327 float AV_delay,x;
1328 // A-V sync!
1329 #if 0
1330 if(pts_from_bps){
1331 unsigned int samples=(sh_audio->audio.dwSampleSize)?
1332 ((ds_tell(d_audio)-sh_audio->a_in_buffer_len)/sh_audio->audio.dwSampleSize) :
1333 (d_audio->block_no); // <- used for VBR audio
1334 // printf("samples=%d \n",samples);
1335 a_pts=samples*(float)sh_audio->audio.dwScale/(float)sh_audio->audio.dwRate;
1336 delay_corrected=1;
1337 } else
1338 #endif
1339 {
1340 // PTS = (last timestamp) + (bytes after last timestamp)/(bytes per sec)
1341 a_pts=d_audio->pts;
1342 if(!delay_corrected) if(a_pts) delay_corrected=1;
1343 //printf("*** %5.3f ***\n",a_pts);
1344 a_pts+=(ds_tell_pts(d_audio)-sh_audio->a_in_buffer_len)/(float)sh_audio->i_bps;
1345 }
1346 v_pts=sh_video ? sh_video->pts : d_video->pts;
1347 // av = compensated (with out buffering delay) A-V diff
1348 AV_delay=(a_pts-v_pts); AV_delay-=mux_a->timer-(mux_v->timer-(v_timer_corr+v_pts_corr));
1349 // compensate input video timer by av:
1350 x=AV_delay*0.1f;
1351 if(x<-max_pts_correction) x=-max_pts_correction; else
1352 if(x> max_pts_correction) x= max_pts_correction;
1353 if(default_max_pts_correction>=0)
1354 max_pts_correction=default_max_pts_correction;
1355 else
1356 max_pts_correction=sh_video->frametime*0.10; // +-10% of time
1357 // sh_video->timer-=x;
1358 c_total+=x;
1359 v_pts_corr+=x;
1360 }
1361
1362 // printf("A:%6.1f V:%6.1f A-V:%7.3f oAV:%7.3f diff:%7.3f ct:%7.3f vpc:%7.3f \r",
1363 // a_pts,v_pts,a_pts-v_pts,
1364 // (float)(mux_a->timer-mux_v->timer),
1365 // AV_delay, c_total, v_pts_corr );
1366 // printf("V:%6.1f \r", d_video->pts );
1367
1368 #if 0
1369 mp_msg(MSGT_AVSYNC,MSGL_STATUS,"A:%6.1f V:%6.1f A-V:%7.3f ct:%7.3f %3d/%3d %2d%% %2d%% %4.1f%% %d%%\r",
1370 a_pts,v_pts,a_pts-v_pts,c_total,
1371 (int)sh_video->num_frames,(int)sh_video->num_frames_decoded,
1372 (sh_video->timer>0.5)?(int)(100.0*video_time_usage/(double)sh_video->timer):0,
1373 (sh_video->timer>0.5)?(int)(100.0*vout_time_usage/(double)sh_video->timer):0,
1374 (sh_video->timer>0.5)?(100.0*audio_time_usage/(double)sh_video->timer):0
1375 ,cache_fill_status
1376 );
1377 #endif
1378
1379 { float t=(GetTimerMS()-timer_start)*0.001f;
1380 float len=(demuxer->movi_end-demuxer->movi_start);
1381 float p=len>1000 ? (float)(demuxer->filepos-demuxer->movi_start) / len : 0;
1382 #if 0
1383 if(!len && sh_audio && sh_audio->audio.dwLength>100){
1384 p=(sh_audio->audio.dwSampleSize? ds_tell(sh_audio->ds)/sh_audio->audio.dwSampleSize : sh_audio->ds->block_no)
1385 / (float)(sh_audio->audio.dwLength);
1386 }
1387 #endif
1388 #if 0
1389 mp_msg(MSGT_AVSYNC,MSGL_STATUS,"%d < %d < %d \r",
1390 (int)demuxer->movi_start,
1391 (int)demuxer->filepos,
1392 (int)demuxer->movi_end);
1393 #else
1394 if(!quiet) {
1395 if(verbose>0) {
1396 mp_msg(MSGT_AVSYNC,MSGL_STATUS,"Pos:%6.1fs %6df (%2d%%) %3dfps Trem:%4dmin %3dmb A-V:%5.3f [%d:%d] A/Vms %d/%d D/B/S %d/%d/%d \r",
1397 mux_v->timer, decoded_frameno, (int)(p*100),
1398 (t>1) ? (int)(decoded_frameno/t+0.5) : 0,
1399 (p>0.001) ? (int)((t/p-t)/60) : 0,
1400 (p>0.001) ? (int)(ftello(muxer_f)/p/1024/1024) : 0,
1401 v_pts_corr,
1402 (mux_v->timer>1) ? (int)(mux_v->size/mux_v->timer/125) : 0,
1403 (mux_a && mux_a->timer>1) ? (int)(mux_a->size/mux_a->timer/125) : 0,
1404 audiorate/audiosamples, videorate/videosamples,
1405 duplicatedframes, badframes, skippedframes
1406 );
1407 } else
1408 mp_msg(MSGT_AVSYNC,MSGL_STATUS,"Pos:%6.1fs %6df (%2d%%) %3dfps Trem:%4dmin %3dmb A-V:%5.3f [%d:%d]\r",
1409 mux_v->timer, decoded_frameno, (int)(p*100),
1410 (t>1) ? (int)(decoded_frameno/t+0.5) : 0,
1411 (p>0.001) ? (int)((t/p-t)/60) : 0,
1412 (p>0.001) ? (int)(ftello(muxer_f)/p/1024/1024) : 0,
1413 v_pts_corr,
1414 (mux_v->timer>1) ? (int)(mux_v->size/mux_v->timer/125) : 0,
1415 (mux_a && mux_a->timer>1) ? (int)(mux_a->size/mux_a->timer/125) : 0
1416 );
1417 }
1418 #endif
1419 }
1420 fflush(stdout);
1421
1422 #ifdef USE_SUB
1423 // find sub
1424 if(subdata && sh_video->pts>0){
1425 float pts=sh_video->pts;
1426 if(sub_fps==0) sub_fps=sh_video->fps;
1427 if (pts > sub_last_pts || pts < sub_last_pts-1.0 ) {
1428 find_sub(subdata, (pts+sub_delay) *
1429 (subdata->sub_uses_time? 100. : sub_fps));
1430 // FIXME! frame counter...
1431 sub_last_pts = pts;
1432 }
1433 }
1434 #endif
1435
1436 #ifdef USE_DVDREAD
1437 // DVD sub:
1438 if(vo_spudec||vobsub_writer){
1439 unsigned char* packet=NULL;
1440 int len;
1441 while((len=ds_get_packet_sub(d_dvdsub,&packet))>0){
1442 mp_msg(MSGT_MENCODER,MSGL_V,"\rDVD sub: len=%d v_pts=%5.3f s_pts=%5.3f \n",len,sh_video->pts,d_dvdsub->pts);
1443 if (vo_spudec)
1444 spudec_assemble(vo_spudec,packet,len,90000*d_dvdsub->pts);
1445 if (vobsub_writer)
1446 vobsub_out_output(vobsub_writer,packet,len,mux_v->timer + d_dvdsub->pts - sh_video->pts);
1447 }
1448 if (vo_spudec) {
1449 spudec_heartbeat(vo_spudec,90000*sh_video->pts);
1450 vo_osd_changed(OSDTYPE_SPU);
1451 }
1452 }
1453 #endif
1454
1455 if(ferror(muxer_f)) {
1456 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_ErrorWritingFile, out_filename);
1457 mencoder_exit(1, NULL);
1458 }
1459
1460 } // while(!at_eof)
1461
1462 #ifdef HAVE_MP3LAME
1463 // fixup CBR mp3 audio header:
1464 if(sh_audio && mux_a->codec==ACODEC_VBRMP3 && !lame_param_vbr){
1465 mux_a->h.dwSampleSize=1;
1466 ((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->nBlockSize=
1467 (mux_a->size+(mux_a->h.dwLength>>1))/mux_a->h.dwLength;
1468 mux_a->h.dwLength=mux_a->size;
1469 mux_a->h.dwRate=mux_a->wf->nAvgBytesPerSec;
1470 mux_a->h.dwScale=1;
1471 mux_a->wf->nBlockAlign=1;
1472 printf("\n\nCBR audio: %ld bytes/sec, %d bytes/block\n",
1473 mux_a->h.dwRate,((MPEGLAYER3WAVEFORMAT*)(mux_a->wf))->nBlockSize);
1474 }
1475 #endif
1476
1477 printf(MSGTR_WritingAVIIndex);
1478 if (muxer->cont_write_index) muxer_write_index(muxer);
1479 muxer_f_size=ftello(muxer_f);
1480 printf(MSGTR_FixupAVIHeader);
1481 fseek(muxer_f,0,SEEK_SET);
1482 if (muxer->cont_write_header) muxer_write_header(muxer); // update header
1483 if(ferror(muxer_f) || fclose(muxer_f) != 0) {
1484 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_ErrorWritingFile, out_filename);
1485 mencoder_exit(1, NULL);
1486 }
1487 if(vobsub_writer)
1488 vobsub_out_close(vobsub_writer);
1489
1490 if(out_video_codec==VCODEC_FRAMENO && mux_v->timer>100){
1491 printf(MSGTR_RecommendedVideoBitrate,"650MB",(int)((650*1024*1024-muxer_f_size)/mux_v->timer/125));
1492 printf(MSGTR_RecommendedVideoBitrate,"700MB",(int)((700*1024*1024-muxer_f_size)/mux_v->timer/125));
1493 printf(MSGTR_RecommendedVideoBitrate,"800MB",(int)((800*1024*1024-muxer_f_size)/mux_v->timer/125));
1494 printf(MSGTR_RecommendedVideoBitrate,"2 x 650MB",(int)((2*650*1024*1024-muxer_f_size)/mux_v->timer/125));
1495 printf(MSGTR_RecommendedVideoBitrate,"2 x 700MB",(int)((2*700*1024*1024-muxer_f_size)/mux_v->timer/125));
1496 printf(MSGTR_RecommendedVideoBitrate,"2 x 800MB",(int)((2*800*1024*1024-muxer_f_size)/mux_v->timer/125));
1497 }
1498
1499 printf(MSGTR_VideoStreamResult,
1500 (float)(mux_v->size/mux_v->timer*8.0f/1000.0f), (int)(mux_v->size/mux_v->timer), (int)mux_v->size, (float)mux_v->timer, decoded_frameno);
1501 if(sh_audio)
1502 printf(MSGTR_AudioStreamResult,
1503 (float)(mux_a->size/mux_a->timer*8.0f/1000.0f), (int)(mux_a->size/mux_a->timer), (int)mux_a->size, (float)mux_a->timer);
1504
1505 if(sh_video){ uninit_video(sh_video);sh_video=NULL; }
1506 if(demuxer) free_demuxer(demuxer);
1507 if(stream) free_stream(stream); // kill cache thread
1508
1509 #ifdef USE_LIBAVCODEC
1510 if(lavc_abuf != NULL)
1511 free(lavc_abuf);
1512 #endif
1513
1514 return interrupted;
1515 }
1516
1517 static int parse_end_at(m_option_t *conf, const char* param)
1518 {
1519
1520 end_at_type = END_AT_NONE;
1521
1522 /* End at size parsing */
1523 {
1524 char unit[4];
1525
1526 end_at_type = END_AT_SIZE;
1527
1528 if(sscanf(param, "%lf%3s", &end_at, unit) == 2) {
1529 if(!strcasecmp(unit, "b"))
1530 ;
1531 else if(!strcasecmp(unit, "kb"))
1532 end_at *= 1024;
1533 else if(!strcasecmp(unit, "mb"))
1534 end_at *= 1024*1024;
1535 else
1536 end_at_type = END_AT_NONE;
1537 }
1538 else
1539 end_at_type = END_AT_NONE;
1540 }
1541
1542 /* End at time parsing. This has to be last because of
1543 * sscanf("%f", ...) below */
1544 if(end_at_type == END_AT_NONE)
1545 {
1546 int a,b; float d;
1547
1548 end_at_type = END_AT_TIME;
1549
1550 if (sscanf(param, "%d:%d:%f", &a, &b, &d) == 3)
1551 end_at = 3600*a + 60*b + d;
1552 else if (sscanf(param, "%d:%f", &a, &d) == 2)
1553 end_at = 60*a + d;
1554 else if (sscanf(param, "%f", &d) == 1)
1555 end_at = d;
1556 else
1557 end_at_type = END_AT_NONE;
1558 }
1559
1560 if(end_at_type == END_AT_NONE)
1561 return ERR_FUNC_ERR;
1562
1563 return 1;
1564 }
1565
1566 #if 0
1567 /* Flip the image in src and store the result in dst. src and dst may overlap.
1568 width is the size of each line in bytes. */
1569 static uint8_t* flip_upside_down(uint8_t* dst, const uint8_t* src, int width,
1570 int height)
1571 {
1572 uint8_t* tmp = malloc(width);
1573 int i;
1574
1575 for(i = 0; i < height/2; i++) {
1576 memcpy(tmp, &src[i*width], width);
1577 memcpy(&dst[i * width], &src[(height - i) * width], width);
1578 memcpy(&dst[(height - i) * width], tmp, width);
1579 }
1580
1581 free(tmp);
1582 return dst;
1583 }
1584 #endif
1585
1586 #if HAVE_MP3LAME >= 392
1587 /* lame_presets_set
1588 taken out of presets_set in lame-3.93.1/frontend/parse.c and modified */
1589 static int lame_presets_set( lame_t gfp, int fast, int cbr, const char* preset_name )
1590 {
1591 int mono = 0;
1592
1593 if (strcmp(preset_name, "help") == 0) {
1594 fprintf(stdout, "LAME version %s (%s)\n\n", get_lame_version(), get_lame_url());
1595 lame_presets_longinfo_dm( stdout );
1596 return -1;
1597 }
1598
1599
1600
1601 //aliases for compatibility with old presets
1602
1603 if (strcmp(preset_name, "phone") == 0) {
1604 preset_name = "16";
1605 mono = 1;
1606 }
1607 if ( (strcmp(preset_name, "phon+") == 0) ||
1608 (strcmp(preset_name, "lw") == 0) ||
1609 (strcmp(preset_name, "mw-eu") == 0) ||
1610 (strcmp(preset_name, "sw") == 0)) {
1611 preset_name = "24";
1612 mono = 1;
1613 }
1614 if (strcmp(preset_name, "mw-us") == 0) {
1615 preset_name = "40";
1616 mono = 1;
1617 }
1618 if (strcmp(preset_name, "voice") == 0) {
1619 preset_name = "56";
1620 mono = 1;
1621 }
1622 if (strcmp(preset_name, "fm") == 0) {
1623 preset_name = "112";
1624 }
1625 if ( (strcmp(preset_name, "radio") == 0) ||
1626 (strcmp(preset_name, "tape") == 0)) {
1627 preset_name = "112";
1628 }
1629 if (strcmp(preset_name, "hifi") == 0) {
1630 preset_name = "160";
1631 }
1632 if (strcmp(preset_name, "cd") == 0) {
1633 preset_name = "192";
1634 }
1635 if (strcmp(preset_name, "studio") == 0) {
1636 preset_name = "256";
1637 }
1638
1639 #if HAVE_MP3LAME >= 393
1640 if (strcmp(preset_name, "medium") == 0) {
1641
1642 if (fast > 0)
1643 lame_set_preset(gfp, MEDIUM_FAST);
1644 else
1645 lame_set_preset(gfp, MEDIUM);
1646
1647 return 0;
1648 }
1649 #endif
1650
1651 if (strcmp(preset_name, "standard") == 0) {
1652
1653 if (fast > 0)
1654 lame_set_preset(gfp, STANDARD_FAST);
1655 else
1656 lame_set_preset(gfp, STANDARD);
1657
1658 return 0;
1659 }
1660
1661 else if (strcmp(preset_name, "extreme") == 0){
1662
1663 if (fast > 0)
1664 lame_set_preset(gfp, EXTREME_FAST);
1665 else
1666 lame_set_preset(gfp, EXTREME);
1667
1668 return 0;
1669 }
1670
1671 else if (((strcmp(preset_name, "insane") == 0) ||
1672 (strcmp(preset_name, "320" ) == 0)) && (fast < 1)) {
1673
1674 lame_set_preset(gfp, INSANE);
1675
1676 return 0;
1677 }
1678
1679 // Generic ABR Preset
1680 if (((atoi(preset_name)) > 0) && (fast < 1)) {
1681 if ((atoi(preset_name)) >= 8 && (atoi(preset_name)) <= 320){
1682 lame_set_preset(gfp, atoi(preset_name));
1683
1684 if (cbr == 1 )
1685 lame_set_VBR(gfp, vbr_off);
1686
1687 if (mono == 1 ) {
1688 lame_set_mode(gfp, MONO);
1689 }
1690
1691 return 0;
1692
1693 }
1694 else {
1695 fprintf(stderr, "LAME version %s (%s)\n\n", get_lame_version(), get_lame_url());
1696 fprintf(stderr,"Error: The bitrate specified is out of the valid range for this preset\n"
1697 "\n"
1698 "When using this mode you must enter a value between \"8\" and \"320\"\n"
1699 "\n"
1700 "For further information try: \"-lameopts preset=help\"\n"
1701 );
1702 return -1;
1703 }
1704 }
1705
1706
1707
1708 fprintf(stderr, "LAME version %s (%s)\n\n", get_lame_version(), get_lame_url());
1709 fprintf(stderr,"Error: You did not enter a valid profile and/or options with preset\n"
1710 "\n"
1711 "Available profiles are:\n"
1712 "\n"
1713 " <fast> standard\n"
1714 " <fast> extreme\n"
1715 " insane\n"
1716 " <cbr> (ABR Mode) - The ABR Mode is implied. To use it,\n"
1717 " simply specify a bitrate. For example:\n"
1718 " \"preset=185\" activates this\n"
1719 " preset and uses 185 as an average kbps.\n"
1720 "\n"
1721 " Some examples:\n"
1722 "\n"
1723 " \"-lameopts fast:preset=standard \"\n"
1724 " or \"-lameopts cbr:preset=192 \"\n"
1725 " or \"-lameopts preset=172 \"\n"
1726 " or \"-lameopts preset=extreme \"\n"
1727 "\n"
1728 "For further information try: \"-lameopts preset=help\"\n"
1729 );
1730 mencoder_exit(1, "error parsing cmdline");
1731 }
1732 #endif
1733
1734 #if HAVE_MP3LAME >= 392
1735 /* lame_presets_longinfo_dm
1736 taken out of presets_longinfo_dm in lame-3.93.1/frontend/parse.c and modified */
1737 static void lame_presets_longinfo_dm ( FILE* msgfp )
1738 {
1739 fprintf ( msgfp,
1740 "\n"
1741 "The preset switches are designed to provide the highest possible quality.\n"
1742 "\n"
1743 "They have for the most part been subject to and tuned via rigorous double blind\n"
1744 "listening tests to verify and achieve this objective.\n"
1745 "\n"
1746 "These are continually updated to coincide with the latest developments that\n"
1747 "occur and as a result should provide you with nearly the best quality\n"
1748 "currently possible from LAME.\n"
1749 "\n"
1750 "To activate these presets:\n"
1751 "\n"
1752 " For VBR modes (generally highest quality):\n"
1753 "\n"
1754 " \"preset=standard\" This preset should generally be transparent\n"
1755 " to most people on most music and is already\n"
1756 " quite high in quality.\n"
1757 "\n"
1758 " \"preset=extreme\" If you have extremely good hearing and similar\n"
1759 " equipment, this preset will generally provide\n"
1760 " slightly higher quality than the \"standard\"\n"
1761 " mode.\n"
1762 "\n"
1763 " For CBR 320kbps (highest quality possible from the preset switches):\n"
1764 "\n"
1765 " \"preset=insane\" This preset will usually be overkill for most\n"
1766 " people and most situations, but if you must\n"
1767 " have the absolute highest quality with no\n"
1768 " regard to filesize, this is the way to go.\n"
1769 "\n"
1770 " For ABR modes (high quality per given bitrate but not as high as VBR):\n"
1771 "\n"
1772 " \"preset=<kbps>\" Using this preset will usually give you good\n"
1773 " quality at a specified bitrate. Depending on the\n"
1774 " bitrate entered, this preset will determine the\n"
1775 " optimal settings for that particular situation.\n"
1776 " While this approach works, it is not nearly as\n"
1777 " flexible as VBR, and usually will not attain the\n"
1778 " same level of quality as VBR at higher bitrates.\n"
1779 "\n"
1780 "The following options are also available for the corresponding profiles:\n"
1781 "\n"
1782 " <fast> standard\n"
1783 " <fast> extreme\n"
1784 " insane\n"
1785 " <cbr> (ABR Mode) - The ABR Mode is implied. To use it,\n"
1786 " simply specify a bitrate. For example:\n"
1787 " \"preset=185\" activates this\n"
1788 " preset and uses 185 as an average kbps.\n"
1789 "\n"
1790 " \"fast\" - Enables the new fast VBR for a particular profile. The\n"
1791 " disadvantage to the speed switch is that often times the\n"
1792 " bitrate will be slightly higher than with the normal mode\n"
1793 " and quality may be slightly lower also.\n"
1794 " Warning: with the current version fast presets might result in too\n"
1795 " high bitrate compared to regular presets.\n"
1796 "\n"
1797 " \"cbr\" - If you use the ABR mode (read above) with a significant\n"
1798 " bitrate such as 80, 96, 112, 128, 160, 192, 224, 256, 320,\n"
1799 " you can use the \"cbr\" option to force CBR mode encoding\n"
1800 " instead of the standard abr mode. ABR does provide higher\n"
1801 " quality but CBR may be useful in situations such as when\n"
1802 " streaming an mp3 over the internet may be important.\n"
1803 "\n"
1804 " For example:\n"
1805 "\n"
1806 " \"-lameopts fast:preset=standard \"\n"
1807 " or \"-lameopts cbr:preset=192 \"\n"
1808 " or \"-lameopts preset=172 \"\n"
1809 " or \"-lameopts preset=extreme \"\n"
1810 "\n"
1811 "\n"
1812 "A few aliases are available for ABR mode:\n"
1813 "phone => 16kbps/mono phon+/lw/mw-eu/sw => 24kbps/mono\n"
1814 "mw-us => 40kbps/mono voice => 56kbps/mono\n"
1815 "fm/radio/tape => 112kbps hifi => 160kbps\n"
1816 "cd => 192kbps studio => 256kbps");
1817 mencoder_exit(0, NULL);
1818 }
1819 #endif
1820
1821 #ifdef USE_LIBAVCODEC
1822 static uint32_t lavc_find_atag(char *codec)
1823 {
1824 if(codec == NULL)
1825 return 0;
1826
1827 if(! strcasecmp(codec, "mp2"))
1828 return 0x50;
1829
1830 if(! strcasecmp(codec, "mp3"))
1831 return 0x55;
1832
1833 if(! strcasecmp(codec, "ac3"))
1834 return 0x2000;
1835
1836 if(! strcasecmp(codec, "adpcm_ima_wav"))
1837 return 0x11;
1838
1839 if(! strncasecmp(codec, "bonk", 4))
1840 return 0x2048;
1841
1842 return 0;
1843 }
1844 #endif
1845
mplayer with SMedia Glamo drivers