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