← Back to branch summary

~akirad/cinecutie/trunk

« back to all changes in this revision

Viewing changes to cinecutie/packagerenderer.C

  • Committer: Paolo Rampino
  • Date: 2010-02-17 19:46:21 UTC
  • Revision ID: git-v1:c39ff77ffa6ae08441c12e7d7f54e3897ddde7f1
Initial Merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
cinecutie/packagerenderer.C
 
1
 
 
2
/*
 
3
 * CINELERRA
 
4
 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
 
5
 * 
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 * 
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 * 
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 * 
 
20
 */
 
21
 
 
22
#include "arender.h"
 
23
#include "asset.h"
 
24
#include "auto.h"
 
25
#include "brender.h"
 
26
#include "cache.h"
 
27
#include "clip.h"
 
28
#include "cwindow.h"
 
29
#include "cwindowgui.h"
 
30
#include "edit.h"
 
31
#include "edits.h"
 
32
#include "edl.h"
 
33
#include "edlsession.h"
 
34
#include "errorbox.h"
 
35
#include "file.h"
 
36
#include "filesystem.h"
 
37
#include "indexfile.h"
 
38
#include "language.h"
 
39
#include "mwindow.h"
 
40
#include "mwindowgui.h"
 
41
#include "packagerenderer.h"
 
42
#include "playabletracks.h"
 
43
#include "playbackconfig.h"
 
44
#include "pluginserver.h"
 
45
#include "preferences.h"
 
46
#include "render.h"
 
47
#include "renderengine.h"
 
48
#include "renderfarmfsserver.h"
 
49
#include "sighandler.h"
 
50
#include "tracks.h"
 
51
#include "transportque.h"
 
52
#include "vedit.h"
 
53
#include "vframe.h"
 
54
#include "videodevice.h"
 
55
#include "vrender.h"
 
56
 
 
57
 
 
58
 
 
59
 
 
60
 
 
61
 
 
62
 
 
63
RenderPackage::RenderPackage()
 
64
{
 
65
        audio_start = 0;
 
66
        audio_end = 0;
 
67
        video_start = 0;
 
68
        video_end = 0;
 
69
        path[0] = 0;
 
70
        done = 0;
 
71
        use_brender = 0;
 
72
}
 
73
 
 
74
RenderPackage::~RenderPackage()
 
75
{
 
76
}
 
77
 
 
78
 
 
79
 
 
80
 
 
81
 
 
82
 
 
83
 
 
84
 
 
85
// Used by RenderFarm and in the future, Render, to do packages.
 
86
PackageRenderer::PackageRenderer()
 
87
{
 
88
        command = 0;
 
89
        audio_cache = 0;
 
90
        video_cache = 0;
 
91
        aconfig = 0;
 
92
        vconfig = 0;
 
93
}
 
94
 
 
95
PackageRenderer::~PackageRenderer()
 
96
{
 
97
        delete command;
 
98
        delete audio_cache;
 
99
        delete video_cache;
 
100
        delete vconfig;
 
101
        delete aconfig;
 
102
}
 
103
 
 
104
// PackageRenderer::initialize happens only once for every node when doing rendering session
 
105
// This is not called for each package!
 
106
 
 
107
int PackageRenderer::initialize(MWindow *mwindow,
 
108
                EDL *edl, 
 
109
                Preferences *preferences, 
 
110
                Asset *default_asset,
 
111
                ArrayList<PluginServer*> *plugindb)
 
