21 #include "JackAC3Encoder.h"    22 #include "JackError.h"    27 #define max(x,y) (((x)>(y)) ? (x) : (y))    28 #define min(x,y) (((x)<(y)) ? (x) : (y))    35 JackAC3Encoder::JackAC3Encoder(
const JackAC3EncoderParams& params)
    37     aften_set_defaults(&fAftenContext);
    39     fAftenContext.channels = params.channels;
    40         fAftenContext.samplerate = params.sample_rate;
    41         fAftenContext.params.bitrate = params.bitrate;
    43         int acmod = A52_ACMOD_MONO;
    46         switch (params.channels) {
    48         case 1: acmod = A52_ACMOD_MONO; 
break;
    49         case 2: acmod = A52_ACMOD_STEREO; 
break;
    50         case 3: acmod = A52_ACMOD_3_0; 
break;
    51         case 4: acmod = A52_ACMOD_2_2; 
break;
    52         case 5: acmod = A52_ACMOD_3_2; 
break;
    60                 fAftenContext.channels += 1;
    63         fAftenContext.acmod = acmod;
    64         fAftenContext.lfe = lfe;
    65         fAftenContext.sample_format = A52_SAMPLE_FMT_FLT;
    66         fAftenContext.verbose = 1;
    68         fAftenContext.system.n_threads = 1;
    71         fSampleBuffer = 
new float[MAX_AC3_CHANNELS * A52_SAMPLES_PER_FRAME];
    74         fAC3Buffer = 
new unsigned char[A52_MAX_CODED_FRAME_SIZE];
    75         memset(fAC3Buffer, 0, A52_MAX_CODED_FRAME_SIZE);
    77     fZeroBuffer = 
new unsigned char[SPDIF_FRAME_SIZE];
    78         memset(fZeroBuffer, 0, SPDIF_FRAME_SIZE);
    89 bool JackAC3Encoder::Init(jack_nframes_t sample_rate)
    91     fSampleRate = sample_rate;
    92         fByteRate = fSampleRate * 
sizeof(short) * 2;
    93     return (aften_encode_init(&fAftenContext) == 0);
    96 JackAC3Encoder::~JackAC3Encoder()
    98     aften_encode_close(&fAftenContext);
   100     delete [] fSampleBuffer;
   101     delete [] fAC3Buffer;
   102     delete [] fZeroBuffer;
   109 void JackAC3Encoder::Process(
float** inputs_buffer, 
float** outputs_buffer, 
int nframes)
   112         jack_nframes_t frames_left = A52_SAMPLES_PER_FRAME - fFramePos;
   113         jack_nframes_t offset = 0;
   115         while (offset < nframes)
   117                 if ((nframes - offset) >= frames_left) {
   120                         jack_nframes_t pos = fFramePos * fAftenContext.channels;
   121                         for (jack_nframes_t spos = offset; spos < offset + frames_left; ++spos) {
   122                                 for (
size_t i = 0; i < fAftenContext.channels; ++i) {
   123                                         fSampleBuffer[pos + i] = inputs_buffer[i][spos];
   125                                 pos += fAftenContext.channels;
   129             int res = aften_encode_frame(&fAftenContext, fAC3Buffer + SPDIF_HEADER_SIZE, fSampleBuffer);
   137                         FillSpdifHeader(fAC3Buffer, fOutSizeByte + SPDIF_HEADER_SIZE);
   140                         float calc_ac3byterate = (fOutSizeByte * fSampleRate / (float) A52_SAMPLES_PER_FRAME);  
   141                         jack_nframes_t silencebytes = (jack_nframes_t) (fOutSizeByte * (fByteRate / calc_ac3byterate)) - fOutSizeByte - SPDIF_HEADER_SIZE;
   148                         offset += frames_left;
   149                         frames_left = A52_SAMPLES_PER_FRAME;
   155                         jack_nframes_t pos = fFramePos * fAftenContext.channels;
   156                         for (jack_nframes_t spos = offset; spos < nframes; ++spos) {
   157                                 for (
size_t i = 0; i < fAftenContext.channels; ++i) {
   158                                         fSampleBuffer[pos + i] = inputs_buffer[i][spos];
   160                                 pos += fAftenContext.channels;
   163                         fFramePos += (nframes - offset);
   164                         offset += (nframes-offset);
   168         Output2Driver(outputs_buffer, nframes);
   171 void JackAC3Encoder::FillSpdifHeader(
unsigned char* buf, 
int outsize)
   174         int ac3outsize = outsize - SPDIF_HEADER_SIZE;
   176         buf[0] = 0x72; buf[1] = 0xf8;   
   177         buf[2] = 0x1f; buf[3] = 0x4e;   
   179         buf[5] = buf[13] & 7;           
   180         buf[6] = (ac3outsize << 3) & 0xff;
   181         buf[7] = (ac3outsize >> 5) & 0xff;
   184         swab(buf+SPDIF_HEADER_SIZE, buf + SPDIF_HEADER_SIZE, ac3outsize);
   188 int JackAC3Encoder::Output2Driver(
float** outputs, jack_nframes_t nframes)
   191         jack_nframes_t nframes_left = nframes;
   196                 memset(outputs[0], 0, nframes * 
sizeof(jack_default_audio_sample_t));
   197                 memset(outputs[1], 0, nframes * 
sizeof(jack_default_audio_sample_t));   
   205                 while (nframes_left > 0 && rb_data[0].len > 4) {
   207                         jack_nframes_t towrite_frames = (rb_data[0].len) / (
sizeof(
short) * 2);
   208                         towrite_frames = min(towrite_frames, nframes_left);
   212                         sample_move_dS_s16(outputs[0] + (nframes - nframes_left), (
char *) rb_data[0].buf, towrite_frames, 
sizeof(
short) * 2);
   213                         sample_move_dS_s16(outputs[1] + (nframes - nframes_left), (
char *) rb_data[0].buf + 
sizeof(
short), towrite_frames, 
sizeof(
short) * 2);
   215                         sample_move_dS_s16_24ph(outputs[0] + (nframes - nframes_left), (
char *) rb_data[0].buf, towrite_frames, 
sizeof(
short) * 2);
   216                         sample_move_dS_s16_24ph(outputs[1] + (nframes - nframes_left), (
char *) rb_data[0].buf + 
sizeof(
short), towrite_frames, 
sizeof(
short) * 2);
   218                         wrotebytes = towrite_frames * 
sizeof(short) * 2;
   219                         nframes_left -= towrite_frames;
   225                 if (nframes_left > 0) {
   227                         memset(outputs[0] + (nframes - nframes_left), 0, (nframes_left) * 
sizeof(jack_default_audio_sample_t));
   228                         memset(outputs[1] + (nframes - nframes_left), 0, (nframes_left) * 
sizeof(jack_default_audio_sample_t));         
   235 void JackAC3Encoder::sample_move_dS_s16(jack_default_audio_sample_t* dst, 
char *src, jack_nframes_t nsamples, 
unsigned long src_skip) 
   239                 *dst = (*((
short *) src)) / SAMPLE_MAX_16BIT;
   245 void JackAC3Encoder::sample_move_dS_s16_24ph(jack_default_audio_sample_t* dst, 
char *src, jack_nframes_t nsamples, 
unsigned long src_skip) 
   249                 *dst = (((int)(*((
short *) src))) << 8) / SAMPLE_MAX_24BIT;
   255 void JackAC3Encoder::GetChannelName(
const char* name, 
const char* alias, 
char* portname, 
int channel)
   265      const char* AC3_name = 
"";
   270             AC3_name = 
"AC3_1_Left";
   274             if (fAftenContext.channels == 2 || fAftenContext.channels == 4) {
   275                 AC3_name = 
"AC3_2_Right";
   277                 AC3_name = 
"AC3_2_Center";
   282             if (fAftenContext.channels == 4) {
   283                 AC3_name = 
"AC3_3_LeftSurround";
   285                 AC3_name = 
"AC3_3_Right";
   290             if (fAftenContext.channels == 4) {
   291                 AC3_name = 
"AC3_4_RightSurround";
   293                 AC3_name = 
"AC3_4_LeftSurround";
   298             if (fAftenContext.channels > 4) {
   299                AC3_name = 
"AC3_5_RightSurround";
   308      if (fAftenContext.lfe && (channel == fAftenContext.channels - 1)) {
   309         sprintf(portname, 
"%s:%s:AC3_%d_LFE", name, alias, fAftenContext.channels);
   311         sprintf(portname, 
"%s:%s:%s", name, alias, AC3_name);
 size_t jack_ringbuffer_read_space(const jack_ringbuffer_t *rb)
jack_ringbuffer_t * jack_ringbuffer_create(size_t sz)
SERVER_EXPORT void jack_error(const char *fmt,...)
void jack_ringbuffer_free(jack_ringbuffer_t *rb)
void jack_ringbuffer_get_read_vector(const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec)
size_t jack_ringbuffer_write(jack_ringbuffer_t *rb, const char *src, size_t cnt)
void jack_ringbuffer_read_advance(jack_ringbuffer_t *rb, size_t cnt)