cinelerra/adeviceprefs.C

   1 #include "adeviceprefs.h"
   2 #include "audioalsa.h"
   3 #include "audiodevice.inc"
   4 #include "bitspopup.h"
   5 #include "edl.h"
   6 #include "language.h"
   7 #include "playbackconfig.h"
   8 #include "preferences.h"
   9 #include "preferencesthread.h"
  10 #include "recordconfig.h"
  11 #include <string.h>
  12
  13 #define DEVICE_H 50
  14
  15 ADevicePrefs::ADevicePrefs(int x,
  16         int y,
  17         PreferencesWindow *pwindow,
  18         PreferencesDialog *dialog,
  19         AudioOutConfig *out_config,
  20         AudioInConfig *in_config,
  21         int mode)
  22 {
  23         reset();
  24         this->pwindow = pwindow;
  25         this->dialog = dialog;
  26         this->driver = -1;
  27         this->mode = mode;
  28         this->out_config = out_config;
  29         this->in_config = in_config;
  30         this->x = x;
  31         this->y = y;
  32 }
  33
  34 ADevicePrefs::~ADevicePrefs()
  35 {
  36         delete_objects();
  37         if(menu) delete menu;
  38 }
  39
  40 void ADevicePrefs::reset()
  41 {
  42         menu = 0;
  43         firewire_path = 0;
  44         firewire_syt = 0;
  45         syt_title = 0;
  46         path_title = 0;
  47
  48         alsa_drivers = 0;
  49         path_title = 0;
  50         bits_title = 0;
  51         alsa_device = 0;
  52         alsa_bits = 0;
  53         alsa_workaround = 0;
  54 }
  55
  56 int ADevicePrefs::initialize(int creation)
  57 {
  58         int *driver;
  59         delete_objects();
  60
  61         switch(mode)
  62         {
  63                 case MODEPLAY:
  64                         driver = &out_config->driver;
  65                         break;
  66                 case MODERECORD:
  67                         driver = &in_config->driver;
  68                         break;
  69                 case MODEDUPLEX:
  70                         driver = &out_config->driver;
  71                         break;
  72         }
  73         this->driver = *driver;
  74
  75         if(!menu)
  76         {
  77                 dialog->add_subwindow(menu = new ADriverMenu(x,
  78                         y + 10,
  79                         this,
  80                         (mode == MODERECORD),
  81                         driver));
  82                 menu->create_objects();
  83         }
  84
  85         switch(*driver)
  86         {
  87                 case AUDIO_OSS:
  88                 case AUDIO_OSS_ENVY24:
  89                         create_oss_objs();
  90                         break;
  91                 case AUDIO_ALSA:
  92                         create_alsa_objs();
  93                         break;
  94                 case AUDIO_ESOUND:
  95                         create_esound_objs();
  96                         break;
  97                 case AUDIO_1394:
  98                 case AUDIO_DV1394:
  99                 case AUDIO_IEC61883:
 100                         create_firewire_objs();
 101                         break;
 102         }
 103         return 0;
 104 }
 105
 106 int ADevicePrefs::get_h(int recording)
 107 {
 108         if(!recording)
 109                 return DEVICE_H + 30;
 110         else
 111                 return DEVICE_H;
 112 }
 113
 114 int ADevicePrefs::delete_objects()
 115 {
 116         switch(driver)
 117         {
 118                 case AUDIO_OSS:
 119                 case AUDIO_OSS_ENVY24:
 120                         delete_oss_objs();
 121                         break;
 122                 case AUDIO_ALSA:
 123                         delete_alsa_objs();
 124                         break;
 125                 case AUDIO_ESOUND:
 126                         delete_esound_objs();
 127                         break;
 128                 case AUDIO_1394:
 129                 case AUDIO_DV1394:
 130                 case AUDIO_IEC61883:
 131                         delete_firewire_objs();
 132                         break;
 133         }
 134         reset();
 135         driver = -1;
 136         return 0;
 137 }
 138
 139 int ADevicePrefs::delete_oss_objs()
 140 {
 141         delete path_title;
 142         delete bits_title;
 143         delete oss_bits;
 144         for(int i = 0; i < MAXDEVICES; i++)
 145         {
 146                 delete oss_path[i];
 147 break;
 148         }
 149         return 0;
 150 }
 151
 152 int ADevicePrefs::delete_esound_objs()
 153 {
 154         delete server_title;
 155         delete port_title;
 156         delete esound_server;
 157         delete esound_port;
 158         return 0;
 159 }
 160
 161 int ADevicePrefs::delete_firewire_objs()
 162 {
 163         delete port_title;
 164         delete channel_title;
 165         delete firewire_port;
 166         delete firewire_channel;
 167         if(firewire_path)
 168         {
 169                 delete path_title;
 170                 delete firewire_path;
 171         }
 172         firewire_path = 0;
 173         if(firewire_syt)
 174         {
 175                 delete firewire_syt;
 176                 delete syt_title;
 177         }
 178         firewire_syt = 0;
 179         return 0;
 180 }
 181
 182 int ADevicePrefs::delete_alsa_objs()
 183 {
 184 #ifdef HAVE_ALSA
 185         alsa_drivers->remove_all_objects();
 186         delete alsa_drivers;
 187         delete path_title;
 188         delete bits_title;
 189         delete alsa_device;
 190         delete alsa_bits;
 191         delete alsa_workaround;
 192 #endif
 193         return 0;
 194 }
 195
 196
 197 int ADevicePrefs::create_oss_objs()
 198 {
 199         char *output_char;
 200         int *output_int;
 201         int y1 = y;
 202         BC_Resources *resources = BC_WindowBase::get_resources();
 203
 204         for(int i = 0; i < MAXDEVICES; i++)
 205         {
 206                 int x1 = x + menu->get_w() + 5;
 207                 switch(mode)
 208                 {
 209                         case MODEPLAY:
 210 //                              output_int = &out_config->oss_enable[i];
 211                                 break;
 212                         case MODERECORD:
 213 //                              output_int = &in_config->oss_enable[i];
 214                                 break;
 215                         case MODEDUPLEX:
 216 //                              output_int = &out_config->oss_enable[i];
 217                                 break;
 218                 }
 219 //              dialog->add_subwindow(oss_enable[i] = new OSSEnable(x1, y1 + 20, output_int));
 220 //              x1 += oss_enable[i]->get_w() + 5;
 221                 switch(mode)
 222                 {
 223                         case MODEPLAY:
 224                                 output_char = out_config->oss_out_device[i];
 225                                 break;
 226                         case MODERECORD:
 227                                 output_char = in_config->oss_in_device[i];
 228                                 break;
 229                         case MODEDUPLEX:
 230                                 output_char = out_config->oss_out_device[i];
 231                                 break;
 232                 }
 233                 if(i == 0) dialog->add_subwindow(path_title = new BC_Title(x1,
 234                         y,
 235                         _("Device path:"),
 236                         MEDIUMFONT,
 237                         resources->text_default));
 238                 dialog->add_subwindow(oss_path[i] = new ADeviceTextBox(x1,
 239                         y1 + 20,
 240                         output_char));
 241
 242                 x1 += oss_path[i]->get_w() + 5;
 243                 if(i == 0)
 244                 {
 245                         switch(mode)
 246                         {
 247                                 case MODEPLAY:
 248                                         output_int = &out_config->oss_out_bits;
 249                                         break;
 250                                 case MODERECORD:
 251                                         output_int = &in_config->oss_in_bits;
 252                                         break;
 253                                 case MODEDUPLEX:
 254                                         output_int = &out_config->oss_out_bits;
 255                                         break;
 256                         }
 257                         if(i == 0) dialog->add_subwindow(bits_title = new BC_Title(x1, y, _("Bits:"), MEDIUMFONT, resources->text_default));
 258                         oss_bits = new BitsPopup(dialog,
 259                                 x1,
 260                                 y1 + 20,
 261                                 output_int,
 262                                 0,
 263                                 0,
 264                                 0,
 265                                 0,
 266                                 1);
 267                         oss_bits->create_objects();
 268                 }
 269
 270                 x1 += oss_bits->get_w() + 5;
 271                 y1 += DEVICE_H;
 272 break;
 273         }
 274
 275         return 0;
 276 }
 277
 278 int ADevicePrefs::create_alsa_objs()
 279 {
 280 #ifdef HAVE_ALSA
 281         char *output_char;
 282         int *output_int;
 283         int y1 = y;
 284         BC_Resources *resources = BC_WindowBase::get_resources();
 285
 286         int x1 = x + menu->get_w() + 5;
 287
 288         ArrayList<char*> *alsa_titles = new ArrayList<char*>;
 289         AudioALSA::list_devices(alsa_titles, 0, mode);
 290
 291         alsa_drivers = new ArrayList<BC_ListBoxItem*>;
 292         for(int i = 0; i < alsa_titles->total; i++)
 293                 alsa_drivers->append(new BC_ListBoxItem(alsa_titles->values[i]));
 294         alsa_titles->remove_all_objects();
 295         delete alsa_titles;
 296
 297         switch(mode)
 298         {
 299                 case MODEPLAY:
 300                         output_char = out_config->alsa_out_device;
 301                         break;
 302                 case MODERECORD:
 303                         output_char = in_config->alsa_in_device;
 304                         break;
 305                 case MODEDUPLEX:
 306                         output_char = out_config->alsa_out_device;
 307                         break;
 308         }
 309         dialog->add_subwindow(path_title = new BC_Title(x1, y, _("Device:"), MEDIUMFONT, resources->text_default));
 310         alsa_device = new ALSADevice(dialog,
 311                 x1,
 312                 y1 + 20,
 313                 output_char,
 314                 alsa_drivers);
 315         alsa_device->create_objects();
 316         int x2 = x1;
 317
 318         x1 += alsa_device->get_w() + 5;
 319         switch(mode)
 320         {
 321                 case MODEPLAY:
 322                         output_int = &out_config->alsa_out_bits;
 323                         break;
 324                 case MODERECORD:
 325                         output_int = &in_config->alsa_in_bits;
 326                         break;
 327                 case MODEDUPLEX:
 328                         output_int = &out_config->alsa_out_bits;
 329                         break;
 330         }
 331         dialog->add_subwindow(bits_title = new BC_Title(x1, y, _("Bits:"), MEDIUMFONT, resources->text_default));
 332         alsa_bits = new BitsPopup(dialog,
 333                 x1,
 334                 y1 + 20,
 335                 output_int,
 336                 0,
 337                 0,
 338                 0,
 339                 0,
 340                 1);
 341         alsa_bits->create_objects();
 342
 343         y1 += alsa_bits->get_h() + 20 + 5;
 344         x1 = x2;
 345
 346         if(mode == MODEPLAY)
 347         {
 348                 dialog->add_subwindow(alsa_workaround =
 349                         new BC_CheckBox(x1,
 350                                 y1,
 351                                 &out_config->interrupt_workaround,
 352                                 _("Stop playback locks up.")));
 353         }
 354
 355
 356 #endif
 357
 358         return 0;
 359 }
 360
 361 int ADevicePrefs::create_esound_objs()
 362 {
 363         int x1 = x + menu->get_w() + 5;
 364         char *output_char;
 365         int *output_int;
 366         BC_Resources *resources = BC_WindowBase::get_resources();
 367
 368         switch(mode)
 369         {
 370                 case MODEPLAY:
 371                         output_char = out_config->esound_out_server;
 372                         break;
 373                 case MODERECORD:
 374                         output_char = in_config->esound_in_server;
 375                         break;
 376                 case MODEDUPLEX:
 377                         output_char = out_config->esound_out_server;
 378                         break;
 379         }
 380         dialog->add_subwindow(server_title = new BC_Title(x1, y, _("Server:"), MEDIUMFONT, resources->text_default));
 381         dialog->add_subwindow(esound_server = new ADeviceTextBox(x1, y + 20, output_char));
 382
 383         switch(mode)
 384         {
 385                 case MODEPLAY:
 386                         output_int = &out_config->esound_out_port;
 387                         break;
 388                 case MODERECORD:
 389                         output_int = &in_config->esound_in_port;
 390                         break;
 391                 case MODEDUPLEX:
 392                         output_int = &out_config->esound_out_port;
 393                         break;
 394         }
 395         x1 += esound_server->get_w() + 5;
 396         dialog->add_subwindow(port_title = new BC_Title(x1, y, _("Port:"), MEDIUMFONT, resources->text_default));
 397         dialog->add_subwindow(esound_port = new ADeviceIntBox(x1, y + 20, output_int));
 398         return 0;
 399 }
 400
 401 int ADevicePrefs::create_firewire_objs()
 402 {
 403         int x1 = x + menu->get_w() + 5;
 404         int *output_int = 0;
 405         char *output_char = 0;
 406         BC_Resources *resources = BC_WindowBase::get_resources();
 407
 408 // Firewire path
 409         switch(mode)
 410         {
 411                 case MODEPLAY:
 412                         if(driver == AUDIO_DV1394)
 413                                 output_char = out_config->dv1394_path;
 414                         else
 415                         if(driver == AUDIO_1394)
 416                                 output_char = out_config->firewire_path;
 417                         break;
 418                 case MODERECORD:
 419                         if(driver == AUDIO_DV1394 || driver == AUDIO_1394)
 420                                 output_char = in_config->firewire_path;
 421                         break;
 422         }
 423
 424         if(output_char)
 425         {
 426                 dialog->add_subwindow(path_title = new BC_Title(x1, y, _("Device Path:"), MEDIUMFONT, resources->text_default));
 427                 dialog->add_subwindow(firewire_path = new ADeviceTextBox(x1, y + 20, output_char));
 428                 x1 += firewire_path->get_w() + 5;
 429         }
 430
 431 // Firewire port
 432         switch(mode)
 433         {
 434                 case MODEPLAY:
 435                         if(driver == AUDIO_DV1394)
 436                                 output_int = &out_config->dv1394_port;
 437                         else
 438                                 output_int = &out_config->firewire_port;
 439                         break;
 440                 case MODERECORD:
 441                         output_int = &in_config->firewire_port;
 442                         break;
 443                 case MODEDUPLEX:
 444 //                      output_int = &out_config->afirewire_out_port;
 445                         break;
 446         }
 447         dialog->add_subwindow(port_title = new BC_Title(x1, y, _("Port:"), MEDIUMFONT, resources->text_default));
 448         dialog->add_subwindow(firewire_port = new ADeviceIntBox(x1, y + 20, output_int));
 449
 450         x1 += firewire_port->get_w() + 5;
 451
 452 // Firewire channel
 453         switch(mode)
 454         {
 455                 case MODEPLAY:
 456                         if(driver == AUDIO_DV1394)
 457                                 output_int = &out_config->dv1394_channel;
 458                         else
 459                                 output_int = &out_config->firewire_channel;
 460                         break;
 461                 case MODERECORD:
 462                         output_int = &in_config->firewire_channel;
 463                         break;
 464         }
 465         dialog->add_subwindow(channel_title = new BC_Title(x1, y, _("Channel:"), MEDIUMFONT, resources->text_default));
 466         dialog->add_subwindow(firewire_channel = new ADeviceIntBox(x1, y + 20, output_int));
 467         x1 += firewire_channel->get_w() + 5;
 468
 469 // Syt offset
 470         switch(mode)
 471         {
 472                 case MODEPLAY:
 473                         if(driver == AUDIO_DV1394)
 474                                 output_int = &out_config->dv1394_syt;
 475                         else
 476                         if(driver == AUDIO_1394)
 477                                 output_int = &out_config->firewire_syt;
 478                         else
 479                                 output_int = 0;
 480                         break;
 481                 case MODERECORD:
 482                         output_int = 0;
 483                         break;
 484         }
 485
 486         if(output_int)
 487         {
 488                 dialog->add_subwindow(syt_title = new BC_Title(x1, y, _("Syt Offset:"), MEDIUMFONT, resources->text_default));
 489                 dialog->add_subwindow(firewire_syt = new ADeviceIntBox(x1, y + 20, output_int));
 490                 x1 += firewire_syt->get_w() + 5;
 491         }
 492
 493         return 0;
 494 }
 495
 496 ADriverMenu::ADriverMenu(int x,
 497         int y,
 498         ADevicePrefs *device_prefs,
 499         int do_input,
 500         int *output)
 501  : BC_PopupMenu(x, y, 125, adriver_to_string(*output), 1)
 502 {
 503         this->output = output;
 504         this->do_input = do_input;
 505         this->device_prefs = device_prefs;
 506 }
 507
 508 ADriverMenu::~ADriverMenu()
 509 {
 510 }
 511
 512 void ADriverMenu::create_objects()
 513 {
 514         add_item(new ADriverItem(this, AUDIO_OSS_TITLE, AUDIO_OSS));
 515         add_item(new ADriverItem(this, AUDIO_OSS_ENVY24_TITLE, AUDIO_OSS_ENVY24));
 516
 517 #ifdef HAVE_ALSA
 518         add_item(new ADriverItem(this, AUDIO_ALSA_TITLE, AUDIO_ALSA));
 519 #endif
 520
 521         if(!do_input) add_item(new ADriverItem(this, AUDIO_ESOUND_TITLE, AUDIO_ESOUND));
 522 //      add_item(new ADriverItem(this, AUDIO_NAS_TITLE, AUDIO_NAS));
 523 #ifdef HAVE_FIREWIRE
 524         if(!do_input) add_item(new ADriverItem(this, AUDIO_1394_TITLE, AUDIO_1394));
 525         add_item(new ADriverItem(this, AUDIO_DV1394_TITLE, AUDIO_DV1394));
 526         add_item(new ADriverItem(this, AUDIO_IEC61883_TITLE, AUDIO_IEC61883));
 527 #endif
 528 }
 529
 530 char* ADriverMenu::adriver_to_string(int driver)
 531 {
 532         switch(driver)
 533         {
 534                 case AUDIO_OSS:
 535                         sprintf(string, AUDIO_OSS_TITLE);
 536                         break;
 537                 case AUDIO_OSS_ENVY24:
 538                         sprintf(string, AUDIO_OSS_ENVY24_TITLE);
 539                         break;
 540                 case AUDIO_ESOUND:
 541                         sprintf(string, AUDIO_ESOUND_TITLE);
 542                         break;
 543                 case AUDIO_NAS:
 544                         sprintf(string, AUDIO_NAS_TITLE);
 545                         break;
 546                 case AUDIO_ALSA:
 547                         sprintf(string, AUDIO_ALSA_TITLE);
 548                         break;
 549 #ifdef HAVE_FIREWIRE
 550                 case AUDIO_1394:
 551                         sprintf(string, AUDIO_1394_TITLE);
 552                         break;
 553                 case AUDIO_DV1394:
 554                         sprintf(string, AUDIO_DV1394_TITLE);
 555                         break;
 556                 case AUDIO_IEC61883:
 557                         sprintf(string, AUDIO_IEC61883_TITLE);
 558                         break;
 559 #endif
 560         }
 561         return string;
 562 }
 563
 564 ADriverItem::ADriverItem(ADriverMenu *popup, char *text, int driver)
 565  : BC_MenuItem(text)
 566 {
 567         this->popup = popup;
 568         this->driver = driver;
 569 }
 570
 571 ADriverItem::~ADriverItem()
 572 {
 573 }
 574
 575 int ADriverItem::handle_event()
 576 {
 577         popup->set_text(get_text());
 578         *(popup->output) = driver;
 579         popup->device_prefs->initialize();
 580         return 1;
 581 }
 582
 583
 584
 585
 586 OSSEnable::OSSEnable(int x, int y, int *output)
 587  : BC_CheckBox(x, y, *output)
 588 {
 589         this->output = output;
 590 }
 591 int OSSEnable::handle_event()
 592 {
 593         *output = get_value();
 594         return 1;
 595 }
 596
 597
 598
 599
 600 ADeviceTextBox::ADeviceTextBox(int x, int y, char *output)
 601  : BC_TextBox(x, y, 150, 1, output)
 602 {
 603         this->output = output;
 604 }
 605
 606 int ADeviceTextBox::handle_event()
 607 {
 608         strcpy(output, get_text());
 609         return 1;
 610 }
 611
 612 ADeviceIntBox::ADeviceIntBox(int x, int y, int *output)
 613  : BC_TextBox(x, y, 80, 1, *output)
 614 {
 615         this->output = output;
 616 }
 617
 618 int ADeviceIntBox::handle_event()
 619 {
 620         *output = atol(get_text());
 621         return 1;
 622 }
 623
 624
 625 ALSADevice::ALSADevice(PreferencesDialog *dialog,
 626         int x,
 627         int y,
 628         char *output,
 629         ArrayList<BC_ListBoxItem*> *devices)
 630  : BC_PopupTextBox(dialog,
 631         devices,
 632         output,
 633         x,
 634         y,
 635         200,
 636         200)
 637 {
 638         this->output = output;
 639 }
 640
 641 ALSADevice::~ALSADevice()
 642 {
 643 }
 644
 645 int ALSADevice::handle_event()
 646 {
 647         strcpy(output, get_text());
 648         return 1;
 649 }
 650