MythTV: liba52.c Source File

00001 /*
00002  * A52 decoder using liba52
00003  * Copyright (c) 2001 Fabrice Bellard.
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00027 #include "avcodec.h"
00028 #include <a52dec/a52.h>
00029 
00030 #ifdef CONFIG_LIBA52BIN
00031 #include <dlfcn.h>
00032 static const char* liba52name = "liba52.so.0";
00033 #endif
00034 
00039 typedef struct AC3DecodeState {
00040     uint8_t inbuf[4096]; /* input buffer */
00041     uint8_t *inbuf_ptr;
00042     int frame_size;
00043     int flags;
00044     int channels;
00045     a52_state_t* state;
00046     sample_t* samples;
00047 
00048     /*
00049      * virtual method table
00050      *
00051      * using this function table so the liba52 doesn't
00052      * have to be really linked together with ffmpeg
00053      * and might be linked in runtime - this allows binary
00054      * distribution of ffmpeg library which doens't depend
00055      * on liba52 library - but if user has it installed
00056      * it will be used - user might install such library
00057      * separately
00058      */
00059     void* handle;
00060     a52_state_t* (*a52_init)(uint32_t mm_accel);
00061     sample_t* (*a52_samples)(a52_state_t * state);
00062     int (*a52_syncinfo)(uint8_t * buf, int * flags,
00063                           int * sample_rate, int * bit_rate);
00064     int (*a52_frame)(a52_state_t * state, uint8_t * buf, int * flags,
00065                        sample_t * level, sample_t bias);
00066     void (*a52_dynrng)(a52_state_t * state,
00067                          sample_t (* call) (sample_t, void *), void * data);
00068     int (*a52_block)(a52_state_t * state);
00069     void (*a52_free)(a52_state_t * state);
00070 
00071 } AC3DecodeState;
00072 
00073 #ifdef CONFIG_LIBA52BIN
00074 static void* dlsymm(void* handle, const char* symbol)
00075 {
00076     void* f = dlsym(handle, symbol);
00077     if (!f)
00078         av_log( NULL, AV_LOG_ERROR, "A52 Decoder - function '%s' can't be resolved\n", symbol);
00079     return f;
00080 }
00081 #endif
00082 
00083 static int a52_decode_init(AVCodecContext *avctx)
00084 {
00085     AC3DecodeState *s = avctx->priv_data;
00086 
00087 #ifdef CONFIG_LIBA52BIN
00088     s->handle = dlopen(liba52name, RTLD_LAZY);
00089     if (!s->handle)
00090     {
00091         av_log( avctx, AV_LOG_ERROR, "A52 library %s could not be opened! \n%s\n", liba52name, dlerror());
00092         return -1;
00093     }
00094     s->a52_init = (a52_state_t* (*)(uint32_t)) dlsymm(s->handle, "a52_init");
00095     s->a52_samples = (sample_t* (*)(a52_state_t*)) dlsymm(s->handle, "a52_samples");
00096     s->a52_syncinfo = (int (*)(uint8_t*, int*, int*, int*)) dlsymm(s->handle, "a52_syncinfo");
00097     s->a52_frame = (int (*)(a52_state_t*, uint8_t*, int*, sample_t*, sample_t)) dlsymm(s->handle, "a52_frame");
00098     s->a52_block = (int (*)(a52_state_t*)) dlsymm(s->handle, "a52_block");
00099     s->a52_free = (void (*)(a52_state_t*)) dlsymm(s->handle, "a52_free");
00100     if (!s->a52_init || !s->a52_samples || !s->a52_syncinfo
00101         || !s->a52_frame || !s->a52_block || !s->a52_free)
00102     {
00103         dlclose(s->handle);
00104         return -1;
00105     }
00106 #else
00107     s->handle = 0;
00108     s->a52_init = a52_init;
00109     s->a52_samples = a52_samples;
00110     s->a52_syncinfo = a52_syncinfo;
00111     s->a52_frame = a52_frame;
00112     s->a52_block = a52_block;
00113     s->a52_free = a52_free;
00114 #endif
00115     s->state = s->a52_init(0); /* later use CPU flags */
00116     s->samples = s->a52_samples(s->state);
00117     s->inbuf_ptr = s->inbuf;
00118     s->frame_size = 0;
00119 
00120     return 0;
00121 }
00122 
00123 /**** the following function comes from a52dec */
00124 static inline void float_to_int (float * _f, int16_t * s16, int nchannels)
00125 {
00126     int i, j, c;
00127     int32_t * f = (int32_t *) _f;       // XXX assumes IEEE float format
00128 
00129     j = 0;
00130     nchannels *= 256;
00131     for (i = 0; i < 256; i++) {
00132         for (c = 0; c < nchannels; c += 256)
00133             s16[j++] = av_clip_int16(f[i + c] - 0x43c00000);
00134     }
00135 }
00136 
00137 static inline int16_t convert(int32_t i)
00138 {
00139     return av_clip_int16(i - 0x43c00000);
00140 }
00141 
00142 void float2s16_2 (float * _f, int16_t * s16)
00143 {
00144     int i;
00145     int32_t * f = (int32_t *) _f;
00146 
00147     for (i = 0; i < 256; i++) {
00148         s16[2*i] = convert (f[i]);
00149         s16[2*i+1] = convert (f[i+256]);
00150     }
00151 }
00152 
00153 void float2s16_4 (float * _f, int16_t * s16)
00154 {
00155     int i;
00156     int32_t * f = (int32_t *) _f;
00157 
00158     for (i = 0; i < 256; i++) {
00159         s16[4*i] = convert (f[i]);
00160         s16[4*i+1] = convert (f[i+256]);
00161         s16[4*i+2] = convert (f[i+512]);
00162         s16[4*i+3] = convert (f[i+768]);
00163     }
00164 }
00165 
00166 void float2s16_5 (float * _f, int16_t * s16)
00167 {
00168     int i;
00169     int32_t * f = (int32_t *) _f;
00170 
00171     for (i = 0; i < 256; i++) {
00172         s16[5*i] = convert (f[i]);
00173         s16[5*i+1] = convert (f[i+256]);
00174         s16[5*i+2] = convert (f[i+512]);
00175         s16[5*i+3] = convert (f[i+768]);
00176         s16[5*i+4] = convert (f[i+1024]);
00177     }
00178 }
00179 
00180 #define LIKEAC3DEC 1
00181 int channels_multi (int flags)
00182 {
00183     if (flags & A52_LFE)
00184         return 6;
00185     else if (flags & 1) /* center channel */
00186         return 5;
00187     else if ((flags & A52_CHANNEL_MASK) == A52_2F2R)
00188         return 4;
00189     else
00190         return 2;
00191 }
00192 
00193 void float2s16_multi (float * _f, int16_t * s16, int flags)
00194 {
00195     int i;
00196     int32_t * f = (int32_t *) _f;
00197 
00198     switch (flags) {
00199     case A52_MONO:
00200         for (i = 0; i < 256; i++) {
00201             s16[5*i] = s16[5*i+1] = s16[5*i+2] = s16[5*i+3] = 0;
00202             s16[5*i+4] = convert (f[i]);
00203         }
00204         break;
00205     case A52_CHANNEL:
00206     case A52_STEREO:
00207     case A52_DOLBY:
00208         float2s16_2 (_f, s16);
00209         break;
00210     case A52_3F:
00211         for (i = 0; i < 256; i++) {
00212             s16[5*i] = convert (f[i]);
00213             s16[5*i+1] = convert (f[i+512]);
00214             s16[5*i+2] = s16[5*i+3] = 0;
00215             s16[5*i+4] = convert (f[i+256]);
00216         }
00217         break;
00218     case A52_2F2R:
00219         float2s16_4 (_f, s16);
00220         break;
00221     case A52_3F2R:
00222         float2s16_5 (_f, s16);
00223         break;
00224     case A52_MONO | A52_LFE:
00225         for (i = 0; i < 256; i++) {
00226 #if LIKEAC3DEC
00227             s16[6*i] = s16[6*i+2] = s16[6*i+3] = s16[6*i+4] = 0;
00228             s16[6*i+1] = convert (f[i+256]);
00229             s16[6*i+5] = convert (f[i]);
00230 #else
00231             s16[6*i] = s16[6*i+1] = s16[6*i+2] = s16[6*i+3] = 0;
00232             s16[6*i+4] = convert (f[i+256]);
00233             s16[6*i+5] = convert (f[i]);
00234 #endif
00235         }
00236         break;
00237     case A52_CHANNEL | A52_LFE:
00238     case A52_STEREO | A52_LFE:
00239     case A52_DOLBY | A52_LFE:
00240         for (i = 0; i < 256; i++) {
00241 #if LIKEAC3DEC
00242             s16[6*i] = convert (f[i+256]);
00243             s16[6*i+2] = convert (f[i+512]);
00244             s16[6*i+1] = s16[6*i+3] = s16[6*i+4] = 0;
00245             s16[6*i+5] = convert (f[i]);
00246 #else
00247             s16[6*i] = convert (f[i+256]);
00248             s16[6*i+1] = convert (f[i+512]);
00249             s16[6*i+2] = s16[6*i+3] = s16[6*i+4] = 0;
00250             s16[6*i+5] = convert (f[i]);
00251 #endif
00252         }
00253         break;
00254     case A52_3F | A52_LFE:
00255         for (i = 0; i < 256; i++) {
00256 #if LIKEAC3DEC
00257             s16[6*i] = convert (f[i+256]);
00258             s16[6*i+2] = convert (f[i+768]);
00259             s16[6*i+3] = s16[6*i+4] = 0;
00260             s16[6*i+1] = convert (f[i+512]);
00261             s16[6*i+5] = convert (f[i]);
00262 #else
00263             s16[6*i] = convert (f[i+256]);
00264             s16[6*i+1] = convert (f[i+768]);
00265             s16[6*i+2] = s16[6*i+3] = 0;
00266             s16[6*i+4] = convert (f[i+512]);
00267             s16[6*i+5] = convert (f[i]);
00268 #endif
00269         }
00270         break;
00271     case A52_2F2R | A52_LFE:
00272         for (i = 0; i < 256; i++) {
00273 #if LIKEAC3DEC
00274             s16[6*i] = convert (f[i+256]);
00275             s16[6*i+1] = 0;
00276             s16[6*i+2] = convert (f[i+512]);
00277             s16[6*i+3] = convert (f[i+768]);
00278             s16[6*i+4] = convert (f[i+1024]);
00279             s16[6*i+5] = convert (f[i]);
00280 #else
00281             s16[6*i] = convert (f[i+256]);
00282             s16[6*i+1] = convert (f[i+512]);
00283             s16[6*i+2] = convert (f[i+768]);
00284             s16[6*i+3] = convert (f[i+1024]);
00285             s16[6*i+4] = 0;
00286             s16[6*i+5] = convert (f[i]);
00287 #endif
00288         }
00289         break;
00290     case A52_3F2R | A52_LFE:
00291         for (i = 0; i < 256; i++) {
00292 #if LIKEAC3DEC
00293             s16[6*i] = convert (f[i+256]);
00294             s16[6*i+1] = convert (f[i+512]);
00295             s16[6*i+2] = convert (f[i+768]);
00296             s16[6*i+3] = convert (f[i+1024]);
00297             s16[6*i+4] = convert (f[i+1280]);
00298             s16[6*i+5] = convert (f[i]);
00299 #else
00300             s16[6*i] = convert (f[i+256]);
00301             s16[6*i+1] = convert (f[i+768]);
00302             s16[6*i+2] = convert (f[i+1024]);
00303             s16[6*i+3] = convert (f[i+1280]);
00304             s16[6*i+4] = convert (f[i+512]);
00305             s16[6*i+5] = convert (f[i]);
00306 #endif
00307         }
00308         break;
00309     }
00310 }
00311 
00312 /**** end */
00313 
00314 #define HEADER_SIZE 7
00315 
00316 static int a52_decode_frame(AVCodecContext *avctx,
00317                             void *data, int *data_size,
00318                             uint8_t *buf, int buf_size)
00319 {
00320     AC3DecodeState *s = avctx->priv_data;
00321     uint8_t *buf_ptr;
00322     int flags, i, len;
00323     int sample_rate, bit_rate;
00324     short *out_samples = data;
00325     float level;
00326     static const int ac3_channels[8] = {
00327         2, 1, 2, 3, 3, 4, 4, 5
00328     };
00329 
00330     *data_size= 0;
00331 
00332     buf_ptr = buf;
00333     while (buf_size > 0) {
00334         len = s->inbuf_ptr - s->inbuf;
00335         if (s->frame_size == 0) {
00336             /* no header seen : find one. We need at least 7 bytes to parse it */
00337             len = HEADER_SIZE - len;
00338             if (len > buf_size)
00339                 len = buf_size;
00340             memcpy(s->inbuf_ptr, buf_ptr, len);
00341             buf_ptr += len;
00342             s->inbuf_ptr += len;
00343             buf_size -= len;
00344             if ((s->inbuf_ptr - s->inbuf) == HEADER_SIZE) {
00345                 len = s->a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
00346                 if (len == 0) {
00347                     /* no sync found : move by one byte (inefficient, but simple!) */
00348                     memcpy(s->inbuf, s->inbuf + 1, HEADER_SIZE - 1);
00349                     s->inbuf_ptr--;
00350                 } else {
00351                     s->frame_size = len;
00352                     /* update codec info */
00353                     avctx->sample_rate = sample_rate;
00354                     s->channels = ac3_channels[s->flags & 7];
00355                     if (s->flags & A52_LFE)
00356                         s->channels++;
00357                     if (avctx->request_channels > 0)
00358                     {
00359                         avctx->channels = s->channels;
00360                         if (s->channels > avctx->channels)
00361                             avctx->channels = avctx->request_channels;
00362                     }
00363                     if (avctx->channels == 0)
00364                         /* No specific number of channel requested */
00365                         avctx->channels = s->channels;
00366                     else if (s->channels < avctx->channels) {
00367                         av_log(avctx, AV_LOG_ERROR, "ac3dec: AC3 Source channels are less than specified: output to %d channels.. (frmsize: %d)\n", s->channels, len);
00368                         avctx->channels = s->channels;
00369                     }
00370                     avctx->bit_rate = bit_rate;
00371                 }
00372             }
00373         } else if (len < s->frame_size) {
00374             len = s->frame_size - len;
00375             if (len > buf_size)
00376                 len = buf_size;
00377 
00378             memcpy(s->inbuf_ptr, buf_ptr, len);
00379             buf_ptr += len;
00380             s->inbuf_ptr += len;
00381             buf_size -= len;
00382         } else {
00383             int chans;
00384             flags = s->flags;
00385             if (avctx->channels == 1)
00386                 flags = A52_MONO;
00387             else if (avctx->channels == 2) {
00388                 if (s->channels>2)
00389                     flags = A52_DOLBY;
00390                 else
00391                     flags = A52_STEREO;
00392             }
00393             else
00394                 flags |= A52_ADJUST_LEVEL;
00395             level = 1;
00396             chans = channels_multi(flags);
00397             if (s->a52_frame(s->state, s->inbuf, &flags, &level, 384)) {
00398             fail:
00399                 av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
00400                 s->inbuf_ptr = s->inbuf;
00401                 s->frame_size = 0;
00402                 continue;
00403             }
00404             for (i = 0; i < 6; i++) {
00405                 if (s->a52_block(s->state))
00406                     goto fail;
00407                 float2s16_multi(s->samples, out_samples + i * 256 * chans, flags);
00408             }
00409             s->inbuf_ptr = s->inbuf;
00410             s->frame_size = 0;
00411             *data_size = 6 * avctx->channels * 256 * sizeof(int16_t);
00412             break;
00413         }
00414     }
00415     return buf_ptr - buf;
00416 }
00417 
00418 static int a52_decode_end(AVCodecContext *avctx)
00419 {
00420     AC3DecodeState *s = avctx->priv_data;
00421     s->a52_free(s->state);
00422 #ifdef CONFIG_LIBA52BIN
00423     dlclose(s->handle);
00424 #endif
00425     return 0;
00426 }
00427 
00428 AVCodec liba52_decoder = {
00429     "liba52",
00430     CODEC_TYPE_AUDIO,
00431     CODEC_ID_AC3,
00432     sizeof(AC3DecodeState),
00433     a52_decode_init,
00434     NULL,
00435     a52_decode_end,
00436     a52_decode_frame,
00437 };