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)