cinelerra-5.0/cinelerra/fileac3.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 <stdio.h>
  23 #include <stdint.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <ctype.h>
  29 #include <limits.h>
  30 // work around (centos) for __STDC_CONSTANT_MACROS
  31 #include <lzma.h>
  32 #ifndef INT64_MAX
  33 #   define INT64_MAX 9223372036854775807LL
  34 #endif
  35
  36 extern "C"
  37 {
  38 #include "libavcodec/avcodec.h"
  39 }
  40
  41 #include "asset.h"
  42 #include "clip.h"
  43 #include "fileac3.h"
  44 #include "file.h"
  45 #include "filempeg.h"
  46 #include "language.h"
  47 #include "mainerror.h"
  48
  49
  50
  51 #include <string.h>
  52
  53 FileAC3::FileAC3(Asset *asset, File *file)
  54  : FileBase(asset, file)
  55 {
  56         reset_parameters();
  57         mpg_file = 0;
  58 }
  59
  60 FileAC3::~FileAC3()
  61 {
  62         if( mpg_file ) delete mpg_file;
  63         close_file();
  64 }
  65
  66 int FileAC3::reset_parameters_derived()
  67 {
  68         codec = 0;
  69         codec_context = 0;
  70         resample_context = 0;
  71         fd = 0;
  72         temp_raw = 0;
  73         temp_raw_size = 0;
  74         temp_raw_allocated = 0;
  75         temp_compressed = 0;
  76         compressed_allocated = 0;
  77         return 0;
  78 }
  79
  80 void FileAC3::get_parameters(BC_WindowBase *parent_window,
  81                 Asset *asset,
  82                 BC_WindowBase* &format_window,
  83                 int audio_options,
  84                 int video_options)
  85 {
  86         if(audio_options)
  87         {
  88
  89                 AC3ConfigAudio *window = new AC3ConfigAudio(parent_window, asset);
  90                 format_window = window;
  91                 window->create_objects();
  92                 window->run_window();
  93                 delete window;
  94         }
  95 }
  96
  97 int FileAC3::check_sig()
  98 {
  99 // Libmpeg3 does this in FileMPEG.
 100         return 0;
 101 }
 102
 103 int64_t FileAC3::get_channel_layout(int channels)
 104 {
 105         switch( channels ) {
 106         case 1: return AV_CH_LAYOUT_MONO;
 107         case 2: return AV_CH_LAYOUT_STEREO;
 108         case 3: return AV_CH_LAYOUT_SURROUND;
 109         case 4: return AV_CH_LAYOUT_QUAD;
 110         case 5: return AV_CH_LAYOUT_5POINT0;
 111         case 6: return AV_CH_LAYOUT_5POINT1;
 112         case 8: return AV_CH_LAYOUT_7POINT1;
 113         }
 114         return 0;
 115 }
 116
 117 int FileAC3::open_file(int rd, int wr)
 118 {
 119         int result = 0;
 120
 121         if(rd)
 122         {
 123                 if( !mpg_file )
 124                         mpg_file = new FileMPEG(file->asset, file);
 125                 result = mpg_file->open_file(1, 0);
 126         }
 127
 128         if( !result && wr )
 129         {
 130                 //avcodec_init();
 131                 avcodec_register_all();
 132                 codec = avcodec_find_encoder(AV_CODEC_ID_AC3);
 133                 if(!codec)
 134                 {
 135                         eprintf("FileAC3::open_file codec not found.\n");
 136                         result = 1;
 137                 }
 138                 if( !result && !(fd = fopen(asset->path, "w")))
 139                 {
 140                         perror("FileAC3::open_file");
 141                         result = 1;
 142                 }
 143                 if( !result ) {
 144                         int channels = asset->channels;
 145                         int sample_rate = asset->sample_rate;
 146                         int64_t layout = get_channel_layout(channels);
 147                         int bitrate = asset->ac3_bitrate * 1000;
 148                         codec_context = avcodec_alloc_context3(codec);
 149                         codec_context->bit_rate = bitrate;
 150                         codec_context->sample_rate = sample_rate;
 151                         codec_context->channels = channels;
 152                         codec_context->channel_layout = layout;
 153                         codec_context->sample_fmt = codec->sample_fmts[0];
 154                         resample_context = swr_alloc_set_opts(NULL,
 155                                         layout, codec_context->sample_fmt, sample_rate,
 156                                         layout, AV_SAMPLE_FMT_S16, sample_rate,
 157                                         0, NULL);
 158                         swr_init(resample_context);
 159                         if(avcodec_open2(codec_context, codec, 0))
 160                         {
 161                                 eprintf("FileAC3::open_file failed to open codec.\n");
 162                                 result = 1;
 163                         }
 164                 }
 165         }
 166
 167         return 0;
 168 }
 169
 170 int FileAC3::close_file()
 171 {
 172         if( mpg_file )
 173         {
 174                 delete mpg_file;
 175                 mpg_file = 0;
 176         }
 177         if(codec_context)
 178         {
 179                 avcodec_close(codec_context);
 180                 free(codec_context);
 181                 codec_context = 0;
 182                 codec = 0;
 183         }
 184         if( resample_context )
 185                 swr_free(&resample_context);
 186         if(fd)
 187         {
 188                 fclose(fd);
 189                 fd = 0;
 190         }
 191         if(temp_raw)
 192         {
 193                 delete [] temp_raw;
 194                 temp_raw = 0;
 195         }
 196         if(temp_compressed)
 197         {
 198                 delete [] temp_compressed;
 199                 temp_compressed = 0;
 200         }
 201         reset_parameters();
 202         FileBase::close_file();
 203         return 0;
 204 }
 205
 206 int FileAC3::read_samples(double *buffer, int64_t len)
 207 {
 208         return !mpg_file ? 0 : mpg_file->read_samples(buffer, len);
 209 }
 210
 211 int FileAC3::get_index(char *index_path)
 212 {
 213         return !mpg_file ? 1 : mpg_file->get_index(index_path);
 214 }
 215
 216 // Channel conversion matrices because ffmpeg encodes a
 217 // different channel order than liba52 decodes.
 218 // Each row is an output channel.
 219 // Each column is an input channel.
 220 // static int channels5[] =
 221 // {
 222 //      { }
 223 // };
 224 //
 225 // static int channels6[] =
 226 // {
 227 //      { }
 228 // };
 229
 230
 231 int FileAC3::write_samples(double **buffer, int64_t len)
 232 {
 233 // Convert buffer to encoder format
 234         if(temp_raw_size + len > temp_raw_allocated)
 235         {
 236                 int new_allocated = temp_raw_size + len;
 237                 int16_t *new_raw = new int16_t[new_allocated * asset->channels];
 238                 if(temp_raw)
 239                 {
 240                         memcpy(new_raw,
 241                                 temp_raw,
 242                                 sizeof(int16_t) * temp_raw_size * asset->channels);
 243                         delete [] temp_raw;
 244                 }
 245                 temp_raw = new_raw;
 246                 temp_raw_allocated = new_allocated;
 247         }
 248
 249 // Allocate compressed data buffer
 250         if(temp_raw_allocated * asset->channels * 2 > compressed_allocated)
 251         {
 252                 compressed_allocated = temp_raw_allocated * asset->channels * 2;
 253                 delete [] temp_compressed;
 254                 temp_compressed = new unsigned char[compressed_allocated];
 255         }
 256
 257 // Append buffer to temp raw
 258         int16_t *out_ptr = temp_raw + temp_raw_size * asset->channels;
 259         for(int i = 0; i < len; i++)
 260         {
 261                 for(int j = 0; j < asset->channels; j++)
 262                 {
 263                         int sample = (int)(buffer[j][i] * 32767);
 264                         CLAMP(sample, -32768, 32767);
 265                         *out_ptr++ = sample;
 266                 }
 267         }
 268         temp_raw_size += len;
 269
 270         AVCodecContext *&avctx = codec_context;
 271         int frame_size = avctx->frame_size;
 272         int output_size = 0, cur_sample = 0, ret = 0;
 273         for(cur_sample = 0; !ret &&
 274                 cur_sample + frame_size <= temp_raw_size;
 275                 cur_sample += frame_size)
 276         {
 277                 AVPacket avpkt;
 278                 av_init_packet(&avpkt);
 279                 avpkt.data = temp_compressed + output_size;
 280                 avpkt.size = compressed_allocated - output_size;
 281                 AVFrame *frame = av_frame_alloc();
 282                 frame->nb_samples = frame_size;
 283                 frame->format = avctx->sample_fmt;
 284                 frame->channel_layout = avctx->channel_layout;
 285                 frame->sample_rate = avctx->sample_rate;
 286                 ret = av_frame_get_buffer(frame, 0);
 287                 if( ret >= 0 ) {
 288                         const uint8_t *samples = (uint8_t *)temp_raw +
 289                                 cur_sample * sizeof(int16_t) * asset->channels;
 290                         ret = swr_convert(resample_context,
 291                                 (uint8_t **)frame->extended_data, frame_size,
 292                                 &samples, frame_size);
 293                 }
 294                 if( ret >= 0 ) {
 295                         frame->pts = avctx->sample_rate && avctx->time_base.num ?
 296                                 file->get_audio_position() : AV_NOPTS_VALUE ;
 297                         int got_packet = 0;
 298                         ret = avcodec_encode_audio2(avctx, &avpkt, frame, &got_packet);
 299                         if( ret < 0 ) {
 300                                 char errmsg[BCSTRLEN];
 301                                 av_strerror(ret, errmsg, sizeof(errmsg));
 302                                 fprintf(stderr, "avcodec_encode_audio2 failed. \n%s\n", errmsg);
 303                         }
 304                 }
 305                 av_packet_free_side_data(&avpkt);
 306                 output_size += avpkt.size;
 307                 if(frame->extended_data != frame->data)
 308                         av_freep(&frame->extended_data);
 309                 av_frame_free(&frame);
 310         }
 311
 312 // Shift buffer back
 313         memcpy(temp_raw,
 314                 temp_raw + cur_sample * asset->channels,
 315                 (temp_raw_size - cur_sample) * sizeof(int16_t) * asset->channels);
 316         temp_raw_size -= cur_sample;
 317
 318         int bytes_written = fwrite(temp_compressed, 1, output_size, fd);
 319         if(bytes_written < output_size)
 320         {
 321                 eprintf("Error while writing samples. \n%m\n");
 322                 return 1;
 323         }
 324         return 0;
 325 }
 326
 327
 328
 329
 330
 331
 332
 333 AC3ConfigAudio::AC3ConfigAudio(BC_WindowBase *parent_window,
 334         Asset *asset)
 335  : BC_Window(PROGRAM_NAME ": Audio Compression",
 336         parent_window->get_abs_cursor_x(1),
 337         parent_window->get_abs_cursor_y(1),
 338         500,
 339         BC_OKButton::calculate_h() + 100,
 340         500,
 341         BC_OKButton::calculate_h() + 100,
 342         0,
 343         0,
 344         1)
 345 {
 346         this->parent_window = parent_window;
 347         this->asset = asset;
 348 }
 349
 350 void AC3ConfigAudio::create_objects()
 351 {
 352         int x = 10, y = 10;
 353         int x1 = 150;
 354         lock_window("AC3ConfigAudio::create_objects");
 355         add_tool(new BC_Title(x, y, "Bitrate (kbps):"));
 356         AC3ConfigAudioBitrate *bitrate;
 357         add_tool(bitrate =
 358                 new AC3ConfigAudioBitrate(this,
 359                         x1,
 360                         y));
 361         bitrate->create_objects();
 362
 363         add_subwindow(new BC_OKButton(this));
 364         show_window(1);
 365         unlock_window();
 366 }
 367
 368 int AC3ConfigAudio::close_event()
 369 {
 370         set_done(0);
 371         return 1;
 372 }
 373
 374
 375
 376
 377
 378
 379 AC3ConfigAudioBitrate::AC3ConfigAudioBitrate(AC3ConfigAudio *gui,
 380         int x,
 381         int y)
 382  : BC_PopupMenu(x,
 383         y,
 384         150,
 385         AC3ConfigAudioBitrate::bitrate_to_string(gui->string, gui->asset->ac3_bitrate))
 386 {
 387         this->gui = gui;
 388 }
 389
 390 char* AC3ConfigAudioBitrate::bitrate_to_string(char *string, int bitrate)
 391 {
 392         sprintf(string, "%d", bitrate);
 393         return string;
 394 }
 395
 396 void AC3ConfigAudioBitrate::create_objects()
 397 {
 398         add_item(new BC_MenuItem("32"));
 399         add_item(new BC_MenuItem("40"));
 400         add_item(new BC_MenuItem("48"));
 401         add_item(new BC_MenuItem("56"));
 402         add_item(new BC_MenuItem("64"));
 403         add_item(new BC_MenuItem("80"));
 404         add_item(new BC_MenuItem("96"));
 405         add_item(new BC_MenuItem("112"));
 406         add_item(new BC_MenuItem("128"));
 407         add_item(new BC_MenuItem("160"));
 408         add_item(new BC_MenuItem("192"));
 409         add_item(new BC_MenuItem("224"));
 410         add_item(new BC_MenuItem("256"));
 411         add_item(new BC_MenuItem("320"));
 412         add_item(new BC_MenuItem("384"));
 413         add_item(new BC_MenuItem("448"));
 414         add_item(new BC_MenuItem("512"));
 415         add_item(new BC_MenuItem("576"));
 416         add_item(new BC_MenuItem("640"));
 417 }
 418
 419 int AC3ConfigAudioBitrate::handle_event()
 420 {
 421         gui->asset->ac3_bitrate = atol(get_text());
 422         return 1;
 423 }
 424
 425
 426