112
{
 
113
        int result = 0;
 
114
 
 
115
        this->mwindow = mwindow;
 
116
        this->edl = edl;
 
117
        this->preferences = preferences;
 
118
        this->default_asset = default_asset;
 
119
        this->plugindb = plugindb;
 
120
 
 
121
 
 
122
//printf("PackageRenderer::initialize %d\n", preferences->processors);
 
123
        command = new TransportCommand;
 
124
        command->command = NORMAL_FWD;
 
125
        command->get_edl()->copy_all(edl);
 
126
        command->change_type = CHANGE_ALL;
 
127
        command->set_playback_range(edl);
 
128
 
 
129
        default_asset->frame_rate = command->get_edl()->session->frame_rate;
 
130
        default_asset->sample_rate = command->get_edl()->session->sample_rate;
 
131
        default_asset->aspect_ratio = (double)command->get_edl()->session->aspect_w /
 
132
                command->get_edl()->session->aspect_h;
 
133
        result = Render::check_asset(edl, *default_asset);
 
134
 
 
135
        audio_cache = new CICache(preferences, plugindb);
 
136
        video_cache = new CICache(preferences, plugindb);
 
137
 
 
138
        PlaybackConfig *config = command->get_edl()->session->playback_config;
 
139
        aconfig = new AudioOutConfig(0);
 
140
        vconfig = new VideoOutConfig;
 
141
 
 
142
        return result;
 
143
}
 
144
 
 
145
void PackageRenderer::create_output()
 
146
{
 
147
        FileSystem fs;
 
148
        asset = new Asset(*default_asset);
 
149
 
 
150
 
 
151
 
 
152
 
 
153
 
 
154
        strcpy(asset->path, package->path);
 
155
 
 
156
 
 
157
        
 
158
 
 
159
        file = new File;
 
160
 
 
161
        file->set_processors(preferences->processors);
 
162
 
 
163
        result = file->open_file(preferences, 
 
164
                                        asset, 
 
165
                                        0, 
 
166
                                        1, 
 
167
                                        command->get_edl()->session->sample_rate, 
 
168
                                        command->get_edl()->session->frame_rate);
 
169
//printf("PackageRenderer::create_output 10 %d\n", result);
 
170
 
 
171
        if(result && mwindow)
 
172
        {
 
173
// open failed
 
174
                char string[BCTEXTLEN];
 
175
                sprintf(string, _("Couldn't open %s"), asset->path);
 
176
                ErrorBox error(PROGRAM_NAME ": Error",
 
177
                        mwindow->gui->get_abs_cursor_x(1),
 
178
                        mwindow->gui->get_abs_cursor_y(1));
 
179
                error.create_objects(string);
 
180
                error.run_window();
 
181
        }
 
182
        else
 
183
        if(mwindow)
 
184
        {
 
185
                mwindow->sighandler->push_file(file);
 
186
                IndexFile::delete_index(preferences, asset);
 
187
        }
 
188
//printf("PackageRenderer::create_output 100 %d\n", result);
 
189
}
 
190
 
 
191
void PackageRenderer::create_engine()
 
192
{
 
193
        int current_achannel = 0, current_vchannel = 0;
 
194
        audio_read_length = command->get_edl()->session->sample_rate;
 
195
 
 
196
        aconfig->fragment_size = audio_read_length;
 
197
 
 
198
 
 
199
        render_engine = new RenderEngine(0,
 
200
                preferences,
 
201
                command,
 
202
                0,
 
203
                plugindb,
 
204
                0);
 
205
        render_engine->set_acache(audio_cache);
 
206
        render_engine->set_vcache(video_cache);
 
207
        render_engine->arm_command(command, current_achannel, current_vchannel);
 
208
 
 
209
        if(package->use_brender)
 
210
        {
 
211
                audio_preroll = Units::to_int64((double)preferences->brender_preroll /
 
212
                        default_asset->frame_rate *
 
213
                        default_asset->sample_rate);
 
214
                video_preroll = preferences->brender_preroll;
 
215
        }
 
216
        else
 
217
        {
 
218
                audio_preroll = Units::to_int64(preferences->render_preroll * 
 
219
                        default_asset->sample_rate);
 
220
                video_preroll = Units::to_int64(preferences->render_preroll * 
 
221
                        default_asset->frame_rate);
 
222
        }
 
223
        audio_position = package->audio_start - audio_preroll;
 
224
        video_position = package->video_start - video_preroll;
 
225
 
 
226
 
 
227
 
 
228
 
 
229
// Create output buffers
 
230
        if(asset->audio_data)
 
231
        {
 
232
                file->start_audio_thread(audio_read_length, 
 
233
                        preferences->processors > 1 ? 2 : 1);
 
234
        }
 
235
 
 
236
 
 
237
        if(asset->video_data)
 
238
        {
 
239
                compressed_output = new VFrame;
 
240
// The write length needs to correlate with the processor count because
 
241
// it is passed to the file handler which usually processes frames simultaneously.
 
242
                video_write_length = preferences->processors;
 
243
                video_write_position = 0;
 
244
                direct_frame_copying = 0;
 
245
 
 
246
 
 
247
//printf("PackageRenderer::create_engine 1\n");
 
248
                file->start_video_thread(video_write_length,
 
249
                        command->get_edl()->session->color_model,
 
250
                        preferences->processors > 1 ? 2 : 1,
 
251
                        0);
 
252
 
 
253
 
 
254
                if(mwindow)
 
255
                {
 
256
                        video_device = new VideoDevice;
 
257
                        video_device->open_output(vconfig, 
 
258
                                command->get_edl()->session->frame_rate, 
 
259
                                command->get_edl()->session->output_w, 
 
260
                                command->get_edl()->session->output_h, 
 
261
                                mwindow->cwindow->gui->canvas,
 
262
                                0);
 
263
                        video_device->start_playback();
 
264
                }
 
265
        }
 
266
 
 
267
 
 
268
        playable_tracks = new PlayableTracks(render_engine, 
 
269
                video_position, 
 
270
                TRACK_VIDEO,
 
271
                1);
 
272
 
 
273
}
 
