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