← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/g729dec.c

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/g729dec.c
1
 
/*
2
 
 * G.729 decoder
3
 
 * Copyright (c) 2008 Vladimir Voroshilov
4
 
 *
5
 
 * This file is part of Libav.
6
 
 *
7
 
 * Libav is free software; you can redistribute it and/or
8
 
 * modify it under the terms of the GNU Lesser General Public
9
 
 * License as published by the Free Software Foundation; either
10
 
 * version 2.1 of the License, or (at your option) any later version.
11
 
 *
12
 
 * Libav is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 
 * Lesser General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with Libav; if not, write to the Free Software
19
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 
 */
21
 
#include <stdlib.h>
22
 
#include <inttypes.h>
23
 
#include <limits.h>
24
 
#include <stdio.h>
25
 
#include <string.h>
26
 
#include <math.h>
27
 
#include <assert.h>
28
 
 
29
 
#include "avcodec.h"
30
 
#include "libavutil/avutil.h"
31
 
#include "get_bits.h"
32
 
 
33
 
#include "lsp.h"
34
 
#include "celp_math.h"
35
 
#include "acelp_filters.h"
36
 
#include "acelp_pitch_delay.h"
37
 
#include "acelp_vectors.h"
38
 
#include "g729data.h"
39
 
 
40
 
/**
41
 
 * minimum quantized LSF value (3.2.4)
42
 
 * 0.005 in Q13
43
 
 */
44
 
#define LSFQ_MIN                   40
45
 
 
46
 
/**
47
 
 * maximum quantized LSF value (3.2.4)
48
 
 * 3.135 in Q13
49
 
 */
50
 
#define LSFQ_MAX                   25681
51
 
 
52
 
/**
53
 
 * minimum LSF distance (3.2.4)
54
 
 * 0.0391 in Q13
55
 
 */
56
 
#define LSFQ_DIFF_MIN              321
57
 
 
58
 
/**
59
 
 * minimum gain pitch value (3.8, Equation 47)
60
 
 * 0.2 in (1.14)
61
 
 */
62
 
#define SHARP_MIN                  3277
63
 
 
64
 
/**
65
 
 * maximum gain pitch value (3.8, Equation 47)
66
 
 * (EE) This does not comply with the specification.
67
 
 * Specification says about 0.8, which should be
68
 
 * 13107 in (1.14), but reference C code uses
69
 
 * 13017 (equals to 0.7945) instead of it.
70
 
 */
71
 
#define SHARP_MAX                  13017
72
 
 
73
 
/**
74
 
 * subframe size
75
 
 */
76
 
#define SUBFRAME_SIZE              40
77
 
 
78
 
 
79
 
typedef struct {
80
 
    uint8_t ac_index_bits[2];   ///< adaptive codebook index for second subframe (size in bits)
81
 
    uint8_t parity_bit;         ///< parity bit for pitch delay
82
 
    uint8_t gc_1st_index_bits;  ///< gain codebook (first stage) index (size in bits)
83
 
    uint8_t gc_2nd_index_bits;  ///< gain codebook (second stage) index (size in bits)
84
 
    uint8_t fc_signs_bits;      ///< number of pulses in fixed-codebook vector
85
 
    uint8_t fc_indexes_bits;    ///< size (in bits) of fixed-codebook index entry
86
 
} G729FormatDescription;
87
 
 
88
 
typedef struct {
89
 
    int pitch_delay_int_prev;   ///< integer part of previous subframe's pitch delay (4.1.3)
90
 
 
91
 
    /// (2.13) LSP quantizer outputs
92
 
    int16_t  past_quantizer_output_buf[MA_NP + 1][10];
93
 
    int16_t* past_quantizer_outputs[MA_NP + 1];
94
 
 
95
 
    int16_t lsfq[10];           ///< (2.13) quantized LSF coefficients from previous frame
96
 
    int16_t lsp_buf[2][10];     ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
97
 
    int16_t *lsp[2];            ///< pointers to lsp_buf
98
 
}  G729Context;
99
 
 
100
 
static const G729FormatDescription format_g729_8k = {
101
 
    .ac_index_bits     = {8,5},
102
 
    .parity_bit        = 1,
103
 
    .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
104
 
    .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
105
 
    .fc_signs_bits     = 4,
106
 
    .fc_indexes_bits   = 13,
107
 
};
108
 
 
109
 
