libavcodec/sipr.c
Go to the documentation of this file.
00001 /*
00002  * SIPR / ACELP.NET decoder
00003  *
00004  * Copyright (c) 2008 Vladimir Voroshilov
00005  * Copyright (c) 2009 Vitor Sessak
00006  *
00007  * This file is part of Libav.
00008  *
00009  * Libav is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public
00011  * License as published by the Free Software Foundation; either
00012  * version 2.1 of the License, or (at your option) any later version.
00013  *
00014  * Libav is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with Libav; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00022  */
00023 
00024 #include <math.h>
00025 #include <stdint.h>
00026 #include <string.h>
00027 
00028 #include "libavutil/mathematics.h"
00029 #include "avcodec.h"
00030 #define BITSTREAM_READER_LE
00031 #include "get_bits.h"
00032 #include "dsputil.h"
00033 
00034 #include "lsp.h"
00035 #include "celp_math.h"
00036 #include "acelp_vectors.h"
00037 #include "acelp_pitch_delay.h"
00038 #include "acelp_filters.h"
00039 #include "celp_filters.h"
00040 
00041 #define MAX_SUBFRAME_COUNT   5
00042 
00043 #include "sipr.h"
00044 #include "siprdata.h"
00045 
00046 typedef struct {
00047     const char *mode_name;
00048     uint16_t bits_per_frame;
00049     uint8_t subframe_count;
00050     uint8_t frames_per_packet;
00051     float pitch_sharp_factor;
00052 
00053     /* bitstream parameters */
00054     uint8_t number_of_fc_indexes;
00055     uint8_t ma_predictor_bits;  
00056 
00058     uint8_t vq_indexes_bits[5];
00059 
00061     uint8_t pitch_delay_bits[5];
00062 
00063     uint8_t gp_index_bits;
00064     uint8_t fc_index_bits[10]; 
00065     uint8_t gc_index_bits;     
00066 } SiprModeParam;
00067 
00068 static const SiprModeParam modes[MODE_COUNT] = {
00069     [MODE_16k] = {
00070         .mode_name          = "16k",
00071         .bits_per_frame     = 160,
00072         .subframe_count     = SUBFRAME_COUNT_16k,
00073         .frames_per_packet  = 1,
00074         .pitch_sharp_factor = 0.00,
00075 
00076         .number_of_fc_indexes = 10,
00077         .ma_predictor_bits    = 1,
00078         .vq_indexes_bits      = {7, 8, 7, 7, 7},
00079         .pitch_delay_bits     = {9, 6},
00080         .gp_index_bits        = 4,
00081         .fc_index_bits        = {4, 5, 4, 5, 4, 5, 4, 5, 4, 5},
00082         .gc_index_bits        = 5
00083     },
00084 
00085     [MODE_8k5] = {
00086         .mode_name          = "8k5",
00087         .bits_per_frame     = 152,
00088         .subframe_count     = 3,
00089         .frames_per_packet  = 1,
00090         .pitch_sharp_factor = 0.8,
00091 
00092         .number_of_fc_indexes = 3,
00093         .ma_predictor_bits    = 0,
00094         .vq_indexes_bits      = {6, 7, 7, 7, 5},
00095         .pitch_delay_bits     = {8, 5, 5},
00096         .gp_index_bits        = 0,
00097         .fc_index_bits        = {9, 9, 9},
00098         .gc_index_bits        = 7
00099     },
00100 
00101     [MODE_6k5] = {
00102         .mode_name          = "6k5",
00103         .bits_per_frame     = 232,
00104         .subframe_count     = 3,
00105         .frames_per_packet  = 2,
00106         .pitch_sharp_factor = 0.8,
00107 
00108         .number_of_fc_indexes = 3,
00109         .ma_predictor_bits    = 0,
00110         .vq_indexes_bits      = {6, 7, 7, 7, 5},
00111         .pitch_delay_bits     = {8, 5, 5},
00112         .gp_index_bits        = 0,
00113         .fc_index_bits        = {5, 5, 5},
00114         .gc_index_bits        = 7
00115     },
00116 
00117     [MODE_5k0] = {
00118         .mode_name          = "5k0",
00119         .bits_per_frame     = 296,
00120         .subframe_count     = 5,
00121         .frames_per_packet  = 2,
00122         .pitch_sharp_factor = 0.85,
00123 
00124         .number_of_fc_indexes = 1,
00125         .ma_predictor_bits    = 0,
00126         .vq_indexes_bits      = {6, 7, 7, 7, 5},
00127         .pitch_delay_bits     = {8, 5, 8, 5, 5},
00128         .gp_index_bits        = 0,
00129         .fc_index_bits        = {10},
00130         .gc_index_bits        = 7
00131     }
00132 };
00133 
00134 const float ff_pow_0_5[] = {
00135     1.0/(1 <<  1), 1.0/(1 <<  2), 1.0/(1 <<  3), 1.0/(1 <<  4),
00136     1.0/(1 <<  5), 1.0/(1 <<  6), 1.0/(1 <<  7), 1.0/(1 <<  8),
00137     1.0/(1 <<  9), 1.0/(1 << 10), 1.0/(1 << 11), 1.0/(1 << 12),
00138     1.0/(1 << 13), 1.0/(1 << 14), 1.0/(1 << 15), 1.0/(1 << 16)
00139 };
00140 
00141 static void dequant(float *out, const int *idx, const float *cbs[])
00142 {
00143     int i;
00144     int stride  = 2;
00145     int num_vec = 5;
00146 
00147     for (i = 0; i < num_vec; i++)
00148         memcpy(out + stride*i, cbs[i] + stride*idx[i], stride*sizeof(float));
00149 
00150 }
00151 
00152 static void lsf_decode_fp(float *lsfnew, float *lsf_history,
00153                           const SiprParameters *parm)
00154 {
00155     int i;
00156     float lsf_tmp[LP_FILTER_ORDER];
00157 
00158     dequant(lsf_tmp, parm->vq_indexes, lsf_codebooks);
00159 
00160     for (i = 0; i < LP_FILTER_ORDER; i++)
00161         lsfnew[i] = lsf_history[i] * 0.33 + lsf_tmp[i] + mean_lsf[i];
00162 
00163     ff_sort_nearly_sorted_floats(lsfnew, LP_FILTER_ORDER - 1);
00164 
00165     /* Note that a minimum distance is not enforced between the last value and
00166        the previous one, contrary to what is done in ff_acelp_reorder_lsf() */
00167     ff_set_min_dist_lsf(lsfnew, LSFQ_DIFF_MIN, LP_FILTER_ORDER - 1);
00168     lsfnew[9] = FFMIN(lsfnew[LP_FILTER_ORDER - 1], 1.3 * M_PI);
00169 
00170     memcpy(lsf_history, lsf_tmp, LP_FILTER_ORDER * sizeof(*lsf_history));
00171 
00172     for (i = 0; i < LP_FILTER_ORDER - 1; i++)
00173         lsfnew[i] = cos(lsfnew[i]);
00174     lsfnew[LP_FILTER_ORDER - 1] *= 6.153848 / M_PI;
00175 }
00176 
00178 static void pitch_sharpening(int pitch_lag_int, float beta,
00179                              float *fixed_vector)
00180 {
00181     int i;
00182 
00183     for (i = pitch_lag_int; i < SUBFR_SIZE; i++)
00184         fixed_vector[i] += beta * fixed_vector[i - pitch_lag_int];
00185 }
00186 
00192 static void decode_parameters(SiprParameters* parms, GetBitContext *pgb,
00193                               const SiprModeParam *p)
00194 {
00195     int i, j;
00196 
00197     if (p->ma_predictor_bits)
00198         parms->ma_pred_switch       = get_bits(pgb, p->ma_predictor_bits);
00199 
00200     for (i = 0; i < 5; i++)
00201         parms->vq_indexes[i]        = get_bits(pgb, p->vq_indexes_bits[i]);
00202 
00203     for (i = 0; i < p->subframe_count; i++) {
00204         parms->pitch_delay[i]       = get_bits(pgb, p->pitch_delay_bits[i]);
00205         if (p->gp_index_bits)
00206             parms->gp_index[i]      = get_bits(pgb, p->gp_index_bits);
00207 
00208         for (j = 0; j < p->number_of_fc_indexes; j++)
00209             parms->fc_indexes[i][j] = get_bits(pgb, p->fc_index_bits[j]);
00210 
00211         parms->gc_index[i]          = get_bits(pgb, p->gc_index_bits);
00212     }
00213 }
00214 
00215 static void sipr_decode_lp(float *lsfnew, const float *lsfold, float *Az,
00216                            int num_subfr)
00217 {
00218     double lsfint[LP_FILTER_ORDER];
00219     int i,j;
00220     float t, t0 = 1.0 / num_subfr;
00221 
00222     t = t0 * 0.5;
00223     for (i = 0; i < num_subfr; i++) {
00224         for (j = 0; j < LP_FILTER_ORDER; j++)
00225             lsfint[j] = lsfold[j] * (1 - t) + t * lsfnew[j];
00226 
00227         ff_amrwb_lsp2lpc(lsfint, Az, LP_FILTER_ORDER);
00228         Az += LP_FILTER_ORDER;
00229         t += t0;
00230     }
00231 }
00232 
00236 static void eval_ir(const float *Az, int pitch_lag, float *freq,
00237                     float pitch_sharp_factor)
00238 {
00239     float tmp1[SUBFR_SIZE+1], tmp2[LP_FILTER_ORDER+1];
00240     int i;
00241 
00242     tmp1[0] = 1.;
00243     for (i = 0; i < LP_FILTER_ORDER; i++) {
00244         tmp1[i+1] = Az[i] * ff_pow_0_55[i];
00245         tmp2[i  ] = Az[i] * ff_pow_0_7 [i];
00246     }
00247     memset(tmp1 + 11, 0, 37 * sizeof(float));
00248 
00249     ff_celp_lp_synthesis_filterf(freq, tmp2, tmp1, SUBFR_SIZE,
00250                                  LP_FILTER_ORDER);
00251 
00252     pitch_sharpening(pitch_lag, pitch_sharp_factor, freq);
00253 }
00254 
00258 static void convolute_with_sparse(float *out, const AMRFixed *pulses,
00259                                   const float *shape, int length)
00260 {
00261     int i, j;
00262 
00263     memset(out, 0, length*sizeof(float));
00264     for (i = 0; i < pulses->n; i++)
00265         for (j = pulses->x[i]; j < length; j++)
00266             out[j] += pulses->y[i] * shape[j - pulses->x[i]];
00267 }
00268 
00272 static void postfilter_5k0(SiprContext *ctx, const float *lpc, float *samples)
00273 {
00274     float buf[SUBFR_SIZE + LP_FILTER_ORDER];
00275     float *pole_out = buf + LP_FILTER_ORDER;
00276     float lpc_n[LP_FILTER_ORDER];
00277     float lpc_d[LP_FILTER_ORDER];
00278     int i;
00279 
00280     for (i = 0; i < LP_FILTER_ORDER; i++) {
00281         lpc_d[i] = lpc[i] * ff_pow_0_75[i];
00282         lpc_n[i] = lpc[i] * ff_pow_0_5 [i];
00283     };
00284 
00285     memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem,
00286            LP_FILTER_ORDER*sizeof(float));
00287 
00288     ff_celp_lp_synthesis_filterf(pole_out, lpc_d, samples, SUBFR_SIZE,
00289                                  LP_FILTER_ORDER);
00290 
00291     memcpy(ctx->postfilter_mem, pole_out + SUBFR_SIZE - LP_FILTER_ORDER,
00292            LP_FILTER_ORDER*sizeof(float));
00293 
00294     ff_tilt_compensation(&ctx->tilt_mem, 0.4, pole_out, SUBFR_SIZE);
00295 
00296     memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem5k0,
00297            LP_FILTER_ORDER*sizeof(*pole_out));
00298 
00299     memcpy(ctx->postfilter_mem5k0, pole_out + SUBFR_SIZE - LP_FILTER_ORDER,
00300            LP_FILTER_ORDER*sizeof(*pole_out));
00301 
00302     ff_celp_lp_zero_synthesis_filterf(samples, lpc_n, pole_out, SUBFR_SIZE,
00303                                       LP_FILTER_ORDER);
00304 
00305 }
00306 
00307 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const int16_t *pulses,
00308                                 SiprMode mode, int low_gain)
00309 {
00310     int i;
00311 
00312     switch (mode) {
00313     case MODE_6k5:
00314         for (i = 0; i < 3; i++) {
00315             fixed_sparse->x[i] = 3 * (pulses[i] & 0xf) + i;
00316             fixed_sparse->y[i] = pulses[i] & 0x10 ? -1 : 1;
00317         }
00318         fixed_sparse->n = 3;
00319         break;
00320     case MODE_8k5:
00321         for (i = 0; i < 3; i++) {
00322             fixed_sparse->x[2*i    ] = 3 * ((pulses[i] >> 4) & 0xf) + i;
00323             fixed_sparse->x[2*i + 1] = 3 * ( pulses[i]       & 0xf) + i;
00324 
00325             fixed_sparse->y[2*i    ] = (pulses[i] & 0x100) ? -1.0: 1.0;
00326 
00327             fixed_sparse->y[2*i + 1] =
00328                 (fixed_sparse->x[2*i + 1] < fixed_sparse->x[2*i]) ?
00329                 -fixed_sparse->y[2*i    ] : fixed_sparse->y[2*i];
00330         }
00331 
00332         fixed_sparse->n = 6;
00333         break;
00334     case MODE_5k0:
00335     default:
00336         if (low_gain) {
00337             int offset = (pulses[0] & 0x200) ? 2 : 0;
00338             int val = pulses[0];
00339 
00340             for (i = 0; i < 3; i++) {
00341                 int index = (val & 0x7) * 6 + 4 - i*2;
00342 
00343                 fixed_sparse->y[i] = (offset + index) & 0x3 ? -1 : 1;
00344                 fixed_sparse->x[i] = index;
00345 
00346                 val >>= 3;
00347             }
00348             fixed_sparse->n = 3;
00349         } else {
00350             int pulse_subset = (pulses[0] >> 8) & 1;
00351 
00352             fixed_sparse->x[0] = ((pulses[0] >> 4) & 15) * 3 + pulse_subset;
00353             fixed_sparse->x[1] = ( pulses[0]       & 15) * 3 + pulse_subset + 1;
00354 
00355             fixed_sparse->y[0] = pulses[0] & 0x200 ? -1 : 1;
00356             fixed_sparse->y[1] = -fixed_sparse->y[0];
00357             fixed_sparse->n = 2;
00358         }
00359         break;
00360     }
00361 }
00362 
00363 static void decode_frame(SiprContext *ctx, SiprParameters *params,
00364                          float *out_data)
00365 {
00366     int i, j;
00367     int subframe_count = modes[ctx->mode].subframe_count;
00368     int frame_size = subframe_count * SUBFR_SIZE;
00369     float Az[LP_FILTER_ORDER * MAX_SUBFRAME_COUNT];
00370     float *excitation;
00371     float ir_buf[SUBFR_SIZE + LP_FILTER_ORDER];
00372     float lsf_new[LP_FILTER_ORDER];
00373     float *impulse_response = ir_buf + LP_FILTER_ORDER;
00374     float *synth = ctx->synth_buf + 16; // 16 instead of LP_FILTER_ORDER for
00375                                         // memory alignment
00376     int t0_first = 0;
00377     AMRFixed fixed_cb;
00378 
00379     memset(ir_buf, 0, LP_FILTER_ORDER * sizeof(float));
00380     lsf_decode_fp(lsf_new, ctx->lsf_history, params);
00381 
00382     sipr_decode_lp(lsf_new, ctx->lsp_history, Az, subframe_count);
00383 
00384     memcpy(ctx->lsp_history, lsf_new, LP_FILTER_ORDER * sizeof(float));
00385 
00386     excitation = ctx->excitation + PITCH_DELAY_MAX + L_INTERPOL;
00387 
00388     for (i = 0; i < subframe_count; i++) {
00389         float *pAz = Az + i*LP_FILTER_ORDER;
00390         float fixed_vector[SUBFR_SIZE];
00391         int T0,T0_frac;
00392         float pitch_gain, gain_code, avg_energy;
00393 
00394         ff_decode_pitch_lag(&T0, &T0_frac, params->pitch_delay[i], t0_first, i,
00395                             ctx->mode == MODE_5k0, 6);
00396 
00397         if (i == 0 || (i == 2 && ctx->mode == MODE_5k0))
00398             t0_first = T0;
00399 
00400         ff_acelp_interpolatef(excitation, excitation - T0 + (T0_frac <= 0),
00401                               ff_b60_sinc, 6,
00402                               2 * ((2 + T0_frac)%3 + 1), LP_FILTER_ORDER,
00403                               SUBFR_SIZE);
00404 
00405         decode_fixed_sparse(&fixed_cb, params->fc_indexes[i], ctx->mode,
00406                             ctx->past_pitch_gain < 0.8);
00407 
00408         eval_ir(pAz, T0, impulse_response, modes[ctx->mode].pitch_sharp_factor);
00409 
00410         convolute_with_sparse(fixed_vector, &fixed_cb, impulse_response,
00411                               SUBFR_SIZE);
00412 
00413         avg_energy =
00414             (0.01 + ff_dot_productf(fixed_vector, fixed_vector, SUBFR_SIZE))/
00415                 SUBFR_SIZE;
00416 
00417         ctx->past_pitch_gain = pitch_gain = gain_cb[params->gc_index[i]][0];
00418 
00419         gain_code = ff_amr_set_fixed_gain(gain_cb[params->gc_index[i]][1],
00420                                           avg_energy, ctx->energy_history,
00421                                           34 - 15.0/(0.05*M_LN10/M_LN2),
00422                                           pred);
00423 
00424         ff_weighted_vector_sumf(excitation, excitation, fixed_vector,
00425                                 pitch_gain, gain_code, SUBFR_SIZE);
00426 
00427         pitch_gain *= 0.5 * pitch_gain;
00428         pitch_gain = FFMIN(pitch_gain, 0.4);
00429 
00430         ctx->gain_mem = 0.7 * ctx->gain_mem + 0.3 * pitch_gain;
00431         ctx->gain_mem = FFMIN(ctx->gain_mem, pitch_gain);
00432         gain_code *= ctx->gain_mem;
00433 
00434         for (j = 0; j < SUBFR_SIZE; j++)
00435             fixed_vector[j] = excitation[j] - gain_code * fixed_vector[j];
00436 
00437         if (ctx->mode == MODE_5k0) {
00438             postfilter_5k0(ctx, pAz, fixed_vector);
00439 
00440             ff_celp_lp_synthesis_filterf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,
00441                                          pAz, excitation, SUBFR_SIZE,
00442                                          LP_FILTER_ORDER);
00443         }
00444 
00445         ff_celp_lp_synthesis_filterf(synth + i*SUBFR_SIZE, pAz, fixed_vector,
00446                                      SUBFR_SIZE, LP_FILTER_ORDER);
00447 
00448         excitation += SUBFR_SIZE;
00449     }
00450 
00451     memcpy(synth - LP_FILTER_ORDER, synth + frame_size - LP_FILTER_ORDER,
00452            LP_FILTER_ORDER * sizeof(float));
00453 
00454     if (ctx->mode == MODE_5k0) {
00455         for (i = 0; i < subframe_count; i++) {
00456             float energy = ff_dot_productf(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,
00457                                            ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i*SUBFR_SIZE,
00458                                            SUBFR_SIZE);
00459             ff_adaptive_gain_control(&synth[i * SUBFR_SIZE],
00460                                      &synth[i * SUBFR_SIZE], energy,
00461                                      SUBFR_SIZE, 0.9, &ctx->postfilter_agc);
00462         }
00463 
00464         memcpy(ctx->postfilter_syn5k0, ctx->postfilter_syn5k0 + frame_size,
00465                LP_FILTER_ORDER*sizeof(float));
00466     }
00467     memmove(ctx->excitation, excitation - PITCH_DELAY_MAX - L_INTERPOL,
00468            (PITCH_DELAY_MAX + L_INTERPOL) * sizeof(float));
00469 
00470     ff_acelp_apply_order_2_transfer_function(out_data, synth,
00471                                              (const float[2]) {-1.99997   , 1.000000000},
00472                                              (const float[2]) {-1.93307352, 0.935891986},
00473                                              0.939805806,
00474                                              ctx->highpass_filt_mem,
00475                                              frame_size);
00476 }
00477 
00478 static av_cold int sipr_decoder_init(AVCodecContext * avctx)
00479 {
00480     SiprContext *ctx = avctx->priv_data;
00481     int i;
00482 
00483     switch (avctx->block_align) {
00484     case 20: ctx->mode = MODE_16k; break;
00485     case 19: ctx->mode = MODE_8k5; break;
00486     case 29: ctx->mode = MODE_6k5; break;
00487     case 37: ctx->mode = MODE_5k0; break;
00488     default:
00489         if      (avctx->bit_rate > 12200) ctx->mode = MODE_16k;
00490         else if (avctx->bit_rate > 7500 ) ctx->mode = MODE_8k5;
00491         else if (avctx->bit_rate > 5750 ) ctx->mode = MODE_6k5;
00492         else                              ctx->mode = MODE_5k0;
00493         av_log(avctx, AV_LOG_WARNING,
00494                "Invalid block_align: %d. Mode %s guessed based on bitrate: %d\n",
00495                avctx->block_align, modes[ctx->mode].mode_name, avctx->bit_rate);
00496     }
00497 
00498     av_log(avctx, AV_LOG_DEBUG, "Mode: %s\n", modes[ctx->mode].mode_name);
00499 
00500     if (ctx->mode == MODE_16k) {
00501         ff_sipr_init_16k(ctx);
00502         ctx->decode_frame = ff_sipr_decode_frame_16k;
00503     } else {
00504         ctx->decode_frame = decode_frame;
00505     }
00506 
00507     for (i = 0; i < LP_FILTER_ORDER; i++)
00508         ctx->lsp_history[i] = cos((i+1) * M_PI / (LP_FILTER_ORDER + 1));
00509 
00510     for (i = 0; i < 4; i++)
00511         ctx->energy_history[i] = -14;
00512 
00513     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00514 
00515     avcodec_get_frame_defaults(&ctx->frame);
00516     avctx->coded_frame = &ctx->frame;
00517 
00518     return 0;
00519 }
00520 
00521 static int sipr_decode_frame(AVCodecContext *avctx, void *data,
00522                              int *got_frame_ptr, AVPacket *avpkt)
00523 {
00524     SiprContext *ctx = avctx->priv_data;
00525     const uint8_t *buf=avpkt->data;
00526     SiprParameters parm;
00527     const SiprModeParam *mode_par = &modes[ctx->mode];
00528     GetBitContext gb;
00529     float *samples;
00530     int subframe_size = ctx->mode == MODE_16k ? L_SUBFR_16k : SUBFR_SIZE;
00531     int i, ret;
00532 
00533     ctx->avctx = avctx;
00534     if (avpkt->size < (mode_par->bits_per_frame >> 3)) {
00535         av_log(avctx, AV_LOG_ERROR,
00536                "Error processing packet: packet size (%d) too small\n",
00537                avpkt->size);
00538         return -1;
00539     }
00540 
00541     /* get output buffer */
00542     ctx->frame.nb_samples = mode_par->frames_per_packet * subframe_size *
00543                             mode_par->subframe_count;
00544     if ((ret = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
00545         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00546         return ret;
00547     }
00548     samples = (float *)ctx->frame.data[0];
00549 
00550     init_get_bits(&gb, buf, mode_par->bits_per_frame);
00551 
00552     for (i = 0; i < mode_par->frames_per_packet; i++) {
00553         decode_parameters(&parm, &gb, mode_par);
00554 
00555         ctx->decode_frame(ctx, &parm, samples);
00556 
00557         samples += subframe_size * mode_par->subframe_count;
00558     }
00559 
00560     *got_frame_ptr   = 1;
00561     *(AVFrame *)data = ctx->frame;
00562 
00563     return mode_par->bits_per_frame >> 3;
00564 }
00565 
00566 AVCodec ff_sipr_decoder = {
00567     .name           = "sipr",
00568     .type           = AVMEDIA_TYPE_AUDIO,
00569     .id             = CODEC_ID_SIPR,
00570     .priv_data_size = sizeof(SiprContext),
00571     .init           = sipr_decoder_init,
00572     .decode         = sipr_decode_frame,
00573     .capabilities   = CODEC_CAP_DR1,
00574     .long_name = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"),
00575 };