configure: update FFmpeg revision (bc63a76).
[vaapi:mplayer.git] / mencoder.c
1 /*
2  * This file is part of MPlayer.
3  *
4  * MPlayer is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * MPlayer is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18
19 #define VCODEC_COPY 0
20 #define VCODEC_FRAMENO 1
21 // real codecs:
22 #define VCODEC_LIBAVCODEC 4
23 #define VCODEC_VFW 7
24 #define VCODEC_LIBDV 8
25 #define VCODEC_XVID 9
26 #define VCODEC_QTVIDEO 10
27 #define VCODEC_NUV 11
28 #define VCODEC_RAW 12
29 #define VCODEC_X264 13
30
31 #define ACODEC_COPY 0
32 #define ACODEC_PCM 1
33 #define ACODEC_VBRMP3 2
34 #define ACODEC_NULL 3
35 #define ACODEC_LAVC 4
36 #define ACODEC_TOOLAME 5
37 #define ACODEC_FAAC 6
38 #define ACODEC_TWOLAME 7
39
40 #ifdef __MINGW32__
41 #define SIGHUP   1
42 #define SIGQUIT  3
43 #define SIGPIPE 13
44 #endif
45
46 #include "config.h"
47
48 #include <inttypes.h>
49 #include <signal.h>
50 #include <stdio.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <strings.h>
54 #include <sys/time.h>
55 #if defined(__MINGW32__) || defined(__CYGWIN__)
56 #include <windows.h>
57 #endif
58
59 #include "input/input.h"
60 #include "libaf/af_format.h"
61 #include "libao2/audio_out.h"
62 #include "libavcodec/avcodec.h"
63 #include "libmpcodecs/ae.h"
64 #include "libmpcodecs/dec_audio.h"
65 #include "libmpcodecs/dec_video.h"
66 #include "libmpcodecs/mp_image.h"
67 #include "libmpcodecs/vd.h"
68 #include "libmpcodecs/vf.h"
69 #include "libmpdemux/aviprint.h"
70 #include "libmpdemux/demuxer.h"
71 #include "libmpdemux/mp3_hdr.h"
72 #include "libmpdemux/ms_hdr.h"
73 #include "libmpdemux/muxer.h"
74 #include "libmpdemux/stheader.h"
75 #include "libvo/fastmemcpy.h"
76 #include "sub/font_load.h"
77 #include "sub/sub.h"
78 #include "libvo/video_out.h"
79 #include "osdep/timer.h"
80 #include "stream/stream.h"
81 #include "stream/stream_bd.h"
82 #ifdef CONFIG_DVDREAD
83 #include "stream/stream_dvd.h"
84 #endif
85 #include "stream/stream_dvdnav.h"
86 #include "sub/ass_mp.h"
87 #include "codec-cfg.h"
88 #include "edl.h"
89 #include "help_mp.h"
90 #include "m_config.h"
91 #include "m_option.h"
92 #include "mp_fifo.h"
93 #include "mp_msg.h"
94 #include "mpcommon.h"
95 #include "parser-cfg.h"
96 #include "parser-mecmd.h"
97 #include "path.h"
98 #include "sub/spudec.h"
99 #include "sub/vobsub.h"
100 #include "sub/eosd.h"
101 #include "mencoder.h"
102
103
104 int vo_doublebuffering=0;
105 int vo_directrendering=0;
106 int vo_config_count=1;
107
108 //--------------------------
109
110 // cache2:
111 int stream_cache_size=-1;
112 #ifdef CONFIG_STREAM_CACHE
113 float stream_cache_min_percent=20.0;
114 float stream_cache_seek_min_percent=50.0;
115 #endif
116
117 int audio_id=-1;
118 int video_id=-1;
119 int dvdsub_id=-1;
120 int vobsub_id=-1;
121 char* audio_lang=NULL;
122 char* dvdsub_lang=NULL;
123
124 static char** audio_codec_list=NULL;  // override audio codec
125 static char** video_codec_list=NULL;  // override video codec
126 static char** audio_fm_list=NULL;     // override audio codec family
127 static char** video_fm_list=NULL;     // override video codec family
128
129 static int out_audio_codec=-1;
130 static int out_video_codec=-1;
131
132 int out_file_format=MUXER_TYPE_AVI;     // default to AVI
133 int quiet=0;
134 double video_time_usage=0;
135 double vout_time_usage=0;
136 double max_video_time_usage=0;
137 double max_vout_time_usage=0;
138 double cur_video_time_usage=0;
139 double cur_vout_time_usage=0;
140 int benchmark=0;
141
142 // A-V sync:
143 static float default_max_pts_correction=-1;//0.01f;
144 static float max_pts_correction=0;//default_max_pts_correction;
145 static float c_total=0;
146
147 static float audio_preload=0.5;
148 static float audio_delay_fix=0.0;
149 static float audio_delay=0.0;
150 static int ignore_start=0;
151 static int audio_density=2;
152
153 double force_fps=0;
154 static double force_ofps=0; // set to 24 for inverse telecine
155 static int skip_limit=-1;
156 float playback_speed=1.0;
157
158 static int force_srate=0;
159 static int audio_output_format=AF_FORMAT_UNKNOWN;
160
161 char *vobsub_out=NULL;
162 unsigned int vobsub_out_index=0;
163 char *vobsub_out_id=NULL;
164
165 char* out_filename=NULL;
166
167 char *force_fourcc=NULL;
168 int force_audiofmttag=-1;
169
170 char* passtmpfile="divx2pass.log";
171
172 static int play_n_frames=-1;
173 static int play_n_frames_mf=-1;
174
175 // sub:
176 char *font_name=NULL;
177 char *sub_font_name=NULL;
178 float font_factor=0.75;
179 char **sub_name=NULL;
180 char **sub_paths = NULL;
181 float sub_delay=0;
182 float sub_fps=0;
183 int   sub_auto = 0;
184 char *vobsub_name = NULL;
185 int   subcc_enabled=0;
186 int   suboverlap_enabled = 1;
187
188 int auto_expand=1;
189 int encode_duplicates=1;
190
191 // infos are empty by default
192 char *info_name=NULL;
193 char *info_artist=NULL;
194 char *info_genre=NULL;
195 char *info_subject=NULL;
196 char *info_copyright=NULL;
197 char *info_sourceform=NULL;
198 char *info_comment=NULL;
199
200 // Needed by libmpcodecs vf_vo.c
201 int config_video_out(const vo_functions_t *vo, uint32_t width, uint32_t height,
202                      uint32_t d_width, uint32_t d_height, uint32_t flags,
203                      char *title, uint32_t format) {
204   return 1;
205 }
206 // Needed by libmpdemux.
207 int mp_input_check_interrupt(int time) {
208   usec_sleep(time);
209   return 0;
210 }
211 // Needed by getch2
212 void mplayer_put_key(int code)
213 {
214 }
215
216 char *current_module;
217
218 // Needed by mpcommon.c
219 void set_osd_subtitle(subtitle *subs) {
220     vo_sub = subs;
221     vo_osd_changed(OSDTYPE_SUBTITLE);
222 }
223
224 static double seek_to_sec;
225 static off_t seek_to_byte=0;
226
227 static m_time_size_t end_at = { .type = END_AT_NONE, .pos = 0 };
228
229 static char * frameno_filename=NULL;
230
231 typedef struct {
232     unsigned char* start;
233     int in_size;
234     float frame_time;
235     int already_read;
236     int flush;
237 } s_frame_data;
238
239 static edl_record_ptr edl_records = NULL; ///< EDL entries memory area
240 static edl_record_ptr next_edl_record = NULL; ///< only for traversing edl_records
241 static short edl_muted; ///< Stores whether EDL is currently in muted mode.
242 static short edl_seeking; ///< When non-zero, stream is seekable.
243 static int edl_seek_type; ///< When non-zero, frames are discarded instead of seeking.
244
245 /* This header requires all the global variable declarations. */
246 #include "cfg-mencoder.h"
247
248
249 /* FIXME */
250 static void mencoder_exit(int level, const char *how)
251 {
252     if (how)
253         mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ExitingHow, how);
254     else
255         mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_Exiting);
256
257     exit(level);
258 }
259
260 static void parse_cfgfiles( m_config_t* conf )
261 {
262   char *conffile;
263   if (!disable_system_conf &&
264       m_config_parse_config_file(conf, MPLAYER_CONFDIR "/mencoder.conf", 1) < 0)
265     mencoder_exit(1,MSGTR_ConfigFileError);
266
267   if (!disable_user_conf) {
268     if ((conffile = get_path("mencoder.conf")) == NULL) {
269       mp_msg(MSGT_CPLAYER,MSGL_ERR,MSGTR_GetpathProblem);
270     } else {
271       if (m_config_parse_config_file(conf, conffile, 1) < 0)
272         mencoder_exit(1,MSGTR_ConfigFileError);
273       free(conffile);
274     }
275   }
276 }
277
278
279 //---------------------------------------------------------------------------
280
281 static int dec_audio(sh_audio_t *sh_audio,unsigned char* buffer,int total){
282     int size=0;
283     int at_eof=0;
284     while(size<total && !at_eof){
285         int len=total-size;
286                 if(len>MAX_OUTBURST) len=MAX_OUTBURST;
287                 if (mp_decode_audio(sh_audio, len) < 0)
288                     at_eof = 1;
289                 if(len>sh_audio->a_out_buffer_len) len=sh_audio->a_out_buffer_len;
290                 fast_memcpy(buffer+size,sh_audio->a_out_buffer,len);
291                 sh_audio->a_out_buffer_len-=len; size+=len;
292                 if(sh_audio->a_out_buffer_len>0)
293                     memmove(sh_audio->a_out_buffer,&sh_audio->a_out_buffer[len],sh_audio->a_out_buffer_len);
294     }
295     return size;
296 }
297
298 //---------------------------------------------------------------------------
299
300 static volatile int at_eof=0;
301 static volatile int interrupted=0;
302
303 static void exit_sighandler(int x){
304     at_eof=1;
305     interrupted=2; /* 1 means error */
306 }
307
308 static muxer_t* muxer=NULL;
309
310 static void add_subtitles(char *filename, float fps, int silent)
311 {
312     sub_data *subd;
313 #ifdef CONFIG_ASS
314     ASS_Track *asst = 0;
315 #endif
316
317     if (!filename) return;
318
319     subd = sub_read_file(filename, fps);
320 #ifdef CONFIG_ASS
321     if (ass_enabled)
322 #ifdef CONFIG_ICONV
323         asst = ass_read_file(ass_library, filename, sub_cp);
324 #else
325         asst = ass_read_file(ass_library, filename, 0);
326 #endif
327     if (ass_enabled && subd && !asst)
328         asst = ass_read_subdata(ass_library, subd, fps);
329
330     if (!asst && !subd && !silent)
331 #else
332     if (!subd && !silent)
333 #endif
334         mp_msg(MSGT_CPLAYER, MSGL_ERR, MSGTR_CantLoadSub,
335                     filename_recode(filename));
336
337 #ifdef CONFIG_ASS
338     if (!asst && !subd) return;
339     ass_track = asst;
340 #else
341     if (!subd) return;
342 #endif
343     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_FILE_SUB_FILENAME=%s\n",
344            filename_recode(filename));
345     subdata = subd;
346 }
347
348 /* Provide a timer value suitable for use in A/V sync calculations.
349  * mux->timer records the current position of the muxer stream.
350  * mux->encoder_delay is how many frames are currently buffered by the
351  * encoder. To mencoder core, encoder-buffered frames have been "dealt with"--
352  * they'll get to the muxer eventually. So, for the purposes of A/V sync,
353  * we need to add the total time length of buffered frames to the muxer stream
354  * position. */
355 static double adjusted_muxer_time(muxer_stream_t *mux)
356 {
357     if (! mux) return MP_NOPTS_VALUE;
358     return mux->timer + (double) mux->encoder_delay * mux->h.dwScale/mux->h.dwRate;
359 }
360
361 /* This function returns the absolute time for which MEncoder will switch files
362  * or move in the file so audio can be cut correctly. -1 if there is no limit. */
363 static float stop_time(demuxer_t* demuxer, muxer_stream_t* mux_v)
364 {
365         float timeleft = -1;
366         if (play_n_frames >= 0)
367                 timeleft = adjusted_muxer_time(mux_v) + play_n_frames * (double)(mux_v->h.dwScale) / mux_v->h.dwRate;
368         if (end_at.type == END_AT_TIME && (timeleft > end_at.pos || timeleft == -1))
369                 timeleft = end_at.pos;
370         if (next_edl_record && demuxer && demuxer->video) { // everything is OK to be checked
371                 float tmp = adjusted_muxer_time(mux_v) + next_edl_record->start_sec - demuxer->video->pts;
372                 if (timeleft == -1 || timeleft > tmp) {
373                         // There's less time in EDL than what we already know
374                         if (next_edl_record->action == EDL_SKIP && edl_seeking) {
375                                 timeleft = tmp;
376                         } else if (next_edl_record->action == EDL_MUTE) {
377                                 //timeleft = next_edl_record->start_sec - demuxer->video->pts;
378                                 // For the moment (and probably forever) EDL mute doesn't work in MEncoder
379                         }
380                 }
381         }
382         return timeleft;
383 }
384
385 /** \brief Seeks audio forward to pts by dumping audio packets
386  *  \return The current audio pts. */
387 static float forward_audio(float pts, demux_stream_t *d_audio, muxer_stream_t* mux_a)
388 {
389     sh_audio_t * sh_audio = d_audio ? d_audio->sh : NULL;
390     int samplesize, avg;
391     float a_pts = calc_a_pts(sh_audio, d_audio);
392
393     if (!sh_audio) return a_pts;
394
395     if (sh_audio->audio.dwScale) samplesize = sh_audio->audio.dwSampleSize;
396     else samplesize = (sh_audio->wf ? sh_audio->wf->nBlockAlign : 1);
397     avg = (sh_audio->wf ? sh_audio->wf->nAvgBytesPerSec : sh_audio->i_bps);
398
399     // after a demux_seek, a_pts will be zero until you read some audio.
400     // carefully checking if a_pts is truely correct by reading tiniest amount of data possible.
401     if (pts > a_pts && a_pts == 0.0 && samplesize) {
402         if (demux_read_data(sh_audio->ds,mux_a->buffer,samplesize) <= 0) return a_pts; // EOF
403         a_pts = calc_a_pts(sh_audio, d_audio);
404     }
405
406     while (pts > a_pts) {
407         int len;
408         if (samplesize) {
409             len = avg * (pts - a_pts > 0.5 ? 0.5 : pts - a_pts);
410             len/= samplesize; if(len<1) len=1;
411             len*= samplesize;
412             len = demux_read_data(sh_audio->ds,mux_a->buffer,len);
413         } else {
414             unsigned char * crap;
415             len = ds_get_packet(sh_audio->ds, &crap);
416         }
417         if (len <= 0) break; // EOF of audio.
418         a_pts = calc_a_pts(sh_audio, d_audio);
419     }
420     return a_pts;
421 }
422
423 /** \brief Seeks slowly by dumping frames.
424  *  \return 1 for success, 2 for EOF. */
425 static int slowseek(float end_pts, demux_stream_t *d_video,
426                     demux_stream_t *d_audio, muxer_stream_t *mux_a,
427                     s_frame_data *frame_data, int framecopy, int print_info)
428 {
429     sh_video_t * sh_video = d_video->sh;
430     vf_instance_t * vfilter = sh_video ? sh_video->vfilter : NULL;
431     int done = 0;
432
433     while (!interrupted) {
434         float a_pts = 0.;
435
436         if (!frame_data->already_read) { // when called after fixdelay, a frame is already read
437             frame_data->in_size = video_read_frame(sh_video, &frame_data->frame_time, &frame_data->start, force_fps);
438             frame_data->flush = frame_data->in_size < 0 && d_video->eof;
439             if (frame_data->flush) {
440                 frame_data->in_size = 0;
441                 frame_data->start = NULL;
442             }
443             if(frame_data->in_size<0) return 2;
444             sh_video->timer += frame_data->frame_time;
445         }
446         frame_data->already_read = 0;
447
448         a_pts = forward_audio(sh_video->pts - frame_data->frame_time + audio_delay, d_audio, mux_a);
449
450         if (done) {
451             // wait for keyframe in case of -ovc copy
452             if (!framecopy || (sh_video->ds->flags & 1)) {
453                 frame_data->already_read = 1;
454                 return 1;
455             }
456         }
457         if (sh_video->pts >= end_pts) done = 1;
458
459         if (vfilter) {
460             int softskip = (vfilter->control(vfilter, VFCTRL_SKIP_NEXT_FRAME, 0) == CONTROL_TRUE);
461             void *decoded_frame = decode_video(sh_video, frame_data->start, frame_data->in_size, !softskip, MP_NOPTS_VALUE, NULL);
462             if (decoded_frame)
463                 filter_video(sh_video, decoded_frame, MP_NOPTS_VALUE);
464             else if (frame_data->flush)
465                 return 2;
466         }
467
468         if (print_info) mp_msg(MSGT_MENCODER, MSGL_STATUS,
469                MSGTR_EdlSkipStartEndCurrent,
470                next_edl_record->start_sec, next_edl_record->stop_sec,
471                sh_video->pts, a_pts);
472     }
473     if (interrupted) return 2;
474     return 1;
475 }
476
477 /// Deletes audio or video as told by -delay to sync
478 static void fixdelay(demux_stream_t *d_video, demux_stream_t *d_audio,
479                      muxer_stream_t *mux_a, s_frame_data *frame_data,
480                      int framecopy)
481 {
482     // TODO: Find a way to encode silence instead of deleting video
483     sh_video_t * sh_video = d_video->sh;
484     float a_pts;
485
486     // demux_seek has a weirdness that sh_video->pts is meaningless,
487     // until a single frame is read... Same for audio actually too.
488     // Reading one frame, and keeping it.
489     frame_data->in_size = video_read_frame(sh_video, &frame_data->frame_time, &frame_data->start, force_fps);
490     if(frame_data->in_size<0) return;
491     sh_video->timer += frame_data->frame_time;
492     frame_data->already_read = 1;
493
494     a_pts = forward_audio(sh_video->pts - frame_data->frame_time + audio_delay, d_audio, mux_a);
495
496     if (audio_delay > 0) return;
497     else if (sh_video->pts - frame_data->frame_time + audio_delay >= a_pts) return;
498
499     slowseek(a_pts - audio_delay, d_video, d_audio, mux_a, frame_data, framecopy, 0);
500 }
501
502 /** \brief Seeks for EDL
503  *  \return 1 for success, 0 for failure, 2 for EOF. */
504 static int edl_seek(edl_record_ptr next_edl_record, demuxer_t *demuxer,
505                     demux_stream_t *d_audio, muxer_stream_t *mux_a,
506                     s_frame_data *frame_data, int framecopy)
507 {
508     sh_video_t * sh_video = demuxer->video ? demuxer->video->sh : NULL;
509
510     if (!sh_video) return 0;
511     if (sh_video->pts >= next_edl_record->stop_sec) return 1; // nothing to do...
512
513     if (!edl_seek_type) {
514         if(demux_seek(demuxer, next_edl_record->stop_sec - sh_video->pts, audio_delay, 0)){
515             sh_video->pts = demuxer->video->pts;
516             //if (vo_vobsub) vobsub_seek(vo_vobsub,sh_video->pts);
517             //if(vo_spudec) spudec_reset(vo_spudec);
518             if (audio_delay != 0.0) fixdelay(demuxer->video, d_audio, mux_a, frame_data, framecopy);
519             return 1;
520         }
521         // non-seekable stream.
522         return 0;
523     }
524
525     // slow seek, read every frame.
526
527     return slowseek(next_edl_record->stop_sec, demuxer->video, d_audio, mux_a, frame_data, framecopy, 1);
528 }
529
530
531 int main(int argc,char* argv[]){
532
533 stream_t* stream=NULL;
534 stream_t* ostream=NULL;
535 demuxer_t* demuxer=NULL;
536 stream_t* stream2=NULL;
537 demuxer_t* demuxer2=NULL;
538 demux_stream_t *d_audio=NULL;
539 demux_stream_t *d_video=NULL;
540 demux_stream_t *d_dvdsub=NULL;
541 sh_audio_t *sh_audio=NULL;
542 sh_video_t *sh_video=NULL;
543 int file_format=DEMUXER_TYPE_UNKNOWN;
544 int i=DEMUXER_TYPE_UNKNOWN;
545 void *vobsub_writer=NULL;
546 s_frame_data frame_data = { .start = NULL, .in_size = 0, .frame_time = 0., .already_read = 0 };
547
548 uint32_t ptimer_start;
549 uint32_t audiorate=0;
550 uint32_t videorate=0;
551 uint32_t audiosamples=1;
552 uint32_t videosamples=1;
553 uint32_t skippedframes=0;
554 uint32_t duplicatedframes=0;
555 uint32_t badframes=0;
556
557 muxer_stream_t* mux_a=NULL;
558 muxer_stream_t* mux_v=NULL;
559 off_t muxer_f_size=0;
560
561 double v_pts_corr=0;
562 double v_timer_corr=0;
563 double sub_offset=0;
564 int did_seek=0;
565
566 m_entry_t* filelist = NULL;
567 char* filename=NULL;
568
569 int decoded_frameno=0;
570 int next_frameno=-1;
571 int curfile=0;
572 int new_srate=0;
573
574 unsigned int timer_start=0;
575 ao_data_t ao_data = {0,0,0,0,OUTBURST,-1,0};
576
577 audio_encoding_params_t aparams;
578 audio_encoder_t *aencoder = NULL;
579
580 user_correct_pts = 0;
581
582   common_preinit(&argc, &argv);
583
584   // Create the config context and register the options
585   mconfig = m_config_new();
586   m_config_register_options(mconfig,mencoder_opts);
587   m_config_register_options(mconfig, common_opts);
588
589   // Preparse the command line
590   m_config_preparse_command_line(mconfig,argc,argv);
591
592   print_version("MEncoder");
593
594  parse_cfgfiles(mconfig);
595  filelist = m_config_parse_me_command_line(mconfig, argc, argv);
596  if(!filelist) mencoder_exit(1, MSGTR_ErrorParsingCommandLine);
597  if (!common_init())
598    mencoder_exit(1,NULL);
599
600 {
601         char *extension;
602
603         if (!out_filename) mencoder_exit(1,MSGTR_MissingOutputFilename);
604         extension=strrchr(out_filename,'.');
605         if (extension != NULL && strlen(extension) > 3 && strlen(extension) < 6)
606         {
607                 extension++;
608
609                 switch (out_file_format)
610                 {
611                         case MUXER_TYPE_AVI:
612                         if (strcasecmp(extension,"avi"))
613                                 mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_MencoderWrongFormatAVI);
614                         break;
615
616                         case MUXER_TYPE_MPEG:
617                         if (strcasecmp(extension,"mpg") &&
618                                 strcasecmp(extension,"mpeg") &&
619                                 strcasecmp(extension,"vob"))
620                                 mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_MencoderWrongFormatMPG);
621                         break;
622                 }
623         }
624 }
625  /* Display what configure line was used */
626  mp_msg(MSGT_MENCODER, MSGL_V, "Configuration: " CONFIGURATION "\n");
627
628
629 if (frameno_filename) {
630   stream2=open_stream(frameno_filename, NULL, NULL);
631   if(stream2){
632     demuxer2=demux_open(stream2,DEMUXER_TYPE_AVI,-1,-1,-2,NULL);
633     if(demuxer2) mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_UsingPass3ControlFile, frameno_filename);
634     else mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_FormatNotRecognized);
635   }
636 }
637
638   /* HACK, for some weird reason, push() has to be called twice,
639      otherwise options are not saved correctly */
640   m_config_push(mconfig);
641 play_next_file:
642   m_config_push(mconfig);
643   m_entry_set_options(mconfig,&filelist[curfile]);
644   filename = filelist[curfile].name;
645
646   if(!filename){
647         mp_msg(MSGT_CPLAYER, MSGL_FATAL, MSGTR_MissingFilename);
648         mencoder_exit(1,NULL);
649   }
650
651   if (vobsub_name)
652     vo_vobsub = vobsub_open(vobsub_name, spudec_ifo, 1, &vo_spudec);
653 #ifdef CONFIG_ASS
654   // must be before demuxer open, since the settings are
655   // used in generating the ASSTrack
656   if (ass_enabled && ass_library)
657     ass_mp_reset_config(ass_library);
658 #endif
659
660   stream=open_stream(filename,0,&file_format);
661
662   if(!stream){
663         mp_msg(MSGT_CPLAYER, MSGL_FATAL, MSGTR_CannotOpenFile_Device);
664         mencoder_exit(1,NULL);
665   }
666
667   mp_msg(MSGT_CPLAYER, MSGL_INFO, MSGTR_OpenedStream, file_format, (int)(stream->start_pos), (int)(stream->end_pos));
668
669 if(stream->type==STREAMTYPE_BD){
670   if(audio_lang && audio_id==-1) audio_id=bd_aid_from_lang(stream,audio_lang);
671   if(dvdsub_lang && dvdsub_id==-1) dvdsub_id=bd_sid_from_lang(stream,dvdsub_lang);
672 }
673
674 #ifdef CONFIG_DVDREAD
675 if(stream->type==STREAMTYPE_DVD){
676   if(audio_lang && audio_id==-1) audio_id=dvd_aid_from_lang(stream,audio_lang);
677   if(dvdsub_lang && dvdsub_id==-1) dvdsub_id=dvd_sid_from_lang(stream,dvdsub_lang);
678 }
679 #endif
680
681 #ifdef CONFIG_DVDNAV
682 if(stream->type==STREAMTYPE_DVDNAV){
683   if(audio_lang && audio_id==-1) audio_id=mp_dvdnav_aid_from_lang(stream,audio_lang);
684   if(dvdsub_lang && dvdsub_id==-1) dvdsub_id=mp_dvdnav_sid_from_lang(stream,dvdsub_lang);
685 }
686 #endif
687
688   stream->start_pos+=seek_to_byte;
689
690   if(stream_cache_size>0) stream_enable_cache(stream,stream_cache_size*1024ull,0,0);
691
692   if(demuxer2) audio_id=-2; /* do NOT read audio packets... */
693
694   demuxer=demux_open(stream,file_format,audio_id,video_id,dvdsub_id,filename);
695   if(!demuxer){
696     mp_msg(MSGT_DEMUXER, MSGL_FATAL, MSGTR_FormatNotRecognized);
697     mp_msg(MSGT_DEMUXER, MSGL_FATAL, MSGTR_CannotOpenDemuxer);
698         mencoder_exit(1,NULL);
699   }
700
701   if (ts_prog) {
702     demux_program_t prog = { .progid = ts_prog };
703     if (demux_control(demuxer, DEMUXER_CTRL_IDENTIFY_PROGRAM, &prog) != DEMUXER_CTRL_NOTIMPL) {
704       audio_id = prog.aid; // switching is handled by select_audio below
705       video_id = prog.vid;
706       demuxer_switch_video(demuxer, video_id);
707     }
708   }
709   select_audio(demuxer, audio_id, audio_lang);
710
711   if (dvdsub_id == -1 && dvdsub_lang)
712     dvdsub_id = demuxer_sub_track_by_lang(demuxer, dvdsub_lang);
713
714   if (dvdsub_id == -1)
715     dvdsub_id = demuxer_default_sub_track(demuxer);
716
717   for (i = 0; i < MAX_S_STREAMS; i++) {
718     sh_sub_t *sh = demuxer->s_streams[i];
719     if (sh && sh->sid == dvdsub_id) {
720       demuxer->sub->id = i;
721       demuxer->sub->sh = sh;
722       break;
723     }
724   }
725
726   if(dvd_chapter>1) {
727     float pts;
728     if (demuxer_seek_chapter(demuxer, dvd_chapter-1, 1, &pts, NULL, NULL) >= 0 && pts > -1.0)
729       seek_to_sec = pts;
730   }
731
732 d_audio=demuxer2 ? demuxer2->audio : demuxer->audio;
733 d_video=demuxer->video;
734 d_dvdsub=demuxer->sub;
735 sh_audio=d_audio->sh;
736 sh_video=d_video->sh;
737
738   if(!sh_video)
739   {
740         mp_msg(MSGT_CPLAYER,MSGL_FATAL,MSGTR_VideoStreamRequired);
741         mencoder_exit(1,NULL);
742   }
743
744   if(!video_read_properties(sh_video)){
745       mp_msg(MSGT_CPLAYER, MSGL_FATAL, MSGTR_CannotReadVideoProperties);
746       mencoder_exit(1,NULL);
747   }
748
749   mp_msg(MSGT_MENCODER,MSGL_INFO, MSGTR_FilefmtFourccSizeFpsFtime,
750    demuxer->file_format,sh_video->format, sh_video->disp_w,sh_video->disp_h,
751    sh_video->fps,sh_video->frametime
752   );
753
754   if(force_fps){
755     sh_video->fps=force_fps;
756     sh_video->frametime=1.0f/sh_video->fps;
757     mp_msg(MSGT_MENCODER,MSGL_INFO,MSGTR_ForcingInputFPS, sh_video->fps);
758   }
759
760   if(sh_audio && out_audio_codec<0){
761     if(audio_id==-2)
762         mp_msg(MSGT_MENCODER,MSGL_ERR,MSGTR_DemuxerDoesntSupportNosound);
763     mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_NoAudioEncoderSelected);
764     mencoder_exit(1,NULL);
765   }
766   if(sh_video && out_video_codec<0){
767     mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_NoVideoEncoderSelected);
768     mencoder_exit(1,NULL);
769   }
770
771 if(sh_audio && (out_audio_codec || seek_to_sec || !sh_audio->wf || playback_speed != 1.0)){
772   // Go through the codec.conf and find the best codec...
773   mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
774   if(!init_best_audio_codec(sh_audio,audio_codec_list,audio_fm_list)){
775     sh_audio=d_audio->sh=NULL; // failed to init :(
776   }
777   mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
778 }
779
780   if (sh_audio) {
781     new_srate = sh_audio->samplerate;
782     if (playback_speed != 1.0) {
783         new_srate *= playback_speed;
784         // limits are taken from libaf/af_resample.c
785         if (new_srate < 8000) new_srate = 8000;
786         if (new_srate > 192000) new_srate = 192000;
787         playback_speed = (float)new_srate / (float)sh_audio->samplerate;
788     }
789   }
790
791 // set up video encoder:
792
793 if (!curfile) { // curfile is non zero when a second file is opened
794 if (vobsub_out) {
795     unsigned int palette[16], width, height;
796     unsigned char tmp[3] = { 0, 0, 0 };
797     if (spudec_ifo && vobsub_parse_ifo(NULL,spudec_ifo, palette, &width, &height, 1, dvdsub_id, tmp) >= 0)
798         vobsub_writer = vobsub_out_open(vobsub_out, palette, sh_video->disp_w, sh_video->disp_h,
799                                         vobsub_out_id?vobsub_out_id:(char *)tmp, vobsub_out_index);
800 #ifdef CONFIG_DVDREAD
801     if (vobsub_writer == NULL) {
802         char tmp[3];
803         if (vobsub_out_id == NULL && stream->type == STREAMTYPE_DVD) {
804             int i;
805             dvd_priv_t *dvd = (dvd_priv_t*)stream->priv;
806             for (i = 0; i < dvd->nr_of_subtitles; ++i)
807                 if (dvd->subtitles[i].id == dvdsub_id) {
808                     tmp[0] = (dvd->subtitles[i].language >> 8) & 0xff;
809                     tmp[1] = dvd->subtitles[i].language & 0xff;
810                     tmp[2] = 0;
811                     vobsub_out_id = tmp;
812                     break;
813                 }
814         }
815         vobsub_writer=vobsub_out_open(vobsub_out, stream->type==STREAMTYPE_DVD?((dvd_priv_t *)(stream->priv))->cur_pgc->palette:NULL,
816                                       sh_video->disp_w, sh_video->disp_h, vobsub_out_id, vobsub_out_index);
817     }
818 #endif
819 }
820 else if (!vo_spudec) {
821 init_vo_spudec(stream, sh_video, d_dvdsub ? d_dvdsub->sh : NULL);
822 }
823
824 ostream = open_output_stream(out_filename, 0);
825 if(!ostream) {
826   mp_msg(MSGT_MENCODER, MSGL_FATAL, MSGTR_CannotOpenOutputFile, out_filename);
827   mencoder_exit(1,NULL);
828 }
829
830 muxer=muxer_new_muxer(out_file_format,ostream);
831 if(!muxer) {
832   mp_msg(MSGT_MENCODER, MSGL_FATAL, MSGTR_CannotInitializeMuxer);
833   mencoder_exit(1,NULL);
834 }
835 #if 0
836 //disabled: it horrybly distorts filtered sound
837 if(out_file_format == MUXER_TYPE_MPEG) audio_preload = 0;
838 #endif
839
840 muxer->audio_delay_fix = audio_delay_fix;
841
842 // ============= VIDEO ===============
843
844 mux_v=muxer_new_stream(muxer,MUXER_TYPE_VIDEO);
845
846 mux_v->buffer_size=0x800000; // 8MB
847 mux_v->buffer=malloc(mux_v->buffer_size);
848
849 mux_v->source=sh_video;
850
851 mux_v->h.dwSampleSize=0; // VBR
852 #ifdef CONFIG_FFMPEG
853 {
854     double fps = force_ofps?force_ofps:sh_video->fps*playback_speed;
855     AVRational q= av_d2q(fps, fps*1001+2);
856     mux_v->h.dwScale= q.den;
857     mux_v->h.dwRate = q.num;
858 }
859 #else
860 mux_v->h.dwScale=10000;
861 mux_v->h.dwRate=mux_v->h.dwScale*(force_ofps?force_ofps:sh_video->fps*playback_speed);
862 #endif
863
864 mux_v->codec=out_video_codec;
865
866 mux_v->bih=NULL;
867 }
868 sh_video->codec=NULL;
869 sh_video->vfilter=NULL; // fixme!
870
871 switch(mux_v->codec){
872 case VCODEC_COPY:
873         if (!curfile) {
874                 if (sh_video->bih) {
875                         mux_v->bih=malloc(sh_video->bih->biSize);
876                         memcpy(mux_v->bih, sh_video->bih, sh_video->bih->biSize);
877                 }
878     else
879     {
880         mux_v->bih=calloc(1,sizeof(*mux_v->bih));
881         mux_v->bih->biSize=sizeof(*mux_v->bih);
882         mux_v->bih->biWidth=sh_video->disp_w;
883         mux_v->bih->biHeight=sh_video->disp_h;
884         mux_v->bih->biCompression=sh_video->format;
885         mux_v->bih->biPlanes=1;
886         mux_v->bih->biBitCount=24; // FIXME!!!
887         mux_v->bih->biSizeImage=mux_v->bih->biWidth*mux_v->bih->biHeight*(mux_v->bih->biBitCount/8);
888     }
889         }
890     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_VCodecFramecopy,
891         mux_v->bih->biWidth, mux_v->bih->biHeight,
892         mux_v->bih->biBitCount, mux_v->bih->biCompression);
893
894         if (curfile) {
895                 if (sh_video->bih) {
896                         if ((mux_v->bih->biSize != sh_video->bih->biSize) ||
897                             memcmp(mux_v->bih, sh_video->bih, sh_video->bih->biSize))
898                         {
899                                 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_VCodecFramecopy,
900                                        sh_video->bih->biWidth, sh_video->bih->biHeight,
901                                        sh_video->bih->biBitCount, sh_video->bih->biCompression);
902                                 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_FrameCopyFileMismatch);
903                                 mencoder_exit(1,NULL);
904                         }
905                 }
906                 else {
907                         if ((mux_v->bih->biWidth != sh_video->disp_w) ||
908                             (mux_v->bih->biHeight != sh_video->disp_h) ||
909                             (mux_v->bih->biCompression != sh_video->format)) {
910                                 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_VCodecFramecopy,
911                                        sh_video->disp_w, sh_video->disp_w, 24, sh_video->format);
912                                 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_FrameCopyFileMismatch);
913                                 mencoder_exit(1,NULL);
914                         }
915                 }
916         }
917     break;
918 case VCODEC_FRAMENO:
919         if (!curfile) {
920     mux_v->bih=calloc(1,sizeof(*mux_v->bih));
921     mux_v->bih->biSize=sizeof(*mux_v->bih);
922     mux_v->bih->biWidth=sh_video->disp_w;
923     mux_v->bih->biHeight=sh_video->disp_h;
924     mux_v->bih->biPlanes=1;
925     mux_v->bih->biBitCount=24;
926     mux_v->bih->biCompression=mmioFOURCC('F','r','N','o');
927     mux_v->bih->biSizeImage=mux_v->bih->biWidth*mux_v->bih->biHeight*(mux_v->bih->biBitCount/8);
928         }
929     break;
930 default: {
931     static vf_instance_t * ve = NULL;
932   if (!ve) {
933     switch(mux_v->codec){
934     case VCODEC_LIBAVCODEC:
935         sh_video->vfilter=vf_open_encoder(NULL,"lavc",(char *)mux_v); break;
936     case VCODEC_RAW:
937         sh_video->vfilter=vf_open_encoder(NULL,"raw",(char *)mux_v); break;
938     case VCODEC_VFW:
939         sh_video->vfilter=vf_open_encoder(NULL,"vfw",(char *)mux_v); break;
940     case VCODEC_LIBDV:
941         sh_video->vfilter=vf_open_encoder(NULL,"libdv",(char *)mux_v); break;
942     case VCODEC_XVID:
943         sh_video->vfilter=vf_open_encoder(NULL,"xvid",(char *)mux_v); break;
944     case VCODEC_QTVIDEO:
945         sh_video->vfilter=vf_open_encoder(NULL,"qtvideo",(char *)mux_v); break;
946     case VCODEC_NUV:
947         sh_video->vfilter=vf_open_encoder(NULL,"nuv",(char *)mux_v); break;
948     case VCODEC_X264:
949         sh_video->vfilter=vf_open_encoder(NULL,"x264",(char *)mux_v); break;
950     }
951     if(!mux_v->bih || !sh_video->vfilter){
952         mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_EncoderOpenFailed);
953         mencoder_exit(1,NULL);
954     }
955     ve = sh_video->vfilter;
956   } else sh_video->vfilter = ve;
957     // append 'expand' filter, it fixes stride problems and renders osd:
958 #ifdef CONFIG_ASS
959     if (auto_expand && !ass_enabled) { /* we do not want both */
960 #else
961     if (auto_expand) {
962 #endif
963       char* vf_args[] = { "osd", "1", NULL };
964       sh_video->vfilter=vf_open_filter(sh_video->vfilter,"expand",vf_args);
965     }
966
967 #ifdef CONFIG_ASS
968   if(ass_enabled) {
969     int i;
970     int insert = 1;
971     if (vf_settings)
972       for (i = 0; vf_settings[i].name; ++i)
973         if (strcmp(vf_settings[i].name, "ass") == 0) {
974           insert = 0;
975           break;
976         }
977     if (insert) {
978       char* vf_arg[] = {"auto", "1", NULL};
979       vf_instance_t* vf_ass = vf_open_filter(sh_video->vfilter,"ass",vf_arg);
980       if (vf_ass)
981         sh_video->vfilter=vf_ass;
982       else
983         mp_msg(MSGT_CPLAYER,MSGL_ERR, "ASS: cannot add video filter\n");
984     }
985
986     if (ass_library) {
987       for (i = 0; i < demuxer->num_attachments; ++i) {
988         demux_attachment_t* att = demuxer->attachments + i;
989         if (extract_embedded_fonts &&
990             att->name && att->type && att->data && att->data_size &&
991             (strcmp(att->type, "application/x-truetype-font") == 0 ||
992              strcmp(att->type, "application/x-font") == 0))
993           ass_add_font(ass_library, att->name, att->data, att->data_size);
994       }
995     }
996   }
997 #endif
998
999   sh_video->vfilter=append_filters(sh_video->vfilter);
1000   eosd_init(sh_video->vfilter);
1001
1002 #ifdef CONFIG_ASS
1003   if (ass_enabled)
1004     eosd_ass_init(ass_library);
1005 #endif
1006
1007 // after reading video params we should load subtitles because
1008 // we know fps so now we can adjust subtitles time to ~6 seconds AST
1009 // check .sub
1010     load_subtitles(filename, sh_video->fps, add_subtitles);
1011
1012     mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
1013     init_best_video_codec(sh_video,video_codec_list,video_fm_list);
1014     mp_msg(MSGT_CPLAYER,MSGL_INFO,"==========================================================================\n");
1015     if(!sh_video->initialized) mencoder_exit(1,NULL);
1016  }
1017 }
1018
1019 if (!curfile) {
1020 /* force output fourcc to .. */
1021 if ((force_fourcc != NULL) && (strlen(force_fourcc) >= 4))
1022 {
1023     mux_v->bih->biCompression = mmioFOURCC(force_fourcc[0], force_fourcc[1],
1024                                             force_fourcc[2], force_fourcc[3]);
1025     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ForcingOutputFourcc,
1026         mux_v->bih->biCompression, (char *)&mux_v->bih->biCompression);
1027 }
1028
1029 if (! ignore_start)
1030     muxer->audio_delay_fix -= sh_video->stream_delay;
1031
1032 //if(demuxer->file_format!=DEMUXER_TYPE_AVI) pts_from_bps=0; // it must be 0 for mpeg/asf!
1033
1034 // ============= AUDIO ===============
1035 if(sh_audio){
1036
1037 if (force_audiofmttag != -1) {
1038         sh_audio->format = force_audiofmttag;
1039         if (sh_audio->wf) {
1040                 sh_audio->wf->wFormatTag = sh_audio->format;
1041         }
1042         mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ForcingOutputAudiofmtTag,
1043                force_audiofmttag);
1044 }
1045
1046 mux_a=muxer_new_stream(muxer,MUXER_TYPE_AUDIO);
1047
1048 mux_a->buffer_size=0x100000; //16384;
1049 mux_a->buffer=malloc(mux_a->buffer_size);
1050 if (!mux_a->buffer)
1051     mencoder_exit(1,MSGTR_MemAllocFailed);
1052
1053 mux_a->source=sh_audio;
1054
1055 mux_a->codec=out_audio_codec;
1056
1057 ao_data.samplerate = force_srate;
1058 ao_data.channels = 0;
1059 ao_data.format = audio_output_format;
1060 if(!init_audio_filters(sh_audio,
1061    // input:
1062    new_srate,
1063    // output:
1064    &ao_data.samplerate, &ao_data.channels, &ao_data.format)) {
1065      mp_msg(MSGT_CPLAYER,MSGL_ERR,MSGTR_AudioFilterChainPreinitError);
1066      mencoder_exit(1, NULL);
1067    }
1068
1069 aparams.channels = ao_data.channels;
1070 aparams.sample_rate = ao_data.samplerate;
1071 aparams.sample_format = ao_data.format;
1072 aparams.audio_preload = 1000 * audio_preload;
1073 if(mux_a->codec != ACODEC_COPY) {
1074     aencoder = new_audio_encoder(mux_a, &aparams);
1075     if(!aencoder)
1076         mencoder_exit(1, NULL);
1077     if(!init_audio_filters(sh_audio,
1078         new_srate,
1079         &aparams.sample_rate, &aparams.channels, &aencoder->input_format)) {
1080       mp_msg(MSGT_CPLAYER,MSGL_FATAL,MSGTR_NoMatchingFilter);
1081       mencoder_exit(1,NULL);
1082     }
1083     ao_data.format = aencoder->input_format;
1084     ao_data.channels = aparams.channels;
1085     ao_data.samplerate = aparams.sample_rate;
1086 }
1087 switch(mux_a->codec){
1088 case ACODEC_COPY:
1089     if (playback_speed != 1.0) mp_msg(MSGT_CPLAYER, MSGL_WARN, MSGTR_NoSpeedWithFrameCopy);
1090     if (sh_audio->format >= 0x10000) {
1091         mp_msg(MSGT_MENCODER,MSGL_ERR,MSGTR_CantCopyAudioFormat, sh_audio->format);
1092         mencoder_exit(1,NULL);
1093     }
1094     if (sh_audio->wf){
1095         mux_a->wf=malloc(sizeof(*mux_a->wf) + sh_audio->wf->cbSize);
1096         memcpy(mux_a->wf, sh_audio->wf, sizeof(*mux_a->wf) + sh_audio->wf->cbSize);
1097         if(!sh_audio->i_bps) sh_audio->i_bps=mux_a->wf->nAvgBytesPerSec;
1098     } else {
1099         mux_a->wf = malloc(sizeof(*mux_a->wf));
1100         mux_a->wf->nBlockAlign = 1; //mux_a->h.dwSampleSize;
1101         mux_a->wf->wFormatTag = sh_audio->format;
1102         mux_a->wf->nChannels = sh_audio->channels;
1103         mux_a->wf->nSamplesPerSec = sh_audio->samplerate;
1104         mux_a->wf->nAvgBytesPerSec=sh_audio->i_bps; //mux_a->h.dwSampleSize*mux_a->wf->nSamplesPerSec;
1105         mux_a->wf->wBitsPerSample = 16; // FIXME
1106         mux_a->wf->cbSize=0; // FIXME for l3codeca.acm
1107     }
1108     if(sh_audio->audio.dwScale){
1109         mux_a->h.dwSampleSize=sh_audio->audio.dwSampleSize;
1110         mux_a->h.dwScale=sh_audio->audio.dwScale;
1111         mux_a->h.dwRate=sh_audio->audio.dwRate;
1112     } else {
1113         mux_a->h.dwSampleSize=mux_a->wf->nBlockAlign;
1114         mux_a->h.dwScale=mux_a->h.dwSampleSize;
1115         mux_a->h.dwRate=mux_a->wf->nAvgBytesPerSec;
1116     }
1117     mux_a->h.dwRate *= playback_speed;
1118     mux_a->wf->nSamplesPerSec *= playback_speed;
1119     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ACodecFramecopy,
1120         mux_a->wf->wFormatTag, mux_a->wf->nChannels, mux_a->wf->nSamplesPerSec,
1121         mux_a->wf->wBitsPerSample, mux_a->wf->nAvgBytesPerSec, mux_a->h.dwSampleSize);
1122     break;
1123 }
1124
1125 if ( mp_msg_test(MSGT_MENCODER,MSGL_DBG2) ) print_wave_header(mux_a->wf, MSGL_DBG2);
1126
1127 if (! ignore_start)
1128     muxer->audio_delay_fix += sh_audio->stream_delay;
1129
1130 } // if(sh_audio)
1131
1132 decoded_frameno=0;
1133
1134 signal(SIGINT,exit_sighandler);  // Interrupt from keyboard
1135 signal(SIGQUIT,exit_sighandler); // Quit from keyboard
1136 signal(SIGTERM,exit_sighandler); // kill
1137 signal(SIGHUP,exit_sighandler);  // broken terminal line
1138 signal(SIGPIPE,exit_sighandler); // broken pipe
1139
1140 timer_start=GetTimerMS();
1141 } // if (!curfile) // if this was the first file.
1142 else {
1143         if (!mux_a != !sh_audio) {
1144                 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_NoAudioFileMismatch);
1145                 mencoder_exit(1,NULL);
1146         }
1147         if (sh_audio && mux_a->codec == ACODEC_COPY) {
1148                 if (playback_speed != 1.0) mp_msg(MSGT_CPLAYER, MSGL_WARN, MSGTR_NoSpeedWithFrameCopy);
1149                 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ACodecFramecopy,
1150                        mux_a->wf->wFormatTag, mux_a->wf->nChannels, mux_a->wf->nSamplesPerSec,
1151                        mux_a->wf->wBitsPerSample, mux_a->wf->nAvgBytesPerSec, mux_a->h.dwSampleSize);
1152                 if (sh_audio->wf) {
1153                         if ((mux_a->wf->wFormatTag != sh_audio->wf->wFormatTag) ||
1154                             (mux_a->wf->nChannels != sh_audio->wf->nChannels) ||
1155                             (mux_a->wf->nSamplesPerSec != sh_audio->wf->nSamplesPerSec * playback_speed))
1156                         {
1157                                 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ACodecFramecopy,
1158                                        sh_audio->wf->wFormatTag, sh_audio->wf->nChannels, (int)(sh_audio->wf->nSamplesPerSec * playback_speed),
1159                                        sh_audio->wf->wBitsPerSample, sh_audio->wf->nAvgBytesPerSec, 0);
1160                                 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_AudioCopyFileMismatch);
1161                                 mencoder_exit(1,NULL);
1162                         }
1163                 } else {
1164                         if ((mux_a->wf->wFormatTag != sh_audio->format) ||
1165                             (mux_a->wf->nChannels != sh_audio->channels) ||
1166                             (mux_a->wf->nSamplesPerSec != sh_audio->samplerate * playback_speed))
1167                         {
1168                                 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_ACodecFramecopy,
1169                                        sh_audio->wf->wFormatTag, sh_audio->wf->nChannels, (int)(sh_audio->wf->nSamplesPerSec * playback_speed),
1170                                        sh_audio->wf->wBitsPerSample, sh_audio->wf->nAvgBytesPerSec, 0);
1171                                 mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_AudioCopyFileMismatch);
1172                                 mencoder_exit(1,NULL);
1173                         }
1174                 }
1175         } else if (sh_audio) {
1176                 int out_srate = mux_a->wf->nSamplesPerSec;
1177                 int out_channels = mux_a->wf->nChannels;
1178                 int out_format = aencoder->input_format;
1179                 if (!init_audio_filters(sh_audio, new_srate,
1180                                         &out_srate, &out_channels,
1181                                         &out_format)) {
1182                         mp_msg(MSGT_CPLAYER, MSGL_FATAL, MSGTR_NoMatchingFilter);
1183                         mencoder_exit(1, NULL);
1184                 }
1185                 mux_a->wf->nSamplesPerSec = out_srate;
1186                 mux_a->wf->nChannels = out_channels;
1187         }
1188 }
1189
1190 if (seek_to_sec) {
1191     demux_seek(demuxer, seek_to_sec, audio_delay, 1);
1192 //  there is 2 way to handle the -ss option in 3-pass mode:
1193 // > 1. do the first pass for the whole file, and use -ss for 2nd/3rd pases only
1194 // > 2. do all the 3 passes with the same -ss value
1195 //  this line enables behaviour 1. (and kills 2. at the same time):
1196 //    if(demuxer2) demux_seek(demuxer2, d, audio_delay, 1);
1197 }
1198
1199 if (out_file_format == MUXER_TYPE_MPEG)
1200         {
1201         if (audio_preload > 0.4) {
1202           mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_LimitingAudioPreload);
1203           audio_preload = 0.4;
1204         }
1205         if (audio_density < 4) {
1206           mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_IncreasingAudioDensity);
1207           audio_density = 4;
1208         }
1209         }
1210
1211 if(file_format == DEMUXER_TYPE_TV)
1212         {
1213         mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_ZeroingAudioPreloadAndMaxPtsCorrection);
1214         audio_preload = 0.0;
1215         default_max_pts_correction = 0;
1216         }
1217
1218 play_n_frames=play_n_frames_mf;
1219 if (curfile && end_at.type == END_AT_TIME) end_at.pos += adjusted_muxer_time(mux_v);
1220
1221 if (edl_records) free_edl(edl_records);
1222 next_edl_record = edl_records = NULL;
1223 edl_muted = 0;
1224 edl_seeking = 1;
1225 if (edl_filename) {
1226     next_edl_record = edl_records = edl_parse_file();
1227 }
1228
1229 if (sh_audio && audio_delay != 0.) fixdelay(d_video, d_audio, mux_a, &frame_data, mux_v->codec==VCODEC_COPY);
1230
1231 // Just assume a seek. Also works if time stamps do not start with 0
1232 did_seek = 1;
1233
1234 while(!at_eof){
1235
1236     int blit_frame=0;
1237     float a_pts=0;
1238     float v_pts=0;
1239     int skip_flag=0; // 1=skip  -1=duplicate
1240     double a_muxer_time;
1241     double v_muxer_time;
1242
1243     a_muxer_time = adjusted_muxer_time(mux_a);
1244     v_muxer_time = adjusted_muxer_time(mux_v);
1245
1246     if((end_at.type == END_AT_SIZE && end_at.pos <= stream_tell(muxer->stream))  ||
1247        (end_at.type == END_AT_TIME && end_at.pos < v_muxer_time))
1248         break;
1249
1250     if(play_n_frames>=0){
1251       --play_n_frames;
1252       if(play_n_frames<0) break;
1253     }
1254     if(dvd_last_chapter>0) {
1255       int cur_chapter = demuxer_get_current_chapter(demuxer);
1256       if(cur_chapter!=-1 && cur_chapter+1>dvd_last_chapter)
1257         break;
1258     }
1259
1260 goto_redo_edl:
1261     if (next_edl_record && sh_video && sh_video->pts >= next_edl_record->start_sec) {
1262         if (next_edl_record->action == EDL_SKIP && edl_seeking) {
1263             float last_pos = d_video->pts;
1264             int result;
1265             mp_msg(MSGT_CPLAYER, MSGL_DBG4, "EDL_SKIP: start [%f], stop [%f], length [%f]\n",
1266                    next_edl_record->start_sec, next_edl_record->stop_sec, next_edl_record->length_sec);
1267
1268             result = edl_seek(next_edl_record, demuxer, d_audio, mux_a, &frame_data, mux_v->codec==VCODEC_COPY);
1269
1270             if (result == 2) { at_eof=1; break; } // EOF
1271             else if (result == 0) edl_seeking = 0; // no seeking
1272             else { // sucess
1273                 did_seek = 1;
1274                 edl_muted = 0;
1275                 if (last_pos >= sh_video->pts) {
1276                     // backwards seek detected!! Forget about this EDL skip altogether.
1277                     next_edl_record = next_edl_record->next;
1278                 }
1279                 else for (next_edl_record = edl_records; next_edl_record; next_edl_record = next_edl_record->next) {
1280                     /* note the use of stop_sec,
1281                        meaning if by some magical way we landed in the MIDDLE of a censored area,
1282                        in the next loop it will jump out of it.
1283                     */
1284                     if (next_edl_record->stop_sec > sh_video->pts) break; // we got to the right place.
1285                     if (next_edl_record->action == EDL_MUTE) edl_muted = !edl_muted; // toggle mute each time.
1286                 }
1287
1288                 /* for a pedantic EDL, that doesn't show even a single
1289                    frame from the "censored" area, uncomment next line. */
1290                 goto goto_redo_edl;
1291             }
1292         } else if (next_edl_record->action == EDL_MUTE) {
1293             edl_muted = !edl_muted;  // This variable does nothing for now.
1294             mp_msg(MSGT_CPLAYER, MSGL_DBG4, "EDL_MUTE: [%f]\n", next_edl_record->start_sec );
1295             next_edl_record=next_edl_record->next;
1296         }
1297     }
1298
1299
1300 if(sh_audio){
1301     // get audio:
1302     while(a_muxer_time-audio_preload<v_muxer_time){
1303         float tottime;
1304         int len=0;
1305
1306         ptimer_start = GetTimerMS();
1307         // CBR - copy 0.5 sec of audio
1308         // or until the end of video:
1309         tottime = stop_time(demuxer, mux_v);
1310         if (tottime != -1) {
1311                 tottime -= a_muxer_time;
1312                 if (tottime > 1./audio_density) tottime = 1./audio_density;
1313         }
1314         else tottime = 1./audio_density;
1315
1316         // let's not output more audio than necessary
1317         if (tottime <= 0) break;
1318
1319         if(aencoder)
1320         {
1321                 if(mux_a->h.dwSampleSize) /* CBR */
1322                 {
1323                         if(aencoder->set_decoded_len)
1324                         {
1325                                 len = mux_a->h.dwSampleSize*(int)(mux_a->h.dwRate*tottime);
1326                                 aencoder->set_decoded_len(aencoder, len);
1327                         }
1328                         else
1329                                 len = aencoder->decode_buffer_size;
1330
1331                         len = dec_audio(sh_audio, aencoder->decode_buffer, len);
1332                         mux_a->buffer_len += aencoder->encode(aencoder, mux_a->buffer + mux_a->buffer_len,
1333                                 aencoder->decode_buffer, len, mux_a->buffer_size-mux_a->buffer_len);
1334                         if(mux_a->buffer_len < mux_a->wf->nBlockAlign)
1335                                 len = 0;
1336                         else
1337                                 len = mux_a->wf->nBlockAlign*(mux_a->buffer_len/mux_a->wf->nBlockAlign);
1338                 }
1339                 else    /* VBR */
1340                 {
1341                         int sz = 0;
1342                         while(1)
1343                         {
1344                                 len = 0;
1345                                 if(! sz)
1346                                         sz = aencoder->get_frame_size(aencoder);
1347                                 if(sz > 0 && mux_a->buffer_len >= sz)
1348                                 {
1349                                         len = sz;
1350                                         break;
1351                                 }
1352                                 len = dec_audio(sh_audio,aencoder->decode_buffer, aencoder->decode_buffer_size);
1353                                 if(len <= 0)
1354                                 {
1355                                         len = 0;
1356                                         break;
1357                                 }
1358                                 len = aencoder->encode(aencoder, mux_a->buffer + mux_a->buffer_len, aencoder->decode_buffer, len, mux_a->buffer_size-mux_a->buffer_len);
1359                                 mux_a->buffer_len += len;
1360                         }
1361             }
1362             if (v_muxer_time == 0) mux_a->h.dwInitialFrames++;
1363         }
1364         else {
1365         if(mux_a->h.dwSampleSize){
1366             switch(mux_a->codec){
1367             case ACODEC_COPY: // copy
1368                 len=mux_a->wf->nAvgBytesPerSec*tottime;
1369                 len/=mux_a->h.dwSampleSize;if(len<1) len=1;
1370                 len*=mux_a->h.dwSampleSize;
1371                 len=demux_read_data(sh_audio->ds,mux_a->buffer,len);
1372                 break;
1373             }
1374         } else {
1375             // VBR - encode/copy an audio frame
1376             switch(mux_a->codec){
1377             case ACODEC_COPY: // copy
1378                 len=ds_get_packet(sh_audio->ds,(unsigned char**) &mux_a->buffer);
1379                 break;
1380                 }
1381             }
1382         }
1383         if(len<=0) break; // EOF?
1384         muxer_write_chunk(mux_a,len,AVIIF_KEYFRAME, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
1385         a_muxer_time = adjusted_muxer_time(mux_a); // update after muxing
1386         if(!mux_a->h.dwSampleSize && a_muxer_time>0)
1387             mux_a->wf->nAvgBytesPerSec=0.5f+(double)mux_a->size/a_muxer_time; // avg bps (VBR)
1388         if(mux_a->buffer_len>=len){
1389             mux_a->buffer_len-=len;
1390             memmove(mux_a->buffer,mux_a->buffer+len,mux_a->buffer_len);
1391         }
1392
1393
1394         audiosamples++;
1395         audiorate+= (GetTimerMS() - ptimer_start);
1396
1397     }
1398 }
1399
1400     // get video frame!
1401
1402     if (!frame_data.already_read) {
1403         frame_data.in_size=video_read_frame(sh_video,&frame_data.frame_time,&frame_data.start,force_fps);
1404         frame_data.flush = frame_data.in_size < 0 && d_video->eof &&
1405                            mux_v->codec != VCODEC_COPY &&
1406                            mux_v->codec != VCODEC_FRAMENO;
1407         if (frame_data.flush) {
1408             frame_data.in_size = 0;
1409             frame_data.start = NULL;
1410         }
1411         sh_video->timer+=frame_data.frame_time;
1412     }
1413     frame_data.frame_time /= playback_speed;
1414     if(frame_data.in_size<0){ at_eof=1; break; }
1415     ++decoded_frameno;
1416
1417     v_timer_corr-=frame_data.frame_time-(float)mux_v->h.dwScale/mux_v->h.dwRate;
1418
1419 if(demuxer2){   // 3-pass encoding, read control file (frameno.avi)
1420     // find our frame:
1421         while(next_frameno<decoded_frameno){
1422             int* start;
1423             int len=ds_get_packet(demuxer2->video,(unsigned char**) &start);
1424             if(len<0){ at_eof=1;break;}
1425             if(len==0) --skip_flag; else  // duplicate
1426             if(len==4) next_frameno=start[0];
1427         }
1428     if(at_eof) break;
1429         skip_flag=next_frameno-decoded_frameno;
1430     // find next frame:
1431         while(next_frameno<=decoded_frameno){
1432             int* start;
1433             int len=ds_get_packet(demuxer2->video,(unsigned char**) &start);
1434             if(len<0){ at_eof=1;break;}
1435             if(len==0) --skip_flag; else  // duplicate
1436             if(len==4) next_frameno=start[0];
1437         }
1438 } else {
1439
1440 // check frame duplicate/drop:
1441
1442 float mux_frametime = (float)mux_v->h.dwScale/mux_v->h.dwRate;
1443
1444 if (v_timer_corr >= mux_frametime && (skip_limit<0 || skip_flag < skip_limit)) {
1445     v_timer_corr-=mux_frametime;
1446     ++skip_flag; // skip
1447 }
1448 while (v_timer_corr <= -mux_frametime && (skip_limit<0 || -skip_flag < skip_limit)) {
1449     v_timer_corr+=mux_frametime;
1450     --skip_flag; // dup
1451 }
1452
1453 // either v_pts_corr is big, more than 2 times framerate, then we follow its advice,
1454 // or, it cancels out v_timer_corr, in which case be happy and do nothing.
1455
1456 while ((v_pts_corr <= -mux_frametime && skip_flag > 0) || (v_pts_corr <= -2*mux_frametime)) {
1457     v_pts_corr+=mux_frametime;
1458     --skip_flag; // dup
1459 }
1460 if ((v_pts_corr >= mux_frametime && skip_flag < 0) || (v_pts_corr >= 2*mux_frametime)) {
1461   if (skip_flag<=0) { // we can't skip more than 1 frame now
1462     v_pts_corr-=mux_frametime;
1463     ++skip_flag; // skip
1464   }
1465 }
1466
1467 } // demuxer2
1468
1469 ptimer_start = GetTimerMS();
1470
1471 switch(mux_v->codec){
1472 case VCODEC_COPY:
1473     mux_v->buffer=frame_data.start;
1474     if(skip_flag<=0) muxer_write_chunk(mux_v,frame_data.in_size,(sh_video->ds->flags&1)?AVIIF_KEYFRAME:0, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
1475     break;
1476 case VCODEC_FRAMENO:
1477     mux_v->buffer=(unsigned char *)&decoded_frameno; // tricky
1478     if(skip_flag<=0) muxer_write_chunk(mux_v,sizeof(int),AVIIF_KEYFRAME, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
1479     break;
1480 default:
1481     // decode_video will callback down to ve_*.c encoders, through the video filters
1482     {
1483     int drop_frame = skip_flag > 0 &&
1484                      (!sh_video->vfilter ||
1485                       ((vf_instance_t *)sh_video->vfilter)->control(sh_video->vfilter, VFCTRL_SKIP_NEXT_FRAME, 0) != CONTROL_TRUE);
1486     void *decoded_frame = decode_video(sh_video,frame_data.start,frame_data.in_size,
1487                                        drop_frame, MP_NOPTS_VALUE, NULL);
1488     if (frame_data.flush && !decoded_frame)
1489         at_eof = 1;
1490     if (did_seek && sh_video->pts != MP_NOPTS_VALUE) {
1491         did_seek = 0;
1492         sub_offset = sh_video->pts;
1493     }
1494     // NOTE: this is not really correct, but it allows -ass to work mostly
1495     // v_muxer_time was tried before, but it is completely off when -ss is used
1496     // (see bug #1960).
1497     // sh_video->pts causes flickering with subtitles and complaints from MPEG-4
1498     // encoder due to not being monotonic.
1499     // If you change this please note the reason here!
1500     blit_frame = decoded_frame && filter_video(sh_video, decoded_frame, v_muxer_time + sub_offset);}
1501     v_muxer_time = adjusted_muxer_time(mux_v); // update after muxing
1502
1503     if (sh_video->vf_initialized < 0) mencoder_exit(1, NULL);
1504
1505     if(!blit_frame){
1506       if (play_n_frames >= 0)
1507         play_n_frames++;
1508       badframes++;
1509       if(skip_flag<=0){
1510         // unwanted skipping of a frame, what to do?
1511         v_timer_corr-=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1512 #if 0
1513         // Old code apparently made under the assumption that !blit_frame means
1514         // decoding failed due to corruption or something.. but duplication and
1515         // skipping of frames should be entirely disabled when skip_limit==0,
1516         // and must be in order for many filters to work with -noskip.
1517         // Eventually this entire block should probably be removed.
1518         if(skip_limit==0){
1519             // skipping not allowed -> write empty frame:
1520             if (!encode_duplicates || !sh_video->vfilter || ((vf_instance_t *)sh_video->vfilter)->control(sh_video->vfilter, VFCTRL_DUPLICATE_FRAME, 0) != CONTROL_TRUE)
1521               muxer_write_chunk(mux_v,0,0, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
1522         } else {
1523             // skipping allowed -> skip it and distriubute timer error:
1524             v_timer_corr-=(float)mux_v->h.dwScale/mux_v->h.dwRate;
1525         }
1526 #endif
1527       }
1528     }
1529 }
1530
1531 videosamples++;
1532 videorate+=(GetTimerMS() - ptimer_start);
1533
1534 if(skip_flag<0){
1535     // duplicate frame
1536         if(!quiet) mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_DuplicateFrames,-skip_flag);
1537     while(skip_flag<0){
1538         duplicatedframes++;
1539         if (!encode_duplicates || !sh_video->vfilter || ((vf_instance_t *)sh_video->vfilter)->control(sh_video->vfilter, VFCTRL_DUPLICATE_FRAME, 0) != CONTROL_TRUE)
1540             muxer_write_chunk(mux_v,0,0, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
1541         ++skip_flag;
1542     }
1543 } else
1544 if(skip_flag>0){
1545     // skip frame
1546         if(!quiet) mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_SkipFrame);
1547         skippedframes++;
1548     --skip_flag;
1549 }
1550
1551 if(sh_audio && !demuxer2){
1552     float AV_delay,x;
1553     // A-V sync!
1554 #if 0
1555     if(pts_from_bps){
1556         unsigned int samples=(sh_audio->audio.dwSampleSize)?
1557           ((ds_tell(d_audio)-sh_audio->a_in_buffer_len)/sh_audio->audio.dwSampleSize) :
1558           (d_audio->block_no); // <- used for VBR audio
1559         a_pts=samples*(float)sh_audio->audio.dwScale/(float)sh_audio->audio.dwRate;
1560     } else
1561 #endif
1562     {
1563       // PTS = (last timestamp) + (bytes after last timestamp)/(bytes per sec)
1564       a_pts=calc_a_pts(sh_audio, d_audio);
1565     }
1566     v_pts=sh_video ? sh_video->pts : d_video->pts;
1567     // av = compensated (with out buffering delay) A-V diff
1568     AV_delay=(a_pts-v_pts);
1569     AV_delay-=audio_delay;
1570     AV_delay /= playback_speed;
1571     AV_delay-=a_muxer_time-(v_muxer_time-(v_timer_corr+v_pts_corr));
1572         // compensate input video timer by av:
1573         x=AV_delay*0.1f;
1574         if(x<-max_pts_correction) x=-max_pts_correction; else
1575         if(x> max_pts_correction) x= max_pts_correction;
1576         if(default_max_pts_correction>=0)
1577           max_pts_correction=default_max_pts_correction*playback_speed;
1578         else
1579           max_pts_correction=sh_video->frametime*0.10 *playback_speed; // +-10% of time
1580         // sh_video->timer-=x;
1581         c_total+=x;
1582         v_pts_corr+=x;
1583 }
1584
1585     {   float t=(GetTimerMS()-timer_start)*0.001f;
1586         float len=(demuxer->movi_end-demuxer->movi_start);
1587         off_t pos = demuxer->filepos >= 0 ? demuxer->filepos : stream_tell(demuxer->stream);
1588         float p=len>1000 ? (float)(pos-demuxer->movi_start) / len :
1589                 (demuxer_get_percent_pos(demuxer) / 100.0);
1590 #if 0
1591         if(!len && sh_audio && sh_audio->audio.dwLength>100){
1592             p=(sh_audio->audio.dwSampleSize? ds_tell(sh_audio->ds)/sh_audio->audio.dwSampleSize : sh_audio->ds->block_no)
1593              / (float)(sh_audio->audio.dwLength);
1594         }
1595 #endif
1596       if(!quiet) {
1597         if( mp_msg_test(MSGT_STATUSLINE,MSGL_V) ) {
1598                 mp_msg(MSGT_STATUSLINE,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",
1599                 v_muxer_time, decoded_frameno, (int)(p*100),
1600                 (t>1) ? (int)(decoded_frameno/t+0.5) : 0,
1601                 (p>0.001) ? (int)((t/p-t)/60) : 0,
1602                 (p>0.001) ? (int)(stream_tell(muxer->stream)/p/1024/1024) : 0,
1603                 v_pts_corr,
1604                 (v_muxer_time>1) ? (int)(mux_v->size/v_muxer_time/125) : 0,
1605                 (mux_a && a_muxer_time>1) ? (int)(mux_a->size/a_muxer_time/125) : 0,
1606                         audiorate/audiosamples, videorate/videosamples,
1607                         duplicatedframes, badframes, skippedframes
1608                 );
1609         } else
1610         mp_msg(MSGT_STATUSLINE,MSGL_STATUS,"Pos:%6.1fs %6df (%2d%%) %5.2ffps Trem:%4dmin %3dmb  A-V:%5.3f [%d:%d]\r",
1611             v_muxer_time, decoded_frameno, (int)(p*100),
1612             (t>1) ? (float)(decoded_frameno/t) : 0,
1613             (p>0.001) ? (int)((t/p-t)/60) : 0,
1614             (p>0.001) ? (int)(stream_tell(muxer->stream)/p/1024/1024) : 0,
1615             v_pts_corr,
1616             (v_muxer_time>1) ? (int)(mux_v->size/v_muxer_time/125) : 0,
1617             (mux_a && a_muxer_time>1) ? (int)(mux_a->size/a_muxer_time/125) : 0
1618         );
1619       }
1620     }
1621         fflush(stdout);
1622
1623 #ifdef CONFIG_DVDREAD
1624 // DVD sub:
1625  if(vobsub_writer){
1626      unsigned char* packet=NULL;
1627      int len;
1628      while((len=ds_get_packet_sub(d_dvdsub,&packet, NULL, NULL))>0){
1629          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);
1630              vobsub_out_output(vobsub_writer,packet,len,v_muxer_time + d_dvdsub->pts - sh_video->pts);
1631      }
1632  }
1633  else
1634 #endif
1635     update_subtitles(sh_video, sh_video->pts, d_dvdsub, 0);
1636
1637  frame_data = (s_frame_data){ .start = NULL, .in_size = 0, .frame_time = 0., .already_read = 0 };
1638
1639 #if 0
1640  if(ferror(muxer_f)) {
1641      mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_ErrorWritingFile, out_filename);
1642      mencoder_exit(1, NULL);
1643  }
1644 #endif
1645
1646 } // while(!at_eof)
1647
1648 if (!interrupted && filelist[++curfile].name != 0) {
1649         if (sh_video && sh_video->vfilter) { // Before uniniting sh_video and the filter chain, break apart the VE.
1650                 vf_instance_t * ve; // this will be the filter right before the ve.
1651                 for (ve = sh_video->vfilter; ve->next && ve->next->next; ve = ve->next);
1652
1653                 if (ve->next) ve->next = NULL; // I'm telling the last filter, before the VE, there is nothing after it
1654                 else sh_video->vfilter = NULL; // There is no chain except the VE.
1655         }
1656
1657         if(sh_audio){ uninit_audio(sh_audio);sh_audio=NULL; }
1658         if(sh_video){ uninit_video(sh_video);sh_video=NULL; }
1659         if(demuxer) free_demuxer(demuxer);
1660         if(stream) free_stream(stream); // kill cache thread
1661
1662         at_eof = 0;
1663
1664         m_config_pop(mconfig);
1665         goto play_next_file;
1666 }
1667
1668 /* Emit the remaining frames in the video system */
1669 /*TODO emit frmaes delayed by decoder lag*/
1670 if(sh_video && sh_video->vfilter){
1671         mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_FlushingVideoFrames);
1672         if (!((vf_instance_t *)sh_video->vfilter)->fmt.have_configured)
1673                 mp_msg(MSGT_MENCODER, MSGL_WARN, MSGTR_FiltersHaveNotBeenConfiguredEmptyFile);
1674         else
1675                 ((vf_instance_t *)sh_video->vfilter)->control(sh_video->vfilter,
1676                                                       VFCTRL_FLUSH_FRAMES, 0);
1677 }
1678
1679 if(aencoder)
1680     if(aencoder->fixup)
1681         aencoder->fixup(aencoder);
1682
1683 /* flush muxer just in case, this is a no-op unless
1684  * we created a stream but never wrote frames to it... */
1685 muxer_flush(muxer);
1686 if (muxer->cont_write_index) muxer_write_index(muxer);
1687 muxer_f_size=stream_tell(muxer->stream);
1688 stream_seek(muxer->stream,0);
1689 if (muxer->cont_write_header) muxer_write_header(muxer); // update header
1690 #if 0
1691 if(ferror(muxer_f) || fclose(muxer_f) != 0) {
1692     mp_msg(MSGT_MENCODER,MSGL_FATAL,MSGTR_ErrorWritingFile, out_filename);
1693     mencoder_exit(1, NULL);
1694 }
1695 #endif
1696 if(vobsub_writer)
1697     vobsub_out_close(vobsub_writer);
1698
1699 if(out_video_codec==VCODEC_FRAMENO && mux_v->timer>100){
1700     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_RecommendedVideoBitrate,"650MB",(int)((650*1024*1024-muxer_f_size)/mux_v->timer/125));
1701     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_RecommendedVideoBitrate,"700MB",(int)((700*1024*1024-muxer_f_size)/mux_v->timer/125));
1702     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_RecommendedVideoBitrate,"800MB",(int)((800*1024*1024-muxer_f_size)/mux_v->timer/125));
1703     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_RecommendedVideoBitrate,"2 x 650MB",(int)((2*650*1024*1024-muxer_f_size)/mux_v->timer/125));
1704     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_RecommendedVideoBitrate,"2 x 700MB",(int)((2*700*1024*1024-muxer_f_size)/mux_v->timer/125));
1705     mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_RecommendedVideoBitrate,"2 x 800MB",(int)((2*800*1024*1024-muxer_f_size)/mux_v->timer/125));
1706 }
1707
1708 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_VideoStreamResult,
1709     (float)(mux_v->size/mux_v->timer*8.0f/1000.0f), (int)(mux_v->size/mux_v->timer), (uint64_t)mux_v->size, (float)mux_v->timer, decoded_frameno);
1710 if(sh_audio)
1711 mp_msg(MSGT_MENCODER, MSGL_INFO, MSGTR_AudioStreamResult,
1712     (float)(mux_a->size/mux_a->timer*8.0f/1000.0f), (int)(mux_a->size/mux_a->timer), (uint64_t)mux_a->size, (float)mux_a->timer);
1713
1714 if(sh_audio){ uninit_audio(sh_audio);sh_audio=NULL; }
1715 if(sh_video){ uninit_video(sh_video);sh_video=NULL; }
1716 if(demuxer) free_demuxer(demuxer);
1717 if(stream) free_stream(stream); // kill cache thread
1718
1719 return interrupted;
1720 }