274
 
 
275
 
 
276
 
 
277
 
 
278
void PackageRenderer::do_audio()
 
279
{
 
280
//printf("PackageRenderer::do_audio 1\n");
 
281
// Do audio data
 
282
        if(asset->audio_data)
 
283
        {
 
284
                audio_output = file->get_audio_buffer();
 
285
// Zero unused channels in output vector
 
286
                for(int i = 0; i < MAX_CHANNELS; i++)
 
287
                        audio_output_ptr[i] = (i < asset->channels) ? 
 
288
                                audio_output[i] : 
 
289
                                0;
 
290
 
 
291
 
 
292
 
 
293
 
 
294
// Call render engine
 
295
                result = render_engine->arender->process_buffer(audio_output_ptr, 
 
296
                        audio_read_length, 
 
297
                        audio_position,
 
298
                        0);
 
299
 
 
300
//printf("PackageRenderer::do_audio 3\n");
 
301
 
 
302
 
 
303
// Fix buffers for preroll
 
304
                int64_t output_length = audio_read_length;
 
305
                if(audio_preroll > 0)
 
306
                {
 
307
                        if(audio_preroll >= output_length)
 
308
                                output_length = 0;
 
309
                        else
 
310
                        {
 
311
                                output_length -= audio_preroll;
 
312
                                for(int i = 0; i < MAX_CHANNELS; i++)
 
313
                                {
 
314
                                        if(audio_output_ptr[i])
 
315
                                                for(int j = 0; j < output_length; j++)
 
316
                                                {
 
317
                                                        audio_output_ptr[i][j] = audio_output_ptr[i][j + audio_read_length - output_length];
 
318
                                                }
 
319
                                }
 
320
                        }
 
321
//printf("PackageRenderer::do_audio 4\n");
 
322
 
 
323
                        audio_preroll -= audio_read_length;
 
324
                }
 
325
 
 
326
// Must perform writes even if 0 length so get_audio_buffer doesn't block
 
327
                result |= file->write_audio_buffer(output_length);
 
328
        }
 
329
 
 
330
        audio_position += audio_read_length;
 
331
//printf("PackageRenderer::do_audio 5\n");
 
332
}
 
333
 
 
334
 
 
335
void PackageRenderer::do_video()
 
