cinelerra-5.1/cinelerra/fileref.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2020 William Morrow
   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 "asset.h"
  23 #include "arender.h"
  24 #include "cache.h"
  25 #include "filebase.h"
  26 #include "file.h"
  27 #include "fileref.h"
  28 #include "language.h"
  29 #include "mainerror.h"
  30 #include "renderengine.h"
  31 #include "samples.h"
  32 #include "edlsession.h"
  33 #include "tracks.h"
  34 #include "transportque.h"
  35 #include "vframe.h"
  36 #include "vrender.h"
  37 #include "filexml.h"
  38
  39
  40 FileREF::FileREF(Asset *asset, File *file)
  41  : FileBase(asset, file)
  42 {
  43         is_open = 0;
  44         audio_position = 0;
  45         video_position = 0;
  46         samples_position = -1;
  47         samples_length = -1;
  48         channel = 0;
  49         layer = 0;
  50         ref = 0;
  51         command = 0;
  52         render_engine = 0;
  53         acache = 0;
  54         vcache = 0;
  55         temp = 0;
  56         for( int i=0; i<MAX_CHANNELS; ++i ) samples[i] = 0;
  57 }
  58
  59 FileREF::~FileREF()
  60 {
  61         close_file();
  62 }
  63
  64 int FileREF::open_file(int rd, int wr)
  65 {
  66         if( is_open ) return 1;
  67         if(wr) {
  68                 eprintf(_("Reference files cant be created by rendering\n"));
  69                 return 1;
  70         }
  71         if(rd) {
  72                 FileXML file_xml;
  73                 if( file_xml.read_from_file(asset->path) ) return 1;
  74 //              file_xml.check_version();
  75                 if( ref ) ref->remove_user();
  76                 ref = new EDL;
  77                 ref->create_objects();
  78                 ref->load_xml(&file_xml, LOAD_ALL);
  79                 command = new TransportCommand();
  80                 command->reset();
  81                 command->get_edl()->copy_all(ref);
  82                 command->command = NORMAL_FWD;
  83                 command->change_type = CHANGE_ALL;
  84                 command->realtime = 0;
  85                 samples_position = -1;
  86                 samples_length = -1;
  87                 audio_position = 0;
  88                 render_engine = new RenderEngine(0, file->preferences, 0, 0);
  89                 render_engine->set_acache(acache = new CICache(file->preferences));
  90                 render_engine->set_vcache(vcache = new CICache(file->preferences));
  91                 render_engine->arm_command(command);
  92                 is_open = 1;
  93         }
  94         return 0;
  95 }
  96
  97 int FileREF::close_file()
  98 {
  99         if( !is_open ) return 1;
 100         if( ref ) ref->remove_user();
 101         ref = 0;
 102         delete render_engine;  render_engine = 0;
 103         delete command;  command = 0;
 104         delete acache;   acache = 0;
 105         delete vcache;   vcache = 0;
 106         delete temp;     temp = 0;
 107         for( int i=0; i<MAX_CHANNELS; ++i ) {
 108                 delete samples[i];  samples[i] = 0;
 109         }
 110         audio_position = 0;
 111         video_position = 0;
 112         channel = 0;
 113         samples_position = -1;
 114         samples_length = -1;
 115         layer = 0;
 116         is_open = 0;
 117         return 0;
 118 }
 119
 120 int64_t FileREF::get_video_position()
 121 {
 122         return video_position;
 123 }
 124
 125 int64_t FileREF::get_audio_position()
 126 {
 127         return audio_position;
 128 }
 129
 130 int FileREF::set_video_position(int64_t pos)
 131 {
 132         this->video_position = pos;
 133         return 0;
 134 }
 135 int FileREF::set_layer(int layer)
 136 {
 137         this->layer = layer;
 138         return 0;
 139 }
 140
 141 int FileREF::set_audio_position(int64_t pos)
 142 {
 143         this->audio_position = pos;
 144         return 0;
 145 }
 146 int FileREF::set_channel(int channel)
 147 {
 148         this->channel = channel;
 149         return 0;
 150 }
 151
 152 int FileREF::read_samples(double *buffer, int64_t len)
 153 {
 154         int result = len > 0 ? 0 : 1;
 155         if( !render_engine || !render_engine->arender ) result = 1;
 156         if( !result ) {
 157                 if( samples_length != len ) {
 158                         samples_length = -1;
 159                         for( int i=0; i<MAX_CHANNELS; ++i ) {
 160                                 delete samples[i];  samples[i] = 0;
 161                         }
 162                 }
 163                 if( samples_length < 0 ) {
 164                         samples_length = len;
 165                         int ch = 0, channels = asset->channels;
 166                         while( ch < channels ) samples[ch++] = new Samples(samples_length);
 167                         samples_position = -1;
 168                 }
 169                 if( samples_position != audio_position ) {
 170                         result = render_engine->arender->process_buffer(samples, len, audio_position);
 171                         samples_position = audio_position;
 172                 }
 173         }
 174         Samples *cbfr = samples[channel];
 175         double *data = cbfr ? cbfr->get_data() : 0;
 176         if( !data ) result = 1;
 177         int64_t sz = len*(sizeof(*buffer));
 178         if( !result )
 179                 memcpy(buffer, data, sz);
 180         else
 181                 memset(buffer, 0, sz);
 182         return result;
 183 }
 184
 185 int FileREF::read_frame(VFrame *frame)
 186 {
 187         int result = render_engine && render_engine->vrender ? 0 : 1;
 188         EDLSession *render_session = render_engine->get_edl()->session;
 189         int color_model = render_session->color_model;
 190         int out_w = render_session->output_w, out_h = render_session->output_h;
 191         VFrame *vframe = frame;
 192         if( color_model != frame->get_color_model() ||
 193             out_w != frame->get_w() || out_h != frame->get_h() ) {
 194                 VFrame::get_temp(temp, out_w, out_h, color_model);
 195                 vframe = temp;
 196         }
 197         if( !result )
 198                 result = render_engine->vrender->process_buffer(vframe, video_position++, 0);
 199         if( vframe != frame )
 200                 frame->transfer_from(vframe);
 201         return result;
 202 }
 203
 204 int FileREF::colormodel_supported(int colormodel)
 205 {
 206         return colormodel;
 207 }
 208
 209
 210 int FileREF::get_best_colormodel(Asset *asset, int driver)
 211 {
 212         return BC_RGBA_FLOAT;
 213 }
 214