static const G729FormatDescription format_g729d_6k4 = {
110
 
    .ac_index_bits     = {8,4},
111
 
    .parity_bit        = 0,
112
 
    .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
113
 
    .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
114
 
    .fc_signs_bits     = 2,
115
 
    .fc_indexes_bits   = 9,
116
 
};
117
 
 
118
 
/**
119
 
 * \brief pseudo random number generator
120
 
 */
121
 
static inline uint16_t g729_prng(uint16_t value)
122
 
{
123
 
    return 31821 * value + 13849;
124
 
}
125
 
 
126
 
/**
127
 
 * Get parity bit of bit 2..7
128
 
 */
129
 
static inline int get_parity(uint8_t value)
130
 
{
131
 
   return (0x6996966996696996ULL >> (value >> 2)) & 1;
132
 
}
133
 
 
134
 
static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
135
 
                       int16_t ma_predictor,
136
 
                       int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
137
 
{
138
 
    int i,j;
139
 
    static const uint8_t min_distance[2]={10, 5}; //(2.13)
140
 
    int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
141
 
 
142
 
    for (i = 0; i < 5; i++) {
143
 
        quantizer_output[i]     = cb_lsp_1st[vq_1st][i    ] + cb_lsp_2nd[vq_2nd_low ][i    ];
144
 
        quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
145
 
    }
146
 
 
147
 
    for (j = 0; j < 2; j++) {
148
 
        for (i = 1; i < 10; i++) {
149
 
            int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
150
 
            if (diff > 0) {
151
 
                quantizer_output[i - 1] -= diff;
152
 
                quantizer_output[i    ] += diff;
153
 
            }
154
 
        }
155
 
    }
156
 
 
157
 
    for (i = 0; i < 10; i++) {
158
 
        int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
159
 
        for (j = 0; j < MA_NP; j++)
160
 
            sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
161
 
 
162
 
        lsfq[i] = sum >> 15;
163
 
    }
164
 
 
165
 
    /* Rotate past_quantizer_outputs. */
166
 
    memmove(past_quantizer_outputs + 1, past_quantizer_outputs, MA_NP * sizeof(int16_t*));
167
 
    past_quantizer_outputs[0] = quantizer_output;
168
 
 
169
 
    ff_acelp_reorder_lsf(lsfq, LSFQ_DIFF_MIN, LSFQ_MIN, LSFQ_MAX, 10);
170
 
}
171
 
 
172
 
static av_cold int decoder_init(AVCodecContext * avctx)
173
 
{
174
 
    G729Context* ctx = avctx->priv_data;
175
 
    int i,k;
176
 
 
177
 
    if (avctx->channels != 1) {
178
 
        av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
179
 
        return AVERROR(EINVAL);
180
 
    }
181
 
 
182
 
    /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
183
 
    avctx->frame_size = SUBFRAME_SIZE << 1;
184
 
 
185
 
    for (k = 0; k < MA_NP + 1; k++) {
186
 
        ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
187
 
        for (i = 1; i < 11; i++)
188
 
            ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
189
 
    }
190
 
 
191
 
    ctx->lsp[0] = ctx->lsp_buf[0];
192
 
    ctx->lsp[1] = ctx->lsp_buf[1];
193
 
    memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
194
 
 
195
 
    return 0;
196
 
}
197
 
 
198
 
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
199
 
                        AVPacket *avpkt)
200
 