336
{
 
337
// Do video data
 
338
        if(asset->video_data)
 
339
        {
 
340
// get the absolute video position from the audio position
 
341
                int64_t video_end = video_position + video_read_length;
 
342
 
 
343
                if(video_end > package->video_end)
 
344
                        video_end = package->video_end;
 
345
 
 
346
                while(video_position < video_end && !result)
 
347
                {
 
348
// Try to copy the compressed frame directly from the input to output files
 
349
//printf("PackageRenderer::do_video 2 video_position=%ld\n", video_position);
 
350
                        if(direct_frame_copy(command->get_edl(), 
 
351
                                video_position, 
 
352
                                file, 
 
353
                                result))
 
354
                        {
 
355
// Direct frame copy failed.
 
356
// Switch back to background compression
 
357
                                if(direct_frame_copying)
 
358
                                {
 
359
                                        file->start_video_thread(video_write_length, 
 
360
                                                command->get_edl()->session->color_model,
 
361
                                                preferences->processors > 1 ? 2 : 1,
 
362
                                                0);
 
363
                                        direct_frame_copying = 0;
 
364
                                }
 
365
 
 
366
// Try to use the rendering engine to write the frame.
 
367
// Get a buffer for background writing.
 
368
 
 
369
 
 
370
 
 
371
                                if(video_write_position == 0)
 
372
                                        video_output = file->get_video_buffer();
 
373
 
 
374
 
 
375
 
 
376
 
 
377
 
 
378
// Construct layered output buffer
 
379
                                video_output_ptr = video_output[0][video_write_position];
 
380
 
 
381
                                if(!result)
 
382
                                        result = render_engine->vrender->process_buffer(
 
383
                                                video_output_ptr, 
 
384
                                                video_position, 
 
385
                                                0);
 
386
 
 
387
 
 
388
 
 
389
                                if(!result && 
 
390
                                        mwindow && 
 
391
                                        video_device->output_visible())
 
392
                                {
 
393
// Vector for video device
 
394
                                        VFrame *preview_output;
 
395
 
 
396
                                        video_device->new_output_buffer(&preview_output,
 
397
                                                command->get_edl()->session->color_model);
 
398
 
 
399
                                        preview_output->copy_from(video_output_ptr);
 
400
                                        video_device->write_buffer(preview_output, 
 
401
                                                command->get_edl());
 
402
                                }
 
403
 
 
404
 
 
405
 
 
406
// Don't write to file
 
407
                                if(video_preroll && !result)
 
408
                                {
 
409
                                        video_preroll--;
 
410
// Keep the write position at 0 until ready to write real frames
 
411
                                        result = file->write_video_buffer(0);
 
412
                                        video_write_position = 0;
 
413
                                }
 
414
                                else
 
415
                                if(!result)
 
416
                                {
 
417
// Set background rendering parameters
 
418
// Allow us to skip sections of the output file by setting the frame number.
 
419
// Used by background render and render farm.
 
420
                                        video_output_ptr->set_number(video_position);
 
421
                                        video_write_position++;
 
422
 
 
423
                                        if(video_write_position >= video_write_length)
 
424
                                        {
 
425
//printf("PackageRenderer::do_video 9\n");
 
426
                                                result = file->write_video_buffer(video_write_position);
 
427
// Update the brender map after writing the files.
 
428
                                                if(package->use_brender)
 
429
                                                {
 
430
//printf("PackageRenderer::do_video 10\n");
 
431
                                                        for(int i = 0; i < video_write_position && !result; i++)
 
432
                                                        {
 
433
                                                                result = set_video_map(video_position + 1 - video_write_position + i, 
 
434
                                                                        BRender::RENDERED);
 
435
                                                        }
 
436
//printf("PackageRenderer::do_video 11 %d\n", result);
 
437
                                                }
 
438
                                                video_write_position = 0;
 
439
                                        }
 
440
                                }
 
441
 
 
442
 
 
443
                        }
 
444
 
 
445
                        video_position++;
 
446
                        if(!result && get_result()) result = 1;
 
447
                        if(!result && progress_cancelled()) result = 1;
 
448
                }
 
449
        }
 
450
        else
 
451
        {
 
452
                video_position += video_read_length;
 
453
        }
 
454
}
 
455
 
 
456
 
 
457
void PackageRenderer::stop_engine()
 
458
{
 
459
        delete render_engine;
 
460
        delete playable_tracks;
 
461
}
 
462
 
 
463
 
 
464
void PackageRenderer::stop_output()
 
