cinelerra-5.1/cinelerra/adeviceprefs.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 "adeviceprefs.h"
  23 #include "audioalsa.h"
  24 #include "audiodevice.inc"
  25 #include "audiopulse.h"
  26 #include "bcsignals.h"
  27 #include "bitspopup.h"
  28 #include "edl.h"
  29 #include "language.h"
  30 #include "mwindow.h"
  31 #include "playbackconfig.h"
  32 #include "preferences.h"
  33 #include "preferencesthread.h"
  34 #include "recordconfig.h"
  35 #include "theme.h"
  36 #include <string.h>
  37
  38 //#define DEVICE_H 50
  39
  40 ADevicePrefs::ADevicePrefs(int x, int y, PreferencesWindow *pwindow, PreferencesDialog *dialog,
  41         AudioOutConfig *out_config, AudioInConfig *in_config, int mode)
  42 {
  43         reset();
  44         this->pwindow = pwindow;
  45         this->dialog = dialog;
  46         this->driver = -1;
  47         this->mode = mode;
  48         this->out_config = out_config;
  49         this->in_config = in_config;
  50         this->x = x;
  51         this->y = y;
  52 }
  53
  54 ADevicePrefs::~ADevicePrefs()
  55 {
  56         delete_objects();
  57         if(menu) delete menu;
  58 }
  59
  60 void ADevicePrefs::reset()
  61 {
  62         menu = 0;
  63         follow_audio_config = 0;
  64         firewire_path = 0;
  65         firewire_syt = 0;
  66         channel_title = 0;
  67         firewire_port = 0;
  68         firewire_channel = 0;
  69         syt_title = 0;
  70         path_title = 0;
  71
  72         alsa_drivers = 0;
  73         path_title = 0;
  74         bits_title = 0;
  75         alsa_device = 0;
  76         alsa_workaround = 0;
  77
  78         alsa_bits = 0;
  79         oss_bits = 0;
  80         dvb_bits = 0;
  81         v4l2_bits = 0;
  82
  83         for(int i = 0; i < MAXDEVICES; i++)
  84                 oss_path[i] = 0;
  85
  86         dvb_adapter_title = 0;
  87         dvb_adapter_path = 0;
  88         dvb_device_title = 0;
  89         dvb_adapter_device = 0;
  90
  91         cine_bits = 0;
  92         cine_path = 0;
  93         server_title = 0;
  94         port_title = 0;
  95         port = 0;
  96 }
  97
  98 int ADevicePrefs::initialize(int creation)
  99 {
 100         int *driver = 0;
 101         delete_objects();
 102
 103         switch(mode) {
 104         case MODEPLAY:
 105                 driver = &out_config->driver;
 106                 break;
 107         case MODERECORD:
 108                 driver = &in_config->driver;
 109                 break;
 110         case MODEDUPLEX:
 111                 driver = &out_config->driver;
 112                 break;
 113         }
 114         this->driver = *driver;
 115
 116         if(!menu) {
 117                 dialog->add_subwindow(menu = new ADriverMenu(x,
 118                         y + yS(10), this, (mode == MODERECORD), driver));
 119                 menu->create_objects();
 120         }
 121
 122         switch(*driver) {
 123         case AUDIO_OSS:
 124         case AUDIO_OSS_ENVY24:
 125                 create_oss_objs();
 126                 break;
 127         case AUDIO_ALSA:
 128                 create_alsa_objs();
 129                 break;
 130         case AUDIO_PULSE:
 131                 create_pulse_objs();
 132                 break;
 133         case AUDIO_ESOUND:
 134                 create_esound_objs();
 135                 break;
 136         case AUDIO_1394:
 137         case AUDIO_DV1394:
 138         case AUDIO_IEC61883:
 139                 create_firewire_objs();
 140                 break;
 141         case AUDIO_DVB:
 142                 create_dvb_objs();
 143                 break;
 144         case AUDIO_V4L2MPEG:
 145                 create_v4l2mpeg_objs();
 146                 break;
 147         }
 148
 149         return 0;
 150 }
 151
 152 int ADevicePrefs::get_h(int recording)
 153 {
 154         int margin = pwindow->mwindow->theme->widget_border;
 155         int result = BC_Title::calculate_h(dialog, "X", MEDIUMFONT) + margin +
 156                 BC_TextBox::calculate_h(dialog, MEDIUMFONT, 1, 1);
 157         if( !recording ) {
 158                 result += BC_CheckBox::calculate_h(dialog) + margin;
 159         }
 160
 161         return result;
 162 }
 163
 164 int ADevicePrefs::delete_objects()
 165 {
 166         switch(driver) {
 167         case AUDIO_OSS:
 168         case AUDIO_OSS_ENVY24:
 169                 delete_oss_objs();
 170                 break;
 171         case AUDIO_ALSA:
 172                 delete_alsa_objs();
 173                 break;
 174         case AUDIO_PULSE:
 175                 delete_pulse_objs();
 176                 break;
 177         case AUDIO_ESOUND:
 178                 delete_esound_objs();
 179                 break;
 180         case AUDIO_1394:
 181         case AUDIO_DV1394:
 182         case AUDIO_IEC61883:
 183                 delete_firewire_objs();
 184                 break;
 185         case AUDIO_DVB:
 186                 delete_dvb_objs();
 187                 break;
 188         case AUDIO_V4L2MPEG:
 189                 delete_v4l2mpeg_objs();
 190                 break;
 191         }
 192
 193         delete cine_bits;
 194         delete cine_path;
 195
 196         reset();
 197         driver = -1;
 198         return 0;
 199 }
 200
 201 int ADevicePrefs::delete_oss_objs()
 202 {
 203         delete path_title;
 204         delete bits_title;
 205         delete oss_bits;
 206
 207         for(int i = 0; i < MAXDEVICES; i++)
 208                 delete oss_path[i];
 209         return 0;
 210 }
 211
 212 int ADevicePrefs::delete_esound_objs()
 213 {
 214         delete server_title;
 215         delete server;
 216         delete port_title;
 217         delete port;
 218         return 0;
 219 }
 220
 221 int ADevicePrefs::delete_firewire_objs()
 222 {
 223         delete port_title;
 224         delete channel_title;
 225         delete firewire_port;
 226         delete firewire_channel;
 227         if(firewire_path)
 228         {
 229                 delete path_title;
 230                 delete firewire_path;
 231         }
 232         firewire_path = 0;
 233         if(firewire_syt)
 234         {
 235                 delete firewire_syt;
 236                 delete syt_title;
 237         }
 238         firewire_syt = 0;
 239         return 0;
 240 }
 241
 242 int ADevicePrefs::delete_alsa_objs()
 243 {
 244 #ifdef HAVE_ALSA
 245         if(alsa_drivers) alsa_drivers->remove_all_objects();
 246         delete alsa_drivers;
 247         delete path_title;
 248         delete bits_title;
 249         delete alsa_device;
 250         delete alsa_bits;
 251         delete alsa_workaround;
 252 #endif
 253         return 0;
 254 }
 255
 256 int ADevicePrefs::delete_pulse_objs()
 257 {
 258 #ifdef HAVE_PULSE
 259         delete server_title;
 260         delete server;
 261 #endif
 262         return 0;
 263 }
 264
 265 int ADevicePrefs::delete_dvb_objs()
 266 {
 267         delete dvb_adapter_title;
 268         delete dvb_adapter_path;
 269         delete dvb_device_title;
 270         delete dvb_adapter_device;
 271         delete dvb_bits;
 272         delete follow_audio_config;
 273         return 0;
 274 }
 275
 276 int ADevicePrefs::delete_v4l2mpeg_objs()
 277 {
 278         delete follow_audio_config;
 279         delete v4l2_bits;
 280         return 0;
 281 }
 282
 283 int ADevicePrefs::create_oss_objs()
 284 {
 285         char *output_char = 0;
 286         int *output_int = 0;
 287         int margin = pwindow->mwindow->theme->widget_border;
 288         int y1 = y;
 289         BC_Resources *resources = BC_WindowBase::get_resources();
 290
 291         for(int i = 0; i < MAXDEVICES; i++) {
 292                 int x1 = x + menu->get_w() + xS(5);
 293 #if 0
 294                 switch(mode) {
 295                 case MODEPLAY:
 296                         output_int = &out_config->oss_enable[i];
 297                         break;
 298                 case MODERECORD:
 299                         output_int = &in_config->oss_enable[i];
 300                         break;
 301                 case MODEDUPLEX:
 302                         output_int = &out_config->oss_enable[i];
 303                         break;
 304                 }
 305                 dialog->add_subwindow(oss_enable[i] = new OSSEnable(x1, y1 + yS(20), output_int));
 306                 x1 += oss_enable[i]->get_w() + margin;
 307 #endif
 308                 switch(mode) {
 309                 case MODEPLAY:
 310                         output_char = out_config->oss_out_device[i];
 311                         break;
 312                 case MODERECORD:
 313                         output_char = in_config->oss_in_device[i];
 314                         break;
 315                 case MODEDUPLEX:
 316                         output_char = out_config->oss_out_device[i];
 317                         break;
 318                 }
 319
 320                 if(i == 0) {
 321                         path_title = new BC_Title(x1, y, _("Device path:"),
 322                                 MEDIUMFONT, resources->text_default);
 323                         dialog->add_subwindow(path_title);
 324                 }
 325
 326                 oss_path[i] = new ADeviceTextBox(
 327                         x1, y1 + path_title->get_h() + margin, output_char);
 328                 dialog->add_subwindow(oss_path[i]);
 329                 x1 += oss_path[i]->get_w() + margin;
 330                 if(i == 0) {
 331                         switch(mode) {
 332                         case MODEPLAY:
 333                                 output_int = &out_config->oss_out_bits;
 334                                 break;
 335                         case MODERECORD:
 336                                 output_int = &in_config->oss_in_bits;
 337                                 break;
 338                         case MODEDUPLEX:
 339                                 output_int = &out_config->oss_out_bits;
 340                                 break;
 341                         }
 342                         bits_title = new BC_Title(x1, y, _("Bits:"),
 343                                         MEDIUMFONT, resources->text_default);
 344                         dialog->add_subwindow(bits_title);
 345                         oss_bits = new BitsPopup(dialog,
 346                                 x1, y1 + bits_title->get_h() + margin,
 347                                 output_int, 0, 0, 0, 0, 1);
 348                         oss_bits->create_objects();
 349                 }
 350
 351                 x1 += oss_bits->get_w() + margin;
 352 //              y1 += DEVICE_H;
 353                 break;
 354         }
 355
 356         return 0;
 357 }
 358
 359 int ADevicePrefs::create_alsa_objs()
 360 {
 361 #ifdef HAVE_ALSA
 362         char *output_char = 0;
 363         int *output_int = 0;
 364         int margin = pwindow->mwindow->theme->widget_border;
 365         BC_Resources *resources = BC_WindowBase::get_resources();
 366
 367         int x1 = x + menu->get_w() + margin;
 368         int y1 = y;
 369
 370         ArrayList<char*> *alsa_titles = new ArrayList<char*>;
 371         alsa_titles->set_array_delete();
 372         AudioALSA::list_devices(alsa_titles, 0, mode);
 373         AudioALSA::add_pulse_devices(mode, alsa_titles, 0);
 374
 375         alsa_drivers = new ArrayList<BC_ListBoxItem*>;
 376         for(int i = 0; i < alsa_titles->total; i++)
 377                 alsa_drivers->append(new BC_ListBoxItem(alsa_titles->values[i]));
 378         alsa_titles->remove_all_objects();
 379         delete alsa_titles;
 380
 381         switch(mode) {
 382         case MODEPLAY:
 383                 output_char = out_config->alsa_out_device;
 384                 break;
 385         case MODERECORD:
 386                 output_char = in_config->alsa_in_device;
 387                 break;
 388         case MODEDUPLEX:
 389                 output_char = out_config->alsa_out_device;
 390                 break;
 391         }
 392         path_title = new BC_Title(x1, y, _("Device:"),
 393                         MEDIUMFONT, resources->text_default);
 394         dialog->add_subwindow(path_title);
 395         y1 += path_title->get_h() + margin;
 396         alsa_device = new ALSADevice(dialog,
 397                 x1, y1, output_char, alsa_drivers);
 398         alsa_device->create_objects();
 399         int x2 = x1;
 400
 401         x1 += alsa_device->get_w() + xS(5);
 402         switch(mode) {
 403         case MODEPLAY:
 404                 output_int = &out_config->alsa_out_bits;
 405                 break;
 406         case MODERECORD:
 407                 output_int = &in_config->alsa_in_bits;
 408                 break;
 409         case MODEDUPLEX:
 410                 output_int = &out_config->alsa_out_bits;
 411                 break;
 412         }
 413         bits_title = new BC_Title(x1, y, _("Bits:"),
 414                         MEDIUMFONT, resources->text_default);
 415         dialog->add_subwindow(bits_title);
 416         y1 = y + bits_title->get_h() + margin;
 417         alsa_bits = new BitsPopup(dialog,
 418                         x1, y1, output_int, 0, 0, 0, 0, 1);
 419         alsa_bits->create_objects();
 420
 421         y1 += alsa_bits->get_h();
 422         x1 = x2;
 423
 424         if(mode == MODEPLAY) {
 425                 alsa_workaround = new BC_CheckBox(x1, y1,
 426                                 &out_config->interrupt_workaround,
 427                                 _("Stop playback locks up."));
 428                 dialog->add_subwindow(alsa_workaround);
 429         }
 430 #endif
 431         return 0;
 432 }
 433
 434 int ADevicePrefs::create_esound_objs()
 435 {
 436         int x1 = x + menu->get_w() + xS(5);
 437         char *output_char = 0;
 438         int *output_int = 0;
 439         BC_Resources *resources = BC_WindowBase::get_resources();
 440
 441         switch(mode) {
 442         case MODEPLAY:
 443                 output_char = out_config->esound_out_server;
 444                 break;
 445         case MODERECORD:
 446                 output_char = in_config->esound_in_server;
 447                 break;
 448         case MODEDUPLEX:
 449                 output_char = out_config->esound_out_server;
 450                 break;
 451         }
 452         server_title = new BC_Title(x1, y, _("Server:"),
 453                         MEDIUMFONT, resources->text_default);
 454         dialog->add_subwindow(server_title);
 455         server = new ADeviceTextBox(x1, y + yS(20), output_char);
 456         dialog->add_subwindow(server);
 457
 458         switch(mode) {
 459         case MODEPLAY:
 460                 output_int = &out_config->esound_out_port;
 461                 break;
 462         case MODERECORD:
 463                 output_int = &in_config->esound_in_port;
 464                 break;
 465         case MODEDUPLEX:
 466                 output_int = &out_config->esound_out_port;
 467                 break;
 468         }
 469         x1 += server->get_w() + xS(5);
 470         port_title = new BC_Title(x1, y, _("Port:"),
 471                         MEDIUMFONT, resources->text_default);
 472         dialog->add_subwindow(port_title);
 473         port = new ADeviceIntBox(x1, y + yS(20), output_int);
 474         dialog->add_subwindow(port);
 475         return 0;
 476 }
 477
 478 int ADevicePrefs::create_firewire_objs()
 479 {
 480         int xs5 = xS(5);
 481         int ys20 = yS(20);
 482         int x1 = x + menu->get_w() + xs5;
 483         int *output_int = 0;
 484         char *output_char = 0;
 485         BC_Resources *resources = BC_WindowBase::get_resources();
 486
 487 // Firewire path
 488         switch(mode) {
 489         case MODEPLAY:
 490                 if(driver == AUDIO_DV1394)
 491                         output_char = out_config->dv1394_path;
 492                 else
 493                 if(driver == AUDIO_1394)
 494                         output_char = out_config->firewire_path;
 495                 break;
 496         case MODERECORD:
 497                 if(driver == AUDIO_DV1394 || driver == AUDIO_1394)
 498                         output_char = in_config->firewire_path;
 499                 break;
 500         }
 501
 502         if(output_char) {
 503                 dialog->add_subwindow(path_title = new BC_Title(x1, y, _("Device Path:"), MEDIUMFONT, resources->text_default));
 504                 dialog->add_subwindow(firewire_path = new ADeviceTextBox(x1, y + ys20, output_char));
 505                 x1 += firewire_path->get_w() + xs5;
 506         }
 507
 508 // Firewire port
 509         switch(mode) {
 510         case MODEPLAY:
 511                 if(driver == AUDIO_DV1394)
 512                         output_int = &out_config->dv1394_port;
 513                 else
 514                         output_int = &out_config->firewire_port;
 515                 break;
 516         case MODERECORD:
 517                 output_int = &in_config->firewire_port;
 518                 break;
 519         case MODEDUPLEX:
 520 //              output_int = &out_config->afirewire_out_port;
 521                 break;
 522         }
 523         port_title = new BC_Title(x1, y, _("Port:"),
 524                         MEDIUMFONT, resources->text_default);
 525         dialog->add_subwindow(port_title);
 526         firewire_port = new ADeviceIntBox(x1, y + ys20, output_int);
 527         dialog->add_subwindow(firewire_port);
 528
 529         x1 += firewire_port->get_w() + xs5;
 530
 531 // Firewire channel
 532         switch(mode) {
 533         case MODEPLAY:
 534                 if(driver == AUDIO_DV1394)
 535                         output_int = &out_config->dv1394_channel;
 536                 else
 537                         output_int = &out_config->firewire_channel;
 538                 break;
 539         case MODERECORD:
 540                 output_int = &in_config->firewire_channel;
 541                 break;
 542         }
 543         channel_title = new BC_Title(x1, y, _("Channel:"),
 544                         MEDIUMFONT, resources->text_default);
 545         dialog->add_subwindow(channel_title);
 546         firewire_channel = new ADeviceIntBox(x1, y + ys20, output_int);
 547         dialog->add_subwindow(firewire_channel);
 548         x1 += firewire_channel->get_w() + xs5;
 549
 550 // Syt offset
 551         switch(mode) {
 552         case MODEPLAY:
 553                 if(driver == AUDIO_DV1394)
 554                         output_int = &out_config->dv1394_syt;
 555                 else
 556                 if(driver == AUDIO_1394)
 557                         output_int = &out_config->firewire_syt;
 558                 else
 559                         output_int = 0;
 560                 break;
 561         case MODERECORD:
 562                 output_int = 0;
 563                 break;
 564         }
 565
 566         if(output_int) {
 567                 syt_title = new BC_Title(x1, y, _("Syt Offset:"),
 568                                 MEDIUMFONT, resources->text_default);
 569                 dialog->add_subwindow(syt_title);
 570                 firewire_syt = new ADeviceIntBox(x1, y + ys20, output_int);
 571                 dialog->add_subwindow(firewire_syt);
 572                 x1 += firewire_syt->get_w() + xs5;
 573         }
 574
 575         return 0;
 576 }
 577
 578
 579
 580 int ADevicePrefs::create_dvb_objs()
 581 {
 582         int x1 = x + menu->get_w() + xS(30);
 583         int y1 = y + yS(10);
 584         char *output_char = in_config->dvb_in_adapter;
 585         int y2 = y1 - BC_Title::calculate_h(dialog, _("DVB Adapter:"), MEDIUMFONT) - yS(5);
 586         BC_Resources *resources = BC_WindowBase::get_resources();
 587         dvb_adapter_title = new BC_Title(x1, y2, _("DVB Adapter:"),
 588                         MEDIUMFONT, resources->text_default);
 589         dialog->add_subwindow(dvb_adapter_title);
 590         dvb_adapter_path = new ADeviceTextBox(x1, y1, output_char);
 591         dialog->add_subwindow(dvb_adapter_path);
 592         int x2 = x1 + dvb_adapter_path->get_w() + xS(5);
 593         dvb_device_title = new BC_Title(x2, y2, _("dev:"),
 594                         MEDIUMFONT, resources->text_default);
 595         dialog->add_subwindow(dvb_device_title);
 596         int *output_int = &in_config->dvb_in_device;
 597         dvb_adapter_device = new ADeviceTumbleBox(this, x2, y1, output_int, 0, 9, xS(20));
 598         dvb_adapter_device->create_objects();
 599         x2 += dvb_device_title->get_w() + xS(30);
 600         bits_title = new BC_Title(x2, y2, _("Bits:"),
 601                         MEDIUMFONT, resources->text_default);
 602         dialog->add_subwindow(bits_title);
 603         output_int = &in_config->dvb_in_bits;
 604         dvb_bits = new BitsPopup(dialog, x2, y1, output_int, 0, 0, 0, 0, 1);
 605         dvb_bits->create_objects();
 606         x1 += xS(100);  y1 += dvb_adapter_path->get_h() + yS(5);
 607         output_int =  &in_config->follow_audio;
 608         follow_audio_config = new BC_CheckBox(x1, y1, output_int, _("Follow audio config"));
 609         dialog->add_subwindow(follow_audio_config);
 610         return 0;
 611 }
 612
 613 int ADevicePrefs::create_v4l2mpeg_objs()
 614 {
 615         int x1 = x + menu->get_w() + xS(30);
 616         int y1 = y + yS(10);
 617         int y2 = y1 - BC_Title::calculate_h(dialog, _("Bits:"), MEDIUMFONT) - yS(5);
 618         BC_Resources *resources = BC_WindowBase::get_resources();
 619         bits_title = new BC_Title(x1, y2, _("Bits:"),
 620                         MEDIUMFONT, resources->text_default);
 621         dialog->add_subwindow(bits_title);
 622         int *output_int = &in_config->v4l2_in_bits;
 623         v4l2_bits = new BitsPopup(dialog, x1, y1, output_int, 0, 0, 0, 0, 1);
 624         v4l2_bits->create_objects();
 625         x1 += v4l2_bits->get_w() + xS(10);
 626         follow_audio_config = new BC_CheckBox(x1, y1,
 627                         &in_config->follow_audio, _("Follow audio config"));
 628         dialog->add_subwindow(follow_audio_config);
 629         return 0;
 630 }
 631
 632
 633 int ADevicePrefs::create_pulse_objs()
 634 {
 635 #ifdef HAVE_PULSE
 636         char *output_char = 0;
 637         switch(mode) {
 638         case MODEPLAY:
 639                 output_char = out_config->pulse_out_server;
 640                 break;
 641         case MODERECORD:
 642                 output_char = in_config->pulse_in_server;
 643                 break;
 644         }
 645         int x1 = x, y1 = y;
 646         x1 += menu->get_w() + xS(5);
 647         dialog->add_subwindow(server_title = new BC_Title(x1, y1,
 648                 _("Server (blank for default):")));
 649         y1 += server_title->get_h() + yS(5);
 650         dialog->add_subwindow(server = new ADeviceTextBox(x1, y1, output_char));
 651 #endif
 652         return 0;
 653 }
 654
 655
 656 ADriverMenu::ADriverMenu(int x, int y, ADevicePrefs *device_prefs,
 657         int do_input, int *output)
 658  : BC_PopupMenu(x, y, xS(125), adriver_to_string(*output), 1)
 659 {
 660         this->output = output;
 661         this->do_input = do_input;
 662         this->device_prefs = device_prefs;
 663 }
 664
 665 ADriverMenu::~ADriverMenu()
 666 {
 667 }
 668
 669 void ADriverMenu::create_objects()
 670 {
 671 #ifdef HAVE_ALSA
 672         add_item(new ADriverItem(this, AUDIO_ALSA_TITLE, AUDIO_ALSA));
 673 #endif
 674
 675 #ifdef HAVE_OSS
 676         add_item(new ADriverItem(this, AUDIO_OSS_TITLE, AUDIO_OSS));
 677         add_item(new ADriverItem(this, AUDIO_OSS_ENVY24_TITLE, AUDIO_OSS_ENVY24));
 678 #endif
 679
 680 #ifdef HAVE_ESOUND
 681         if(!do_input) add_item(new ADriverItem(this, AUDIO_ESOUND_TITLE, AUDIO_ESOUND));
 682 #endif
 683
 684 #ifdef HAVE_FIREWIRE
 685         if(!do_input) add_item(new ADriverItem(this, AUDIO_1394_TITLE, AUDIO_1394));
 686         add_item(new ADriverItem(this, AUDIO_DV1394_TITLE, AUDIO_DV1394));
 687         add_item(new ADriverItem(this, AUDIO_IEC61883_TITLE, AUDIO_IEC61883));
 688 #endif
 689
 690 #ifdef HAVE_DVB
 691         if(do_input) add_item(new ADriverItem(this, AUDIO_DVB_TITLE, AUDIO_DVB));
 692 #endif
 693
 694 #ifdef HAVE_VIDEO4LINUX2
 695         if(do_input) add_item(new ADriverItem(this, AUDIO_V4L2MPEG_TITLE, AUDIO_V4L2MPEG));
 696 #endif
 697 #ifdef HAVE_PULSE
 698         add_item(new ADriverItem(this, AUDIO_PULSE_TITLE, AUDIO_PULSE));
 699 #endif
 700 }
 701
 702 char* ADriverMenu::adriver_to_string(int driver)
 703 {
 704         switch(driver) {
 705         case AUDIO_OSS:
 706                 sprintf(string, AUDIO_OSS_TITLE);
 707                 break;
 708         case AUDIO_OSS_ENVY24:
 709                 sprintf(string, AUDIO_OSS_ENVY24_TITLE);
 710                 break;
 711         case AUDIO_ESOUND:
 712                 sprintf(string, AUDIO_ESOUND_TITLE);
 713                 break;
 714         case AUDIO_PULSE:
 715                 sprintf(string, AUDIO_PULSE_TITLE);
 716                 break;
 717         case AUDIO_NAS:
 718                 sprintf(string, AUDIO_NAS_TITLE);
 719                 break;
 720         case AUDIO_ALSA:
 721                 sprintf(string, AUDIO_ALSA_TITLE);
 722                 break;
 723 #ifdef HAVE_FIREWIRE
 724         case AUDIO_1394:
 725                 sprintf(string, AUDIO_1394_TITLE);
 726                 break;
 727         case AUDIO_DV1394:
 728                 sprintf(string, AUDIO_DV1394_TITLE);
 729                 break;
 730         case AUDIO_IEC61883:
 731                 sprintf(string, AUDIO_IEC61883_TITLE);
 732                 break;
 733 #endif
 734         case AUDIO_DVB:
 735                 sprintf(string, AUDIO_DVB_TITLE);
 736                 break;
 737         case AUDIO_V4L2MPEG:
 738                 sprintf(string, AUDIO_V4L2MPEG_TITLE);
 739                 break;
 740         }
 741         return string;
 742 }
 743
 744 ADriverItem::ADriverItem(ADriverMenu *popup, const char *text, int driver)
 745  : BC_MenuItem(text)
 746 {
 747         this->popup = popup;
 748         this->driver = driver;
 749 }
 750
 751 ADriverItem::~ADriverItem()
 752 {
 753 }
 754
 755 int ADriverItem::handle_event()
 756 {
 757         popup->set_text(get_text());
 758         *(popup->output) = driver;
 759         popup->device_prefs->initialize(0);
 760         popup->device_prefs->pwindow->show_dialog();
 761         return 1;
 762 }
 763
 764
 765
 766
 767 OSSEnable::OSSEnable(int x, int y, int *output)
 768  : BC_CheckBox(x, y, *output)
 769 {
 770         this->output = output;
 771 }
 772 int OSSEnable::handle_event()
 773 {
 774         *output = get_value();
 775         return 1;
 776 }
 777
 778
 779
 780
 781 ADeviceTextBox::ADeviceTextBox(int x, int y, char *output)
 782  : BC_TextBox(x, y, xS(150), 1, output)
 783 {
 784         this->output = output;
 785 }
 786
 787 int ADeviceTextBox::handle_event()
 788 {
 789         strcpy(output, get_text());
 790         return 1;
 791 }
 792
 793 ADeviceIntBox::ADeviceIntBox(int x, int y, int *output)
 794  : BC_TextBox(x, y, xS(80), 1, *output)
 795 {
 796         this->output = output;
 797 }
 798
 799 int ADeviceIntBox::handle_event()
 800 {
 801         *output = atol(get_text());
 802         return 1;
 803 }
 804
 805
 806
 807 ADeviceTumbleBox::ADeviceTumbleBox(ADevicePrefs *prefs,
 808         int x, int y, int *output, int min, int max, int text_w)
 809  : BC_TumbleTextBox(prefs->dialog, *output, min, max, x, y, text_w)
 810 {
 811         this->output = output;
 812 }
 813
 814 int ADeviceTumbleBox::handle_event()
 815 {
 816         *output = atol(get_text());
 817         return 1;
 818 }
 819
 820
 821
 822 ALSADevice::ALSADevice(PreferencesDialog *dialog,
 823         int x,
 824         int y,
 825         char *output,
 826         ArrayList<BC_ListBoxItem*> *devices)
 827  : BC_PopupTextBox(dialog, devices, output, x, y, xS(200), yS(200))
 828 {
 829         this->output = output;
 830 }
 831
 832 ALSADevice::~ALSADevice()
 833 {
 834 }
 835
 836 int ALSADevice::handle_event()
 837 {
 838         strcpy(output, get_text());
 839         return 1;
 840 }
 841