{
201
 
    const uint8_t *buf = avpkt->data;
202
 
    int buf_size       = avpkt->size;
203
 
    int16_t *out_frame = data;
204
 
    GetBitContext gb;
205
 
    G729FormatDescription format;
206
 
    int frame_erasure = 0;    ///< frame erasure detected during decoding
207
 
    int bad_pitch = 0;        ///< parity check failed
208
 
    int i;
209
 
    G729Context *ctx = avctx->priv_data;
210
 
    int16_t lp[2][11];           // (3.12)
211
 
    uint8_t ma_predictor;     ///< switched MA predictor of LSP quantizer
212
 
    uint8_t quantizer_1st;    ///< first stage vector of quantizer
213
 
    uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
214
 
    uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
215
 
 
216
 
    int pitch_delay_int;         // pitch delay, integer part
217
 
    int pitch_delay_3x;          // pitch delay, multiplied by 3
218
 
 
219
 
    if (*data_size < SUBFRAME_SIZE << 2) {
220
 
        av_log(avctx, AV_LOG_ERROR, "Error processing packet: output buffer too small\n");
221
 
        return AVERROR(EIO);
222
 
    }
223
 
 
224
 
    if (buf_size == 10) {
225
 
        format = format_g729_8k;
226
 
        av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
227
 
    } else if (buf_size == 8) {
228
 
        format = format_g729d_6k4;
229
 
        av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
230
 
    } else {
231
 
        av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
232
 
        return AVERROR_INVALIDDATA;
233
 
    }
234
 
 
235
 
    for (i=0; i < buf_size; i++)
236
 
        frame_erasure |= buf[i];
237
 
    frame_erasure = !frame_erasure;
238
 
 
239
 
    init_get_bits(&gb, buf, buf_size);
240
 
 
241
 
    ma_predictor     = get_bits(&gb, 1);
242
 
    quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
243
 
    quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
244
 
    quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
245
 
 
246
 
    lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
247
 
               ma_predictor,
248
 
               quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
249
 
 
250
 
    ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
251
 
 
252
 
    ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
253
 
 
254
 
    FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
255
 
 
256
 
    for (i = 0; i < 2; i++) {
257
 
        uint8_t ac_index;      ///< adaptive codebook index
258
 
        uint8_t pulses_signs;  ///< fixed-codebook vector pulse signs
259
 
        int fc_indexes;        ///< fixed-codebook indexes
260
 
        uint8_t gc_1st_index;  ///< gain codebook (first stage) index
261
 
        uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
262
 
 
263
 
        ac_index      = get_bits(&gb, format.ac_index_bits[i]);
264
 
        if(!i && format.parity_bit)
265
 
            bad_pitch = get_parity(ac_index) == get_bits1(&gb);
266
 
        fc_indexes    = get_bits(&gb, format.fc_indexes_bits);
267
 
        pulses_signs  = get_bits(&gb, format.fc_signs_bits);
268
 
        gc_1st_index  = get_bits(&gb, format.gc_1st_index_bits);
269
 
        gc_2nd_index  = get_bits(&gb, format.gc_2nd_index_bits);
270
 
 
271
 
        if(!i) {
272
 
            if (bad_pitch)
273
 
                pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
274
 
            else
275
 
                pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
276
 
        } else {
277
 
            int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
278
 
                                          PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9);
279
 
 
280
 
            if(packet_type == FORMAT_G729D_6K4)
281
 
                pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
282
 
            else
283
 
                pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
284
 
        }
285
 
 
286
 
        /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
287
 
        pitch_delay_int  = (pitch_delay_3x + 1) / 3;
288
 
 
289
 
        ff_acelp_weighted_vector_sum(fc + pitch_delay_int,
290
 
                                     fc + pitch_delay_int,
291
 
                                     fc, 1 << 14,
292
 
                                     av_clip(ctx->gain_pitch, SHARP_MIN, SHARP_MAX),
293
 
                                     0, 14,
294
 
                                     SUBFRAME_SIZE - pitch_delay_int);
295
 
 
296
 
        if (frame_erasure) {
297
 
            ctx->gain_pitch = (29491 * ctx->gain_pitch) >> 15; // 0.90 (0.15)
298
 
            ctx->gain_code  = ( 2007 * ctx->gain_code ) >> 11; // 0.98 (0.11)
299
 
 
300
 
            gain_corr_factor = 0;
301
 
        } else {
302
 
            ctx->gain_pitch  = cb_gain_1st_8k[gc_1st_index][0] +
303
 
                               cb_gain_2nd_8k[gc_2nd_index][0];
304
 
            gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
305
 
                               cb_gain_2nd_8k[gc_2nd_index][1];
306
 
 
307
 
        ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
308
 
                                     ctx->exc + i * SUBFRAME_SIZE, fc,
309
 
                                     (!voicing && frame_erasure) ? 0 : ctx->gain_pitch,
310
 
                                     ( voicing && frame_erasure) ? 0 : ctx->gain_code,
311
 
                                     1 << 13, 14, SUBFRAME_SIZE);
312
 
 
313
 
            ctx->pitch_delay_int_prev = pitch_delay_int;
314
 
    }
315
 
 
316
 
    *data_size = SUBFRAME_SIZE << 2;
317
 
    return buf_size;
318
 
}
319
 
 
320
 
AVCodec ff_g729_decoder =
321
 
{
322
 
    "g729",
323
 
    AVMEDIA_TYPE_AUDIO,
324
 
    CODEC_ID_G729,
325
 
    sizeof(G729Context),
326
 
    decoder_init,
327
 
    NULL,
328
 
    NULL,
329
 
    decode_frame,
330
 
    .long_name = NULL_IF_CONFIG_SMALL("G.729"),
331
 
};