465
{
 
466
        int error = 0;
 
467
        if(asset->audio_data)
 
468
        {
 
469
// stop file I/O
 
470
                file->stop_audio_thread();
 
471
        }
 
472
 
 
473
        if(asset->video_data)
 
474
        {
 
475
                delete compressed_output;
 
476
                if(video_write_position)
 
477
                        file->write_video_buffer(video_write_position);
 
478
                if(package->use_brender)
 
479
                {
 
480
                        for(int i = 0; i < video_write_position && !error; i++)
 
481
                        {
 
482
                                error = set_video_map(video_position - video_write_position + i, 
 
483
                                        BRender::RENDERED);
 
484
                        }
 
485
                }
 
486
                video_write_position = 0;       
 
487
                if(!error) file->stop_video_thread();
 
488
                if(mwindow)
 
489
                {
 
490
                        video_device->stop_playback();
 
491
                        video_device->close_all();
 
492
                        delete video_device;
 
493
                }
 
494
        }
 
495
}
 
496
 
 
497
 
 
498
void PackageRenderer::close_output()
 
499
{
 
500
        if(mwindow)
 
501
                mwindow->sighandler->pull_file(file);
 
502
        file->close_file();
 
503
        delete file;
 
504
        Garbage::delete_object(asset);
 
505
}
 
506
 
 
507
// Aborts and returns 1 if an error is encountered.
 
508
int PackageRenderer::render_package(RenderPackage *package)
 
509
{
 
510
        int audio_done = 0;
 
511
        int video_done = 0;
 
512
        int samples_rendered = 0;
 
513
 
 
514
 
 
515
        result = 0;
 
516
        this->package = package;
 
517
 
 
518
// printf(
 
519
// "PackageRenderer::render_package: audio s=%lld l=%lld video s=%lld l=%lld\n",
 
520
//      package->audio_start, 
 
521
//      package->audio_end - package->audio_start, 
 
522
//      package->video_start, 
 
523
//      package->video_end - package->video_start);
 
524
 
 
525
 
 
526
// FIXME: The design that we only get EDL once does not give us neccessary flexiblity to do things the way they should be donek
 
527
        default_asset->video_data = package->video_do;
 
528
        default_asset->audio_data = package->audio_do;
 
529
        Render::check_asset(edl, *default_asset);
 
530
        
 
531
        create_output();
 
532
 
 
533
        if(!asset->video_data) video_done = 1;
 
534
        if(!asset->audio_data) audio_done = 1;
 
535
 
 
536
// Create render engine
 
537
        if(!result)
 
538
        {
 
539
                create_engine();
 
540
 
 
541
//printf("PackageRenderer::render_package 5 %d\n", result);
 
542
 
 
543
// Main loop
 
544
                while((!audio_done || !video_done) && !result)
 
545
                {
 
546
                        int need_audio = 0, need_video = 0;
 
547
 
 
548
 
 
549
 
 
550
 
 
551
// Calculate lengths to process.  Audio fragment is constant.
 
552
                        if(!audio_done)
 
553
                        {
 
554
                                if(audio_position + audio_read_length >= package->audio_end)
 
555
                                {
 
556
                                        audio_done = 1;
 
557
                                        audio_read_length = package->audio_end - audio_position;
 
558
                                }
 
559
 
 
560
                                samples_rendered = audio_read_length;
 
561
                                need_audio = 1;
 
562
                        }
 
563
 
 
564
//printf("PackageRenderer::render_package 6 %d\n", samples_rendered);
 
565
 
 
566
                        if(!video_done)
 
567
                        {
 
568
                                if(audio_done)
 
569
                                {
 
570
                                        video_read_length = package->video_end - video_position;
 
571
// Packetize video length so progress gets updated
 
572
                                        video_read_length = (int)MIN(asset->frame_rate, video_read_length);
 
573
                                        video_read_length = MAX(video_read_length, 30);
 
574
                                }
 
575
                                else
 
576
// Guide video with audio
 
577
                                {
 
578
                                        video_read_length = Units::to_int64(
 
579
                                                (double)(audio_position + audio_read_length) / 
 
580
                                                asset->sample_rate * 
 
581
                                                asset->frame_rate) - 
 
582
                                                video_position;
 
583
                                }
 
584
 
 
585
// Clamp length
 
586
                                if(video_position + video_read_length >= package->video_end)
 
587
                                {
 
588
                                        video_done = 1;
 
589
                                        video_read_length = package->video_end - video_position;
 
590
                                }
 
591
 
 
592
// Calculate samples rendered for progress bar.
 
593
                                if(audio_done)
 
594
                                        samples_rendered = Units::round((double)video_read_length /
 
595
                                                asset->frame_rate *
 
596
                                                asset->sample_rate);
 
597
 
 
598
                                need_video = 1;
 
599
                        }
 
600
 
 
601
//printf("PackageRenderer::render_package 1 %d %lld %lld\n", result, audio_read_length, video_read_length);
 
602
                        if(need_video && !result) do_video();
 
603
//printf("PackageRenderer::render_package 7 %d %d\n", result, samples_rendered);
 
604
                        if(need_audio && !result) do_audio();
 
605
 
 
606
 
 
607
                        if(!result) set_progress(samples_rendered);
 
608
 
 
609
 
 
610
 
 
611
 
 
612
 
 
613
                        if(!result && progress_cancelled()) result = 1;
 
614
 
 
615
// printf("PackageRenderer::render_package 10 %d %d %d %d\n", 
 
616
// audio_read_length, video_read_length, samples_rendered, result);
 
617
                        if(result) 
 
618
                                set_result(result);
 
619
                        else
 
620
                                result = get_result();
 
621
                }
 
622
 
 
623
//printf("PackageRenderer::render_package 20\n");
 
624
                stop_engine();
 
625
//printf("PackageRenderer::render_package 30\n");
 
626
 
 
627
                stop_output();
 
628
//printf("PackageRenderer::render_package 40\n");
 
629
 
 
630
 
 
631
        }
 
632
 
 
633
 
 
634
 
 
635
//printf("PackageRenderer::render_package 50\n");
 
636
        close_output();
 
637
//printf("PackageRenderer::render_package 60\n");
 
638
 
 
639
 
 
640
        set_result(result);
 
641
//printf("PackageRenderer::render_package 70\n");
 
642
 
 
643
 
 
644
 
 
645
        return result;
 
646
}
 
