cinelerra-5.1/cinelerra/exportedl.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2006 Andraz Tori
   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 "bchash.h"
  24 #include "condition.h"
  25 #include "confirmsave.h"
  26 #include "edits.h"
  27 #include "edl.h"
  28 #include "edlsession.h"
  29 #include "errorbox.h"
  30 #include "file.h"
  31 #include "filesystem.h"
  32 #include "filexml.h"
  33 #include "language.h"
  34 #include "localsession.h"
  35 #include "mainsession.h"
  36 #include "mutex.h"
  37 #include "mwindowgui.h"
  38 #include "mwindow.h"
  39 #include "exportedl.h"
  40 #include "tracks.h"
  41 #include "transition.h"
  42
  43 #include <libintl.h>
  44 #define _(String) gettext(String)
  45 #define gettext_noop(String) String
  46 #define N_(String) gettext_noop (String)
  47
  48
  49
  50 #include <ctype.h>
  51 #include <string.h>
  52
  53 ExportEDLAsset::ExportEDLAsset(MWindow *mwindow, EDL *edl)
  54 {
  55         this->mwindow = mwindow;
  56         this->edl = edl;
  57
  58         path[0] = 0;
  59         edl_type = EDLTYPE_CMX3600;
  60         track_number = -1;
  61 }
  62
  63 ExportEDLAsset::~ExportEDLAsset()
  64 {
  65 }
  66
  67 void ExportEDLAsset::double_to_CMX3600(double seconds, double frame_rate, char *str)
  68 {
  69         char tmp[20];
  70         Units::totext(tmp,
  71                         seconds,
  72                         TIME_HMSF,
  73                         0, // sample_rate ... unnecessary
  74                         frame_rate,
  75                         0);    // frames per foot
  76         if ((int)(seconds / 3600) <= 9)
  77         {
  78                 str[0]='0';
  79                 strcpy(str+1, tmp);
  80         } else
  81         {
  82                 strcpy(str, tmp);
  83         }
  84
  85 //      str[8]='.';
  86
  87         //sprintf(str, "%02d:%02d:%02d:%02d", hour, minute, second, hundredths);
  88 }
  89
  90 int ExportEDLAsset::edit_to_timecodes(Edit *edit, char *sourceinpoint, char *sourceoutpoint, char *destinpoint, char *destoutpoint, char *reel_name)
  91 {
  92         Asset *asset = edit->asset;
  93         Track *track = edit->track;
  94         double frame_rate = edit->track->edl->session->frame_rate;
  95
  96         double edit_sourcestart;
  97         double edit_sourceend;
  98         double edit_deststart;
  99         double edit_destend;
 100
 101         if (asset)
 102         {
 103                 // reelname should be 8 chars long
 104
 105                 strncpy(reel_name, asset->reel_name, 9);
 106                 if (strlen(asset->reel_name) > 8)
 107                 {
 108                         printf(_("Warning: chopping the reel name to eight characters!\n"));
 109                 };
 110                 reel_name[8] = 0;
 111                 for (int i = strlen(reel_name); i<8; i++)
 112                         reel_name[i] = ' ';
 113
 114                 edit_sourcestart = (double)asset->tcstart / asset->frame_rate
 115                         + track->from_units(edit->startsource);
 116                 edit_sourceend = (double)asset->tcstart / asset->frame_rate
 117                         + track->from_units(edit->startsource + edit->length);
 118
 119         } else
 120         {
 121                 strcpy(reel_name, "   BL   ");
 122                 edit_sourcestart = 0;
 123                 edit_sourceend = track->from_units(edit->length);
 124         }
 125
 126         edit_deststart = track->from_units(edit->startproject);
 127         edit_destend = track->from_units(edit->startproject + edit->length);
 128
 129         double_to_CMX3600(edit_sourcestart, frame_rate, sourceinpoint);
 130         double_to_CMX3600(edit_sourceend, frame_rate, sourceoutpoint);
 131         double_to_CMX3600(edit_deststart, frame_rate, destinpoint);
 132         double_to_CMX3600(edit_destend, frame_rate, destoutpoint);
 133
 134         return 0;
 135 }
 136
 137
 138 void ExportEDLAsset::export_it()
 139 {
 140         FILE *fh;
 141         fh = fopen(path, "w+");
 142
 143 // We currently only support exporting one track at a time
 144 // Find the track...
 145         int serial = 0;
 146         Track *track;
 147         for(track = edl->tracks->first;
 148                 track;
 149                 track = track->next)
 150         {
 151                 if (serial == track_number)
 152                         break;
 153                 serial ++;
 154         }
 155
 156
 157         int last_dissolve = 1;
 158
 159         if (edl_type == EDLTYPE_CMX3600)
 160         {
 161
 162                 // TODO: Find docs about exact header for CMX3600
 163                 fprintf(fh, "TITLE: Cinproj   FORMAT: CMX 3600 4-Ch\n");
 164
 165                 int colnum = 1;
 166
 167
 168                 for (Edit *edit = track->edits->first;
 169                         edit;
 170                         edit = edit->next)
 171                 {
 172                         char reel_name[BCTEXTLEN];
 173                         char avselect[5];
 174                         char edittype[5] = "C   ";
 175                         char cutinfo[4] = "   ";
 176                         char sourceinpoint[12];
 177                         char sourceoutpoint[12];
 178                         char destinpoint[12];
 179                         char destoutpoint[12];
 180                         if (track->data_type == TRACK_AUDIO)
 181                                 strcpy(avselect, "A   ");
 182                         else
 183                                 strcpy(avselect, "V   ");
 184
 185                         //if (edit->transition)
 186                         //      printf("title: %s, length: %i\n", edit->transition->title, edit->transition->length);
 187                         if (edit->transition && !strcmp(edit->transition->title, "Dissolve"))
 188                         {
 189                                 char last_sourceout[12];
 190                                 edit_to_timecodes(edit->previous, sourceinpoint, last_sourceout, destinpoint, destoutpoint, reel_name);
 191                                 edit_to_timecodes(edit, sourceinpoint, sourceoutpoint, destinpoint, destoutpoint, reel_name);
 192
 193                                 if (last_dissolve)
 194                                 {
 195                                         fprintf(fh, "%03d %8s %s %4s %3s", colnum, reel_name, avselect, edittype, cutinfo);
 196                                         fprintf(fh, " %s %s", last_sourceout, last_sourceout);
 197                                         fprintf(fh, " %s %s", destinpoint, destinpoint);
 198                                         fprintf(fh,"\n");
 199                                 } else
 200                                 {
 201                                         colnum --;
 202                                 }
 203                                 edittype[0] = 'D';
 204                                 fprintf(fh, "%03d %8s %s %4s %03jd", colnum, reel_name, avselect, edittype, edit->transition->length);
 205                                 fprintf(fh, " %s %s", sourceinpoint, sourceoutpoint);
 206                                 fprintf(fh, " %s %s", destinpoint, destoutpoint);
 207                                 fprintf(fh,"\n");
 208                                 last_dissolve = 1;
 209                         } else
 210                         {
 211                                                         edit_to_timecodes(edit, sourceinpoint, sourceoutpoint, destinpoint, destoutpoint, reel_name);
 212                                 fprintf(fh, "%03d %8s %s %4s %3s", colnum, reel_name, avselect, edittype, cutinfo);
 213                                 fprintf(fh, " %s %s", sourceinpoint, sourceoutpoint);
 214                                 fprintf(fh, " %s %s", destinpoint, destoutpoint);
 215                                 fprintf(fh,"\n");
 216                                 last_dissolve = 0;
 217                         }
 218
 219                         colnum ++;
 220
 221                 }
 222
 223         }
 224
 225         fclose(fh);
 226
 227
 228 }
 229
 230
 231
 232 int ExportEDLAsset::load_defaults()
 233 {
 234         mwindow->defaults->get("EDLEXPORT_PATH", path);
 235         mwindow->defaults->get("EDLEXPORT_TYPE", edl_type);
 236         mwindow->defaults->get("EDLEXPORT_TRACKNUMBER", track_number);
 237         //load_mode = mwindow->defaults->get("RENDER_LOADMODE", LOADMODE_NEW_TRACKS);
 238
 239
 240         return 0;
 241 }
 242
 243 int ExportEDLAsset::save_defaults()
 244 {
 245         mwindow->defaults->update("EDLEXPORT_PATH", path);
 246         mwindow->defaults->update("EDLEXPORT_TYPE", edl_type);
 247         mwindow->defaults->update("EDLEXPORT_TRACKNUMBER", track_number);
 248         return 0;
 249 }
 250
 251
 252
 253
 254 ExportEDLItem::ExportEDLItem(MWindow *mwindow)
 255  : BC_MenuItem(_("Export EDL..."), "Shift-E", 'E')
 256 {
 257         this->mwindow = mwindow;
 258         set_shift(1);
 259 }
 260
 261 int ExportEDLItem::handle_event()
 262 {
 263         mwindow->exportedl->start_interactive();
 264         return 1;
 265 }
 266
 267
 268
 269
 270
 271 ExportEDL::ExportEDL(MWindow *mwindow)
 272  : Thread(0, 0, 0)
 273 {
 274         this->mwindow = mwindow;
 275 //      package_lock = new Mutex("ExportEDL::package_lock");
 276 //      counter_lock = new Mutex("ExportEDL::counter_lock");
 277 //      completion = new Condition(0, "ExportEDL::completion");
 278 //      progress_timer = new Timer;
 279 }
 280
 281 ExportEDL::~ExportEDL()
 282 {
 283 //      delete package_lock;
 284 //      delete counter_lock;
 285 //      delete completion;
 286 ///     if(preferences) delete preferences;
 287 //      delete progress_timer;
 288 }
 289
 290 void ExportEDL::start_interactive()
 291 {
 292         if(!Thread::running())
 293         {
 294                 Thread::start();
 295         }
 296 }
 297
 298 void ExportEDL::run()
 299 {
 300         int result = 0;
 301         exportasset = new ExportEDLAsset(mwindow, mwindow->edl);
 302
 303         exportasset->load_defaults();
 304
 305 // Get format from user
 306                 result = 0;
 307                 int filesok;
 308
 309                 do {
 310                 // FIX
 311                         filesok = 0;
 312                         exportedl_window = new ExportEDLWindow(mwindow, this, exportasset);
 313                         exportedl_window->create_objects();
 314                         result = exportedl_window->run_window();
 315                         if (! result) {
 316                                 // add to recentlist only on OK
 317                                 // Fix "EDL"!
 318                                 exportedl_window->path_recent->add_item("EDLPATH", exportasset->path);
 319                         }
 320                         exportasset->track_number = exportedl_window->track_list->get_selection_number(0, 0);
 321
 322                         delete exportedl_window;
 323                         exportedl_window = 0;
 324                         if (!result)
 325                         {
 326                                 ArrayList<char*> paths;
 327
 328                                 paths.append(exportasset->path);
 329                                 filesok = ConfirmSave::test_files(mwindow, &paths);
 330                         }
 331
 332                 } while (!result && filesok);
 333         mwindow->save_defaults();
 334         exportasset->save_defaults();
 335
 336 // FIX
 337         if(!result) exportasset->export_it();
 338
 339
 340         delete exportasset;
 341
 342 }
 343
 344
 345
 346
 347
 348
 349
 350
 351 #define WIDTH 410
 352 #define HEIGHT 400
 353
 354 static const char *list_titles[] =
 355 {
 356         N_("No."),
 357         N_("Track name")
 358 };
 359
 360
 361 static int list_widths[] =
 362 {
 363         40,
 364         200
 365 };
 366
 367 ExportEDLWindow::ExportEDLWindow(MWindow *mwindow, ExportEDL *exportedl, ExportEDLAsset *exportasset)
 368  : BC_Window(_(PROGRAM_NAME ": Export EDL"),
 369         mwindow->gui->get_screen_w(1, 0) / 2 - WIDTH / 2,
 370         mwindow->gui->get_root_h(1) / 2 - HEIGHT / 2,
 371         WIDTH,
 372         HEIGHT,
 373         (int)BC_INFINITY,
 374         (int)BC_INFINITY,
 375         0,
 376         0,
 377         1)
 378 {
 379         this->mwindow = mwindow;
 380         this->exportasset = exportasset;
 381 }
 382
 383 ExportEDLWindow::~ExportEDLWindow()
 384 {
 385 //      delete format_tools;
 386 //      delete loadmode;
 387 }
 388
 389
 390
 391 void ExportEDLWindow::create_objects()
 392 {
 393         int x = 5, y = 5;
 394         add_subwindow(new BC_Title(x,
 395                 y,
 396                         _("Select a file to export to:")));
 397         y += 25;
 398
 399         add_subwindow(path_textbox = new ExportEDLPathText(x, y, this));
 400         x += 300;
 401         path_recent = new BC_RecentList("EDLPATH", mwindow->defaults,
 402                                         path_textbox, 10, x, y, 300, 100);
 403         add_subwindow(path_recent);
 404 // FIX
 405         path_recent->load_items("EDLPATH");
 406
 407         x += 24;
 408         add_subwindow(path_button = new BrowseButton(
 409                 mwindow,
 410                 this,
 411                 path_textbox,
 412                 x,
 413                 y - 4,
 414                 exportasset->path,
 415                 _("Output to file"),
 416                 _("Select a file to write to:"),
 417                 0));
 418
 419         y += 34;
 420         x = 5;
 421         add_subwindow(new BC_Title(x, y, _("Select track to be exported:")));
 422         y += 25;
 423
 424
 425         items_tracks[0].remove_all_objects();
 426         items_tracks[1].remove_all_objects();
 427         int serial = 0;
 428         if (exportasset->track_number == -1)
 429                 exportasset->track_number = 0;
 430         for(Track *track = mwindow->edl->tracks->first;
 431                 track;
 432                 track = track->next)
 433         {
 434
 435                 char tmp[10];
 436                 sprintf(tmp, "%i\n", serial+1);
 437
 438                 BC_ListBoxItem *listitem = new BC_ListBoxItem(tmp);
 439                 if (serial == exportasset->track_number)
 440                         listitem->set_selected(1);
 441                 items_tracks[0].append(listitem);
 442                 items_tracks[1].append(new BC_ListBoxItem(track->title));
 443                 serial ++;
 444
 445         }
 446
 447
 448         add_subwindow(track_list = new ExportEDLWindowTrackList(this, x, y, 400, 200, items_tracks));
 449
 450         y += 5 + track_list->get_h();
 451         add_subwindow(new BC_Title(x, y, _("Currently only CMX 3600 format is supported")));
 452
 453
 454         add_subwindow(new BC_OKButton(this));
 455         add_subwindow(new BC_CancelButton(this));
 456         show_window();
 457 }
 458
 459
 460 ExportEDLPathText::ExportEDLPathText(int x, int y, ExportEDLWindow *window)
 461  : BC_TextBox(x, y, 300, 1, window->exportasset->path)
 462 {
 463         this->window = window;
 464 }
 465 ExportEDLPathText::~ExportEDLPathText()
 466 {
 467 }
 468 int ExportEDLPathText::handle_event()
 469 {
 470         strcpy(window->exportasset->path, get_text());
 471 //      window->handle_event();
 472         return 1;
 473 }
 474
 475 ExportEDLWindowTrackList::ExportEDLWindowTrackList(ExportEDLWindow *window,
 476         int x,
 477         int y,
 478         int w,
 479         int h,
 480         ArrayList<BC_ListBoxItem*> *track_list)
 481  : BC_ListBox(x,
 482                 y,
 483                 w,
 484                 h,
 485                 LISTBOX_TEXT,
 486                 track_list,
 487                 list_titles,
 488                 list_widths,
 489                 2)
 490 {
 491         this->window = window;
 492 }
 493
 494 int ExportEDLWindowTrackList::handle_event()
 495 {
 496 //      window->exportasset->track_number = get_selection_number(0, 0);
 497 //      printf("aaaaa %i\n", window->exportasset->track_number );
 498 //      window->set_done(0);
 499         return 1;
 500 }
 501
 502
 503