cinelerra-5.1/cinelerra/filevorbis.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 #ifdef HAVE_OGG
  22
  23 #include "asset.h"
  24 #include "bcsignals.h"
  25 #include "byteorder.h"
  26 #include "clip.h"
  27 #include "file.h"
  28 #include "filevorbis.h"
  29 #include "guicast.h"
  30 #include "language.h"
  31 #include "mainerror.h"
  32 #include "mwindow.inc"
  33 #include "mainerror.h"
  34
  35 #include <errno.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39
  40 //suppress noref warning
  41 void *vorbis1_ov_callbacks[] = {
  42  &OV_CALLBACKS_DEFAULT, &OV_CALLBACKS_NOCLOSE,
  43  &OV_CALLBACKS_STREAMONLY, &OV_CALLBACKS_STREAMONLY_NOCLOSE,
  44 };
  45
  46 FileVorbis::FileVorbis(Asset *asset, File *file)
  47  : FileBase(asset, file)
  48 {
  49         reset_parameters();
  50         if(asset->format == FILE_UNKNOWN) asset->format = FILE_VORBIS;
  51         asset->byte_order = 0;
  52 }
  53
  54 FileVorbis::~FileVorbis()
  55 {
  56         close_file();
  57 }
  58
  59 void FileVorbis::get_parameters(BC_WindowBase *parent_window,
  60         Asset *asset, BC_WindowBase* &format_window,
  61         int audio_options, int video_options, EDL *edl)
  62 {
  63         if(audio_options)
  64         {
  65                 VorbisConfigAudio *window = new VorbisConfigAudio(parent_window, asset);
  66                 format_window = window;
  67                 window->create_objects();
  68                 window->run_window();
  69                 delete window;
  70         }
  71 }
  72
  73 int FileVorbis::check_sig(Asset *asset)
  74 {
  75         FILE *fd = fopen(asset->path, "rb");
  76         OggVorbis_File vf;
  77
  78 // Test for Quicktime since OGG misinterprets it
  79         if(fd)
  80         {
  81                 fseek(fd, 4, SEEK_SET);
  82                 char data[4];
  83                 (void)fread(data, 4, 1, fd);
  84                 if(data[0] == 'm' &&
  85                         data[1] == 'd' &&
  86                         data[2] == 'a' &&
  87                         data[3] == 't')
  88                 {
  89                         fclose(fd);
  90                         return 0;
  91                 }
  92
  93                 fseek(fd, 0, SEEK_SET);
  94
  95                 if(ov_open(fd, &vf, NULL, 0) < 0)
  96                 {
  97         // OGG failed.  Close file handle manually.
  98                         ov_clear(&vf);
  99                         if(fd) fclose(fd);
 100                         return 0;
 101                 }
 102                 else
 103                 {
 104                         ov_clear(&vf);
 105                         return 1;
 106                 }
 107         }
 108
 109         return 0;
 110 }
 111
 112 int FileVorbis::reset_parameters_derived()
 113 {
 114         fd = 0;
 115         bzero(&vf, sizeof(vf));
 116         return 0;
 117 }
 118
 119
 120 int FileVorbis::open_file(int rd, int wr)
 121 {
 122
 123         int result = 0;
 124
 125 //printf("FileVorbis::open_file 1\n");
 126         if(rd)
 127         {
 128 //printf("FileVorbis::open_file 1\n");
 129                 if(!(fd = fopen(asset->path, "rb")))
 130                 {
 131                         eprintf("Error while opening \"%s\" for reading. \n%m\n", asset->path);
 132                         result = 1;
 133                 }
 134                 else
 135                 {
 136 //printf("FileVorbis::open_file 2 %p %p\n", fd, vf);
 137                         if(ov_open(fd, &vf, NULL, 0) < 0)
 138                         {
 139                                 eprintf(_("FileVorbis::open_file %s: invalid bitstream.\n"), asset->path);
 140                                 result = 1;
 141                         }
 142                         else
 143                         {
 144 //printf("FileVorbis::open_file 1\n");
 145                                 vorbis_info *vi = ov_info(&vf, -1);
 146                                 asset->channels = vi->channels;
 147                                 if(!asset->sample_rate)
 148                                         asset->sample_rate = vi->rate;
 149 //printf("FileVorbis::open_file 1\n");
 150                                 asset->audio_length = ov_pcm_total(&vf,-1);
 151 //printf("FileVorbis::open_file 1\n");
 152                                 asset->audio_data = 1;
 153 // printf("FileVorbis::open_file 1 %d %d %d\n",
 154 // asset->channels,
 155 // asset->sample_rate,
 156 // asset->audio_length);
 157                         }
 158                 }
 159         }
 160
 161         if(wr)
 162         {
 163                 if(!(fd = fopen(asset->path, "wb")))
 164                 {
 165                         eprintf(_("Error while opening \"%s\" for writing. \n%m\n"), asset->path);
 166                         result = 1;
 167                 }
 168                 else
 169                 {
 170                         vorbis_info_init(&vi);
 171                         if(!asset->vorbis_vbr)
 172                                 result = vorbis_encode_init(&vi,
 173                                         asset->channels,
 174                                         asset->sample_rate,
 175                                         asset->vorbis_max_bitrate,
 176                                         asset->vorbis_bitrate,
 177                                         asset->vorbis_min_bitrate);
 178                         else
 179                         {
 180                                 result = vorbis_encode_setup_managed(&vi,
 181                                         asset->channels,
 182                                         asset->sample_rate,
 183                                         asset->vorbis_max_bitrate,
 184                                         asset->vorbis_bitrate,
 185                                         asset->vorbis_min_bitrate);
 186                                 result |= vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_AVG, NULL);
 187                                 result |= vorbis_encode_setup_init(&vi);
 188                         }
 189
 190                         if(!result)
 191                         {
 192                                 vorbis_analysis_init(&vd, &vi);
 193                                 vorbis_block_init(&vd, &vb);
 194                                 vorbis_comment_init(&vc);
 195                                 srand(time(NULL));
 196                                 ogg_stream_init(&os, rand());
 197
 198                                 ogg_packet header;
 199                                 ogg_packet header_comm;
 200                                 ogg_packet header_code;
 201                                 vorbis_analysis_headerout(&vd,
 202                                         &vc,
 203                                         &header,
 204                                         &header_comm,
 205                                         &header_code);
 206                                 ogg_stream_packetin(&os,
 207                                         &header);
 208                                 ogg_stream_packetin(&os,
 209                                         &header_comm);
 210                                 ogg_stream_packetin(&os,
 211                                         &header_code);
 212
 213                                 while(1)
 214                                 {
 215                                         int result = ogg_stream_flush(&os, &og);
 216                                         if(result == 0) break;
 217                                         fwrite(og.header, 1, og.header_len, fd);
 218                                         fwrite(og.body, 1, og.body_len, fd);
 219                                 }
 220                         }
 221                 }
 222         }
 223
 224 //printf("FileVorbis::open_file 2\n");
 225         return result;
 226 }
 227
 228 #define FLUSH_VORBIS \
 229 while(vorbis_analysis_blockout(&vd, &vb) == 1) \
 230 { \
 231         vorbis_analysis(&vb, NULL); \
 232         vorbis_bitrate_addblock(&vb); \
 233         while(vorbis_bitrate_flushpacket(&vd, &op)) \
 234         { \
 235                 ogg_stream_packetin(&os, &op); \
 236                 while(1) \
 237                 { \
 238                         int result = ogg_stream_pageout(&os, &og); \
 239                         if(!result) break; \
 240                         fwrite(og.header, 1, og.header_len, fd); \
 241                         fwrite(og.body, 1, og.body_len, fd); \
 242                         if(ogg_page_eos(&og)) break; \
 243                 } \
 244         } \
 245 }
 246
 247
 248 int FileVorbis::close_file_derived()
 249 {
 250         if(fd)
 251         {
 252                 if(file->wr)
 253                 {
 254                         vorbis_analysis_wrote(&vd, 0);
 255                         FLUSH_VORBIS
 256
 257                         ogg_stream_clear(&os);
 258                         vorbis_block_clear(&vb);
 259                         vorbis_dsp_clear(&vd);
 260                         vorbis_comment_clear(&vc);
 261                         vorbis_info_clear(&vi);
 262                         fclose(fd);
 263                 }
 264
 265                 if(file->rd)
 266                 {
 267 // This also closes the file handle.
 268                         ov_clear(&vf);
 269                 }
 270                 fd = 0;
 271         }
 272
 273         return 0;
 274 }
 275
 276
 277 int FileVorbis::write_samples(double **buffer, int64_t len)
 278 {
 279         if(!fd) return 0;
 280
 281         float **vorbis_buffer = vorbis_analysis_buffer(&vd, len);
 282         for(int i = 0; i < asset->channels; i++)
 283         {
 284                 float *output = vorbis_buffer[i];
 285                 double *input = buffer[i];
 286                 for(int j = 0; j < len; j++)
 287                 {
 288                         output[j] = input[j];
 289                 }
 290         }
 291
 292         vorbis_analysis_wrote(&vd, len);
 293         FLUSH_VORBIS
 294
 295         return 0;
 296 }
 297
 298 int FileVorbis::read_samples(double *buffer, int64_t len)
 299 {
 300         if(!fd) return 0;
 301
 302 // printf("FileVorbis::read_samples 1 %d %d %d %d\n",
 303 // history_start,
 304 // history_size,
 305 // file->current_sample,
 306 // len);
 307         float **vorbis_output;
 308         int bitstream;
 309         int accumulation = 0;
 310
 311
 312         update_pcm_history(len);
 313
 314
 315 // Fill history buffer
 316         if(decode_start != decode_end)
 317         {
 318                 ov_pcm_seek(&vf, decode_start);
 319                 decode_end = decode_start;
 320         }
 321
 322         while(accumulation < decode_len)
 323         {
 324                 int result = ov_read_float(&vf,
 325                         &vorbis_output,
 326                         decode_len - accumulation,
 327                         &bitstream);
 328 //printf("FileVorbis::read_samples 1 %d %d %d\n", result, len, accumulation);
 329                 if(!result) break;
 330
 331                 append_history(vorbis_output, result);
 332                 accumulation += result;
 333         }
 334
 335
 336         read_history(buffer,
 337                 file->current_sample,
 338                 file->current_channel,
 339                 len);
 340
 341 // printf("FileVorbis::read_samples 2 %d %d %d %d\n",
 342 // history_start,
 343 // history_size,
 344 // file->current_sample,
 345 // len);
 346
 347         return 0;
 348 }
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359 VorbisConfigAudio::VorbisConfigAudio(BC_WindowBase *parent_window,
 360         Asset *asset)
 361  : BC_Window(_(PROGRAM_NAME ": Audio Compression"),
 362         parent_window->get_abs_cursor_x(1),
 363         parent_window->get_abs_cursor_y(1),
 364         350,
 365         170,
 366         -1,
 367         -1,
 368         0,
 369         0,
 370         1)
 371 {
 372         this->parent_window = parent_window;
 373         this->asset = asset;
 374 // *** CONTEXT_HELP ***
 375         context_help_set_keyword("Single File Rendering");
 376 }
 377
 378 VorbisConfigAudio::~VorbisConfigAudio()
 379 {
 380 }
 381
 382 void VorbisConfigAudio::create_objects()
 383 {
 384         int x = 10, y = 10;
 385         int x1 = 150;
 386         char string[BCTEXTLEN];
 387
 388         lock_window("VorbisConfigAudio::create_objects");
 389         add_tool(fixed_bitrate = new VorbisFixedBitrate(x, y, this));
 390         add_tool(variable_bitrate = new VorbisVariableBitrate(x1, y, this));
 391
 392         y += 30;
 393         sprintf(string, "%d", asset->vorbis_min_bitrate);
 394         add_tool(new BC_Title(x, y, _("Min bitrate:")));
 395         add_tool(new VorbisMinBitrate(x1, y, this, string));
 396
 397         y += 30;
 398         add_tool(new BC_Title(x, y, _("Avg bitrate:")));
 399         sprintf(string, "%d", asset->vorbis_bitrate);
 400         add_tool(new VorbisAvgBitrate(x1, y, this, string));
 401
 402         y += 30;
 403         add_tool(new BC_Title(x, y, _("Max bitrate:")));
 404         sprintf(string, "%d", asset->vorbis_max_bitrate);
 405         add_tool(new VorbisMaxBitrate(x1, y, this, string));
 406
 407
 408         add_subwindow(new BC_OKButton(this));
 409         show_window();
 410         flush();
 411         unlock_window();
 412 }
 413
 414 int VorbisConfigAudio::close_event()
 415 {
 416         set_done(0);
 417         return 1;
 418 }
 419
 420
 421
 422
 423
 424 VorbisFixedBitrate::VorbisFixedBitrate(int x, int y, VorbisConfigAudio *gui)
 425  : BC_Radial(x, y, !gui->asset->vorbis_vbr, _("Fixed bitrate"))
 426 {
 427         this->gui = gui;
 428 }
 429 int VorbisFixedBitrate::handle_event()
 430 {
 431         gui->asset->vorbis_vbr = 0;
 432         gui->variable_bitrate->update(0);
 433         return 1;
 434 }
 435
 436 VorbisVariableBitrate::VorbisVariableBitrate(int x, int y, VorbisConfigAudio *gui)
 437  : BC_Radial(x, y, gui->asset->vorbis_vbr, _("Variable bitrate"))
 438 {
 439         this->gui = gui;
 440 }
 441 int VorbisVariableBitrate::handle_event()
 442 {
 443         gui->asset->vorbis_vbr = 1;
 444         gui->fixed_bitrate->update(0);
 445         return 1;
 446 }
 447
 448
 449 VorbisMinBitrate::VorbisMinBitrate(int x,
 450         int y,
 451         VorbisConfigAudio *gui,
 452         char *text)
 453  : BC_TextBox(x, y, 180, 1, text)
 454 {
 455         this->gui = gui;
 456 }
 457 int VorbisMinBitrate::handle_event()
 458 {
 459         gui->asset->vorbis_min_bitrate = atol(get_text());
 460         return 1;
 461 }
 462
 463
 464
 465 VorbisMaxBitrate::VorbisMaxBitrate(int x,
 466         int y,
 467         VorbisConfigAudio *gui,
 468         char *text)
 469  : BC_TextBox(x, y, 180, 1, text)
 470 {
 471         this->gui = gui;
 472 }
 473 int VorbisMaxBitrate::handle_event()
 474 {
 475         gui->asset->vorbis_max_bitrate = atol(get_text());
 476         return 1;
 477 }
 478
 479
 480
 481 VorbisAvgBitrate::VorbisAvgBitrate(int x, int y, VorbisConfigAudio *gui, char *text)
 482  : BC_TextBox(x, y, 180, 1, text)
 483 {
 484         this->gui = gui;
 485 }
 486 int VorbisAvgBitrate::handle_event()
 487 {
 488         gui->asset->vorbis_bitrate = atol(get_text());
 489         return 1;
 490 }
 491
 492 #endif