1972a9eca9634824856e1427aecf285b0860e038
[goodguy/history.git] / cinelerra-5.0 / cinelerra / fileffmpeg.C
1
2 #include <stdio.h>
3 #include <stdint.h>
4 #include <stdlib.h>
5 #include <unistd.h>
6 #include <string.h>
7 // work around for __STDC_CONSTANT_MACROS
8 #include <lzma.h>
9
10 #include "asset.h"
11 #include "bcwindowbase.h"
12 #include "bcprogressbox.h"
13 #include "bitspopup.h"
14 #include "ffmpeg.h"
15 #include "filebase.h"
16 #include "file.h"
17 #include "fileffmpeg.h"
18 #include "filesystem.h"
19 #include "format.inc"
20 #include "indexfile.h"
21 #include "mutex.h"
22 #include "preferences.h"
23 #include "videodevice.inc"
24
25 FileFFMPEG::FileFFMPEG(Asset *asset, File *file)
26   : FileBase(asset, file)
27 {
28         ff = 0;
29         if(asset->format == FILE_UNKNOWN)
30                 asset->format = FILE_FFMPEG;
31 }
32
33 FileFFMPEG::~FileFFMPEG()
34 {
35         delete ff;
36 }
37
38
39 FFMpegConfigNum::FFMpegConfigNum(BC_Window *window,
40                 int x, int y, char *title_text, int *output)
41  : BC_TumbleTextBox(window, (int64_t)*output,
42         (int64_t)-1, (int64_t)25000000, 100, y, 100)
43 {
44         this->window = window;
45         this->x = x;  this->y = y;
46         this->title_text = title_text;
47         this->output = output;
48 }
49
50 FFMpegConfigNum::~FFMpegConfigNum()
51 {
52 }
53
54 void FFMpegConfigNum::create_objects()
55 {
56         window->add_subwindow(title = new BC_Title(x, y, title_text));
57         BC_TumbleTextBox::create_objects();
58 }
59
60 int FFMpegConfigNum::handle_event()
61 {
62         *output = atol(get_text());
63         return 1;
64 }
65
66 FFMpegAudioNum::FFMpegAudioNum(BC_Window *window,
67                 int x, int y, char *title_text, int *output)
68  : FFMpegConfigNum(window, x, y, title_text, output)
69 {
70 }
71
72 int FFMpegAudioBitrate::handle_event()
73 {
74         int ret = FFMpegAudioNum::handle_event();
75         return ret;
76 }
77
78 FFMpegVideoNum::FFMpegVideoNum(BC_Window *window,
79                 int x, int y, char *title_text, int *output)
80  : FFMpegConfigNum(window, x, y, title_text, output)
81 {
82 }
83
84 int FFMpegVideoBitrate::handle_event()
85 {
86         int ret = FFMpegVideoNum::handle_event();
87         Asset *asset = window()->asset;
88         if( asset->ff_video_bitrate )
89                 window()->quality->disable();
90         else
91                 window()->quality->enable();
92         return ret;
93 }
94
95 int FFMpegVideoQuality::handle_event()
96 {
97         int ret = FFMpegVideoNum::handle_event();
98         Asset *asset = window()->asset;
99         if( asset->ff_video_quality )
100                 window()->bitrate->disable();
101         else
102                 window()->bitrate->enable();
103         return ret;
104 }
105
106 void FileFFMPEG::get_parameters(BC_WindowBase *parent_window,
107                 Asset *asset, BC_WindowBase *&format_window,
108                 int audio_options, int video_options)
109 {
110         if(audio_options) {
111                 FFMPEGConfigAudio *window = new FFMPEGConfigAudio(parent_window, asset);
112                 format_window = window;
113                 window->create_objects();
114                 window->run_window();
115                 delete window;
116         }
117         else if(video_options) {
118                 FFMPEGConfigVideo *window = new FFMPEGConfigVideo(parent_window, asset);
119                 format_window = window;
120                 window->create_objects();
121                 window->run_window();
122                 delete window;
123         }
124 }
125
126 int FileFFMPEG::check_sig(Asset *asset)
127 {
128         char *ptr = strstr(asset->path, ".pcm");
129         if( ptr ) return 0;
130         ptr = strstr(asset->path, ".raw");
131         if( ptr ) return 0;
132
133         FFMPEG ffmpeg(0);
134         int ret = !ffmpeg.init_decoder(asset->path) &&
135                 !ffmpeg.open_decoder() ? 1 : 0;
136         return ret;
137 }
138
139 void FileFFMPEG::get_info(char *path, char *text, int len)
140 {
141         char *cp = text;
142         FFMPEG ffmpeg(0);
143         cp += sprintf(cp, _("file path: %s\n"), path);
144         struct stat st;
145         int ret = 0;
146         if( stat(path, &st) < 0 ) {
147                 cp += sprintf(cp, _(" err: %s\n"), strerror(errno));
148                 ret = 1;
149         }
150         else {
151                 cp += sprintf(cp, _("  %jd bytes\n"), st.st_size);
152         }
153         if( !ret ) ret = ffmpeg.init_decoder(path);
154         if( !ret ) ret = ffmpeg.open_decoder();
155         if( !ret ) {
156                 cp += sprintf(cp, _("info:\n"));
157                 ffmpeg.info(cp, len-(cp-text));
158         }
159         else
160                 sprintf(cp, _("== open failed\n"));
161 }
162
163 int FileFFMPEG::get_video_info(int track, int &pid, double &framerate,
164                 int &width, int &height, char *title)
165 {
166         if( !ff ) return -1;
167         pid = ff->ff_video_pid(track);
168         framerate = ff->ff_frame_rate(track);
169         width = ff->ff_video_width(track);
170         height = ff->ff_video_height(track);
171         if( title ) *title = 0;
172         return 0;
173 }
174
175 int FileFFMPEG::get_audio_for_video(int vstream, int astream, int64_t &channel_mask)
176 {
177         if( !ff ) return 1;
178         return ff->ff_audio_for_video(vstream, astream, channel_mask);
179 }
180
181 int FileFFMPEG::select_video_stream(Asset *asset, int vstream)
182 {
183         if( !ff || !asset->video_data ) return 1;
184         asset->width = ff->ff_video_width(vstream);
185         asset->height = ff->ff_video_height(vstream);
186         asset->video_length = ff->ff_video_frames(vstream);
187         asset->frame_rate = ff->ff_frame_rate(vstream);
188         return 0;
189 }
190
191 int FileFFMPEG::select_audio_stream(Asset *asset, int astream)
192 {
193         if( !ff || !asset->audio_data ) return 1;
194         asset->sample_rate = ff->ff_sample_rate(astream);
195         asset->audio_length = ff->ff_audio_samples(astream);
196         return 0;
197 }
198
199 int FileFFMPEG::open_file(int rd, int wr)
200 {
201         int result = 0;
202         if( ff ) return 1;
203         ff = new FFMPEG(this);
204
205         if( rd ) {
206                 result = ff->init_decoder(asset->path);
207                 if( !result ) result = ff->open_decoder();
208                 if( !result ) {
209                         int audio_channels = ff->ff_total_audio_channels();
210                         if( audio_channels > 0 ) {
211                                 asset->audio_data = 1;
212                                 asset->channels = audio_channels;
213                                 asset->sample_rate = ff->ff_sample_rate(0);
214                                 asset->audio_length = ff->ff_audio_samples(0);
215                         }
216                         int video_layers = ff->ff_total_video_layers();
217                         if( video_layers > 0 ) {
218                                 asset->video_data = 1;
219                                 if( !asset->layers ) asset->layers = video_layers;
220                                 asset->actual_width = ff->ff_video_width(0);
221                                 asset->actual_height = ff->ff_video_height(0);
222                                 if( !asset->width ) asset->width = asset->actual_width;
223                                 if( !asset->height ) asset->height = asset->actual_height;
224                                 if( !asset->video_length ) asset->video_length = ff->ff_video_frames(0);
225                                 if( !asset->frame_rate ) asset->frame_rate = ff->ff_frame_rate(0);
226                         }
227                         IndexState *index_state = asset->index_state;
228                         index_state->read_markers(file->preferences->index_directory, asset->path);
229                 }
230         }
231         else if( wr ) {
232                 result = ff->init_encoder(asset->path);
233                 // must be in this order or dvdauthor will fail
234                 if( !result && asset->video_data )
235                         result = ff->open_encoder("video", asset->vcodec);
236                 if( !result && asset->audio_data )
237                         result = ff->open_encoder("audio", asset->acodec);
238         }
239         return result;
240 }
241
242 int FileFFMPEG::close_file()
243 {
244         delete ff;
245         ff = 0;
246         return 0;
247 }
248
249
250 int FileFFMPEG::write_samples(double **buffer, int64_t len)
251 {
252         if( !ff || len < 0 ) return -1;
253         int stream = 0;
254         int ret = ff->encode(stream, buffer, len);
255         return ret;
256 }
257
258 int FileFFMPEG::write_frames(VFrame ***frames, int len)
259 {
260         if( !ff ) return -1;
261         int ret = 0, layer = 0;
262         for(int i = 0; i < 1; i++) {
263                 for(int j = 0; j < len && !ret; j++) {
264                         VFrame *frame = frames[i][j];
265                         ret = ff->encode(layer, frame);
266                 }
267         }
268         return ret;
269 }
270
271
272 int FileFFMPEG::read_samples(double *buffer, int64_t len)
273 {
274         if( !ff || len < 0 ) return -1;
275         int ch = file->current_channel;
276         int64_t pos = file->current_sample;
277         int ret = ff->decode(ch, pos, buffer, len);
278         if( ret > 0 ) return 0;
279         memset(buffer,0,len*sizeof(*buffer));
280         return -1;
281 }
282
283 int FileFFMPEG::read_frame(VFrame *frame)
284 {
285         if( !ff ) return -1;
286         int layer = file->current_layer;
287         int64_t pos = file->current_frame;
288         int ret = ff->decode(layer, pos, frame);
289         frame->set_status(ret);
290         if( ret >= 0 ) return 0;
291         frame->clear_frame();
292         return -1;
293 }
294
295
296 int64_t FileFFMPEG::get_memory_usage()
297 {
298         return 0;
299 }
300
301 int FileFFMPEG::colormodel_supported(int colormodel)
302 {
303         return colormodel;
304 }
305
306 int FileFFMPEG::get_best_colormodel(Asset *asset, int driver)
307 {
308         switch(driver) {
309         case PLAYBACK_X11:      return BC_RGB888;
310         case PLAYBACK_X11_GL:   return BC_YUV888;
311         }
312         return BC_YUV420P;
313 }
314
315 //======
316
317 FFMPEGConfigAudio::FFMPEGConfigAudio(BC_WindowBase *parent_window, Asset *asset)
318  : BC_Window(_(PROGRAM_NAME ": Audio Preset"),
319         parent_window->get_abs_cursor_x(1),
320         parent_window->get_abs_cursor_y(1),
321         420, 420)
322 {
323         this->parent_window = parent_window;
324         this->asset = asset;
325         preset_popup = 0;
326
327         bitrate = 0;
328         audio_options = 0;
329 }
330
331 FFMPEGConfigAudio::~FFMPEGConfigAudio()
332 {
333         lock_window("FFMPEGConfigAudio::~FFMPEGConfigAudio");
334         if(preset_popup) delete preset_popup;
335         presets.remove_all_objects();
336         unlock_window();
337 }
338
339 void FFMPEGConfigAudio::create_objects()
340 {
341         int x = 10, y = 10;
342         lock_window("FFMPEGConfigAudio::create_objects");
343
344         FileSystem fs;
345         char option_path[BCTEXTLEN];
346         FFMPEG::set_option_path(option_path, "audio");
347         fs.update(option_path);
348         int total_files = fs.total_files();
349         for(int i = 0; i < total_files; i++) {
350                 const char *name = fs.get_entry(i)->get_name();
351                 if( asset->fformat[0] != 0 ) {
352                         const char *ext = strrchr(name,'.');
353                         if( !ext ) continue;
354                         if( strcmp(asset->fformat, ++ext) ) continue;
355                 }
356                 presets.append(new BC_ListBoxItem(name));
357         }
358
359         if( asset->acodec[0] ) {
360                 int k = presets.size();
361                 while( --k >= 0 && strcmp(asset->acodec, presets[k]->get_text()) );
362                 if( k < 0 ) asset->acodec[0] = 0;
363         }
364
365         if( !asset->acodec[0] && presets.size() > 0 )
366                 strcpy(asset->acodec, presets[0]->get_text());
367
368         add_tool(new BC_Title(x, y, _("Preset:")));
369         y += 25;
370         preset_popup = new FFMPEGConfigAudioPopup(this, x, y);
371         preset_popup->create_objects();
372
373         y += 50;
374         bitrate = new FFMpegAudioBitrate(this, x, y, _("Bitrate:"), &asset->ff_audio_bitrate);
375         bitrate->create_objects();
376         bitrate->set_increment(1000);
377
378         y += bitrate->get_h() + 10;
379         add_subwindow(new BC_Title(x, y, _("Audio Options:")));
380         y += 25;
381         if( !asset->ff_audio_options[0] && asset->acodec[0] ) {
382                 FFMPEG::set_option_path(option_path, "audio/%s", asset->acodec);
383                 FFMPEG::load_options(option_path, asset->ff_audio_options,
384                          sizeof(asset->ff_audio_options));
385         }
386         add_subwindow(audio_options = new FFAudioOptions(this, x, y, get_w()-x-20, 10,
387                  sizeof(asset->ff_audio_options)-1, asset->ff_audio_options));
388         add_subwindow(new BC_OKButton(this));
389         show_window(1);
390         bitrate->handle_event();
391         unlock_window();
392 }
393
394 int FFMPEGConfigAudio::close_event()
395 {
396         set_done(0);
397         return 1;
398 }
399
400
401 FFAudioOptions::FFAudioOptions(FFMPEGConfigAudio *audio_popup,
402         int x, int y, int w, int rows, int size, char *text)
403  : BC_TextBox(x, y, w, rows, size, text)
404 {
405         this->audio_popup = audio_popup;
406 }
407
408 int FFAudioOptions::handle_event()
409 {
410         strcpy(audio_popup->asset->ff_audio_options, get_text());
411         return 1;
412 }
413
414
415 FFMPEGConfigAudioPopup::FFMPEGConfigAudioPopup(FFMPEGConfigAudio *popup, int x, int y)
416  : BC_PopupTextBox(popup, &popup->presets, popup->asset->acodec, x, y, 300, 300)
417 {
418         this->popup = popup;
419 }
420
421 int FFMPEGConfigAudioPopup::handle_event()
422 {
423         strcpy(popup->asset->acodec, get_text());
424         Asset *asset = popup->asset;
425         char option_path[BCTEXTLEN];
426         FFMPEG::set_option_path(option_path, "audio/%s", asset->acodec);
427         FFMPEG::load_options(option_path, asset->ff_audio_options,
428                          sizeof(asset->ff_audio_options));
429         popup->audio_options->update(asset->ff_audio_options);
430         return 1;
431 }
432
433
434 FFMPEGConfigAudioToggle::FFMPEGConfigAudioToggle(FFMPEGConfigAudio *popup,
435         char *title_text, int x, int y, int *output)
436  : BC_CheckBox(x, y, *output, title_text)
437 {
438         this->popup = popup;
439         this->output = output;
440 }
441 int FFMPEGConfigAudioToggle::handle_event()
442 {
443         *output = get_value();
444         return 1;
445 }
446
447
448 //======
449
450 FFMPEGConfigVideo::FFMPEGConfigVideo(BC_WindowBase *parent_window, Asset *asset)
451  : BC_Window(_(PROGRAM_NAME ": Video Preset"),
452         parent_window->get_abs_cursor_x(1),
453         parent_window->get_abs_cursor_y(1),
454         420, 420)
455 {
456         this->parent_window = parent_window;
457         this->asset = asset;
458         preset_popup = 0;
459
460         bitrate = 0;
461         quality = 0;
462         video_options = 0;
463 }
464
465 FFMPEGConfigVideo::~FFMPEGConfigVideo()
466 {
467         lock_window("FFMPEGConfigVideo::~FFMPEGConfigVideo");
468         if(preset_popup) delete preset_popup;
469         presets.remove_all_objects();
470         unlock_window();
471 }
472
473 void FFMPEGConfigVideo::create_objects()
474 {
475         int x = 10, y = 10;
476         lock_window("FFMPEGConfigVideo::create_objects");
477
478         add_subwindow(new BC_Title(x, y, _("Compression:")));
479         y += 25;
480
481         FileSystem fs;
482         char option_path[BCTEXTLEN];
483         FFMPEG::set_option_path(option_path, "video");
484         fs.update(option_path);
485         int total_files = fs.total_files();
486         for(int i = 0; i < total_files; i++) {
487                 const char *name = fs.get_entry(i)->get_name();
488                 if( asset->fformat[0] != 0 ) {
489                         const char *ext = strrchr(name,'.');
490                         if( !ext ) continue;
491                         if( strcmp(asset->fformat, ++ext) ) continue;
492                 }
493                 presets.append(new BC_ListBoxItem(name));
494         }
495
496         if( asset->vcodec[0] ) {
497                 int k = presets.size();
498                 while( --k >= 0 && strcmp(asset->vcodec, presets[k]->get_text()) );
499                 if( k < 0 ) asset->vcodec[0] = 0;
500         }
501
502         if( !asset->vcodec[0] && presets.size() > 0 )
503                 strcpy(asset->vcodec, presets[0]->get_text());
504
505         preset_popup = new FFMPEGConfigVideoPopup(this, x, y);
506         preset_popup->create_objects();
507
508         if( asset->ff_video_bitrate && asset->ff_video_quality ) {
509                 asset->ff_video_bitrate = 0;
510                 asset->ff_video_quality = 0;
511         }
512
513         y += 50;
514         bitrate = new FFMpegVideoBitrate(this, x, y, _("Bitrate:"), &asset->ff_video_bitrate);
515         bitrate->create_objects();
516         bitrate->set_increment(100000);
517         y += bitrate->get_h() + 5;
518         quality = new FFMpegVideoQuality(this, x, y, _("Quality:"), &asset->ff_video_quality);
519         quality->create_objects();
520         quality->set_increment(1);
521         quality->set_boundaries((int64_t)0, (int64_t)31);
522
523         y += quality->get_h() + 10;
524         add_subwindow(new BC_Title(x, y, _("Video Options:")));
525         y += 25;
526         if( !asset->ff_video_options[0] && asset->vcodec[0] ) {
527                 FFMPEG::set_option_path(option_path, "video/%s", asset->vcodec);
528                 FFMPEG::load_options(option_path, asset->ff_video_options,
529                          sizeof(asset->ff_video_options));
530         }
531         add_subwindow(video_options = new FFVideoOptions(this, x, y, get_w()-x-20, 10,
532                  sizeof(asset->ff_video_options)-1, asset->ff_video_options));
533
534         add_subwindow(new BC_OKButton(this));
535         show_window(1);
536         if( asset->ff_video_bitrate )
537                 quality->disable();
538         if( asset->ff_video_quality )
539                 bitrate->disable();
540         unlock_window();
541 }
542
543 int FFMPEGConfigVideo::close_event()
544 {
545         set_done(0);
546         return 1;
547 }
548
549
550 FFVideoOptions::FFVideoOptions(FFMPEGConfigVideo *video_popup,
551         int x, int y, int w, int rows, int size, char *text)
552  : BC_TextBox(x, y, w, rows, size, text)
553 {
554         this->video_popup = video_popup;
555 }
556
557 int FFVideoOptions::handle_event()
558 {
559         strcpy(video_popup->asset->ff_video_options, get_text());
560         return 1;
561 }
562
563
564 FFMPEGConfigVideoPopup::FFMPEGConfigVideoPopup(FFMPEGConfigVideo *popup, int x, int y)
565  : BC_PopupTextBox(popup, &popup->presets, popup->asset->vcodec, x, y, 300, 300)
566 {
567         this->popup = popup;
568 }
569
570 int FFMPEGConfigVideoPopup::handle_event()
571 {
572         strcpy(popup->asset->vcodec, get_text());
573         Asset *asset = popup->asset;
574         char option_path[BCTEXTLEN];
575         FFMPEG::set_option_path(option_path, "video/%s", asset->vcodec);
576         FFMPEG::load_options(option_path, asset->ff_video_options,
577                          sizeof(asset->ff_video_options));
578         popup->video_options->update(asset->ff_video_options);
579         return 1;
580 }
581
582
583 FFMPEGConfigVideoToggle::FFMPEGConfigVideoToggle(FFMPEGConfigVideo *popup,
584         char *title_text, int x, int y, int *output)
585  : BC_CheckBox(x, y, *output, title_text)
586 {
587         this->popup = popup;
588         this->output = output;
589 }
590 int FFMPEGConfigVideoToggle::handle_event()
591 {
592         *output = get_value();
593         return 1;
594 }
595
596 FFMPEGScanProgress::FFMPEGScanProgress(const char *title, int64_t length, int64_t *position, int *canceled)
597  : Thread(1, 0, 0)
598 {
599         strcpy(this->progress_title, title);
600         this->length = length;
601         this->position = position;
602         this->canceled = canceled;
603         done = 0;
604         progress = 0;
605         start();
606 }
607
608 FFMPEGScanProgress::~FFMPEGScanProgress()
609 {
610         done = 1;
611         cancel();
612         join();
613 }
614
615 void FFMPEGScanProgress::run()
616 {
617         BC_ProgressBox *progress = new BC_ProgressBox(-1, -1, progress_title, length);
618         progress->start();
619
620         struct timeval start_time, now, then;
621         gettimeofday(&start_time, 0);
622         then = start_time;
623
624         while( !done ) {
625                 if( progress->update(*position, 1) ) {
626                         *canceled = done = 1;
627                         break;
628                 }
629                 gettimeofday(&now, 0);
630                 if(now.tv_sec - then.tv_sec >= 1) {
631                         int64_t elapsed = now.tv_sec - start_time.tv_sec;
632                         int64_t byte_rate = *position / elapsed;
633                         int64_t eta = !byte_rate ? 0 : (length - *position) / byte_rate;
634                         char string[BCTEXTLEN];
635                         sprintf(string, "%s\nETA: " _LD "m" _LD "s",
636                                 progress_title, eta / 60, eta % 60);
637                         progress->update_title(string, 1);
638                         then = now;
639                 }
640                 usleep(500000);
641         }
642
643         progress->stop_progress();
644         delete progress;
645 }
646
647 int FileFFMPEG::get_index(char *index_path)
648 {
649         if( !ff ) return -1;
650         if( !file->preferences->ffmpeg_marker_indecies ) return 1;
651
652         IndexState *index_state = asset->index_state;
653         if( index_state->index_status != INDEX_NOTTESTED ) return 0;
654         index_state->index_status = INDEX_BUILDING;
655
656         for( int aidx=0; aidx<ff->ffaudio.size(); ++aidx ) {
657                 FFAudioStream *aud = ff->ffaudio[aidx];
658                 index_state->add_audio_stream(aud->channels, aud->length);
659         }
660
661         char progress_title[BCTEXTLEN];
662         sprintf(progress_title, _("Creating %s\n"), index_path);
663         FileSystem fs;
664         int64_t file_bytes = fs.get_size(ff->fmt_ctx->filename);
665         int64_t scan_position = 0;
666         int canceled = 0;
667         FFMPEGScanProgress scan_progress(progress_title, file_bytes, &scan_position, &canceled);
668
669         index_state->index_bytes = file_bytes;
670         index_state->init_scan(file->preferences->index_size);
671         if( ff->scan(index_state, &scan_position, &canceled) || canceled ) {
672                 index_state->reset_index();
673                 index_state->reset_markers();
674                 return 1;
675         }
676         index_state->marker_status = MARKERS_READY;
677         return index_state->create_index(index_path, asset);
678 }
679