647
 
 
648
 
 
649
 
 
650
 
 
651
 
 
652
 
 
653
 
 
654
 
 
655
// Try to copy the compressed frame directly from the input to output files
 
656
// Return 1 on failure and 0 on success
 
657
int PackageRenderer::direct_frame_copy(EDL *edl, 
 
658
        int64_t &video_position, 
 
659
        File *file,
 
660
        int &error)
 
661
{
 
662
        Track *playable_track;
 
663
        Edit *playable_edit;
 
664
        int64_t frame_size;
 
665
 
 
666
//printf("Render::direct_frame_copy 1\n");
 
667
        if(direct_copy_possible(edl, 
 
668
                video_position, 
 
669
                playable_track, 
 
670
                playable_edit, 
 
671
                file))
 
672
        {
 
673
// Switch to direct copying
 
674
                if(!direct_frame_copying)
 
675
                {
 
676
                        if(video_write_position)
 
677
                        {
 
678
                                error |= file->write_video_buffer(video_write_position);
 
679
                                video_write_position = 0;
 
680
                        }
 
681
                        file->stop_video_thread();
 
682
                        direct_frame_copying = 1;
 
683
                }
 
684
//printf("Render::direct_frame_copy 2\n");
 
685
 
 
686
                if(!package->use_brender)
 
687
                        error |= ((VEdit*)playable_edit)->read_frame(compressed_output, 
 
688
                                video_position,
 
689
                                PLAY_FORWARD,
 
690
                                video_cache,
 
691
                                1,
 
692
                                0,
 
693
                                0);
 
694
 
 
695
 
 
696
                if(!error && video_preroll > 0)
 
697
                {
 
698
                        video_preroll--;
 
699
                }
 
700
                else
 
701
                if(!error)
 
702
                {
 
703
                        if(package->use_brender)
 
704
                        {
 
705
//printf("PackageRenderer::direct_frame_copy 1\n");
 
706
                                error = set_video_map(video_position, BRender::SCANNED);
 
707
//printf("PackageRenderer::direct_frame_copy 10 %d\n", error);
 
708
                        }
 
709
                        else
 
710
                        {
 
711
                                VFrame ***temp_output = new VFrame**[1];
 
712
                                temp_output[0] = new VFrame*[1];
 
713
                                temp_output[0][0] = compressed_output;
 
714
                                error = file->write_frames(temp_output, 1);
 
715
                                delete [] temp_output[0];
 
716
                                delete temp_output;
 
717
                        }
 
718
                }
 
719
                return 0;
 
720
        }
 
721
        else
 
722
                return 1;
 
723
}
 
724
 
 
725
int PackageRenderer::direct_copy_possible(EDL *edl,
 
726
                                int64_t current_position, 
 
727
                                Track* playable_track,  // The one track which is playable
 
728
                                Edit* &playable_edit, // The edit which is playing
 
729
                                File *file)   // Output file
 
730
{
 
731
        int result = 1;
 
732
        int total_playable_tracks = 0;
 
733
        Track* current_track;
 
734
        Patch* current_patch;
 
735
        Auto* current_auto;
 
736
        int temp;
 
737
 
 
738
// Number of playable tracks must equal 1
 
739
        for(current_track = edl->tracks->first;
 
740
                current_track && result; 
 
741
                current_track = current_track->next)
 
742
        {
 
743
                if(current_track->data_type == TRACK_VIDEO)
 
744
                {
 
745
                        if(playable_tracks->is_playable(current_track, current_position, 1))
 
746
                        {
 
747
                                playable_track = current_track;
 
748
                                total_playable_tracks++;
 
749
                        }
 
750
                }
 
751
        }
 
752
 
 
753
//printf("Render::direct_copy_possible 1 %d\n", result);
 
754
        if(total_playable_tracks != 1) result = 0;
 
755
//printf("Render::direct_copy_possible 2 %d\n", result);
 
756
 
 
757
// Edit must have a source file
 
758
        if(result)
 
759
        {
 
760
//printf("Render::direct_copy_possible 3 %d\n", result);
 
761
                playable_edit = playable_track->edits->get_playable_edit(current_position, 1);
 
762
//printf("Render::direct_copy_possible 4 %d %p\n", result, playable_edit);
 
763
                if(!playable_edit)
 
764
                        result = 0;
 
765
        }
 
766
 
 
767
// Source file must be able to copy to destination file.
 
768
// Source file must be same size as project output.
 
769
        if(result)
 
770
        {
 
771
//printf("Render::direct_copy_possible 5 %d\n", result);
 
772
                if(!file->can_copy_from(playable_edit, 
 
773
                        current_position + playable_track->nudge,
 
774
                        edl->session->output_w, 
 
775
                        edl->session->output_h))
 
776
                        result = 0;
 
777
        }
 
778
//printf("Render::direct_copy_possible 6 %d\n", result);
 
779
 
 
780
// Test conditions mutual between vrender.C and this.
 
781
        if(result && 
 
782
                !playable_track->direct_copy_possible(current_position, PLAY_FORWARD, 1))
 
783
                result = 0;
 
784
//printf("Render::direct_copy_possible 7 %d\n", result);
 
785
 
 
786
        return result;
 
787
}
 
788
 
 
789
 
 
790
 
 
791
 
 
792
 
 
793
 
 
794
 
 
795
 
 
796
 
 
797
int PackageRenderer::get_master()
 
798
{
 
799
        return 0;
 
800
}
 
801
 
 
802
// Get result status from server
 
803
int PackageRenderer::get_result()
 
804
{
 
805
        return 0;
 
806
}
 
807
 
 
808
void PackageRenderer::set_result(int value)
 
809
{
 
810
}
 
811
 
 
812
void PackageRenderer::set_progress(int64_t value)
 
813
{
 
814
}       
 
815
 
 
816
int PackageRenderer::set_video_map(int64_t position, int value)
 
817
{
 
818
}
 
819
 
 
820
int PackageRenderer::progress_cancelled()
 
821
{
 
822
        return 0;
 
823
}       
 
824
 
 
825
 
 
826
 
 
827
 
 
828
 
 
829
 
 
830
 
 
831
 
 
832
 
 
833