FFmpeg
g722dec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) CMU 1993 Computer Science, Speech Group
3  * Chengxiang Lu and Alex Hauptmann
4  * Copyright (c) 2005 Steve Underwood <steveu at coppice.org>
5  * Copyright (c) 2009 Kenan Gillet
6  * Copyright (c) 2010 Martin Storsjo
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * G.722 ADPCM audio decoder
28  *
29  * This G.722 decoder is a bit-exact implementation of the ITU G.722
30  * specification for all three specified bitrates - 64000bps, 56000bps
31  * and 48000bps. It passes the ITU tests.
32  *
33  * @note For the 56000bps and 48000bps bitrates, the lowest 1 or 2 bits
34  * respectively of each byte are ignored.
35  */
36 
38 #include "libavutil/opt.h"
39 #include "avcodec.h"
40 #include "codec_internal.h"
41 #include "decode.h"
42 #include "get_bits.h"
43 #include "g722.h"
44 
45 #define OFFSET(x) offsetof(G722Context, x)
46 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
47 static const AVOption options[] = {
48  { "bits_per_codeword", "Bits per G722 codeword", OFFSET(bits_per_codeword), AV_OPT_TYPE_INT, { .i64 = 8 }, 6, 8, AD },
49  { NULL }
50 };
51 
52 static const AVClass g722_decoder_class = {
53  .class_name = "g722 decoder",
54  .item_name = av_default_item_name,
55  .option = options,
56  .version = LIBAVUTIL_VERSION_INT,
57 };
58 
60 {
61  G722Context *c = avctx->priv_data;
62 
66 
67  c->band[0].scale_factor = 8;
68  c->band[1].scale_factor = 2;
69  c->prev_samples_pos = 22;
70 
71  ff_g722dsp_init(&c->dsp);
72 
73  return 0;
74 }
75 
76 static const int16_t low_inv_quant5[32] = {
77  -35, -35, -2919, -2195, -1765, -1458, -1219, -1023,
78  -858, -714, -587, -473, -370, -276, -190, -110,
79  2919, 2195, 1765, 1458, 1219, 1023, 858, 714,
80  587, 473, 370, 276, 190, 110, 35, -35
81 };
82 
83 static const int16_t * const low_inv_quants[3] = { ff_g722_low_inv_quant6,
86 
88  int *got_frame_ptr, AVPacket *avpkt)
89 {
90  G722Context *c = avctx->priv_data;
91  int16_t *out_buf;
92  int j, ret;
93  const int skip = 8 - c->bits_per_codeword;
94  const int16_t *quantizer_table = low_inv_quants[skip];
95  GetBitContext gb;
96 
97  /* get output buffer */
98  frame->nb_samples = avpkt->size * 2;
99  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
100  return ret;
101  out_buf = (int16_t *)frame->data[0];
102 
103  ret = init_get_bits8(&gb, avpkt->data, avpkt->size);
104  if (ret < 0)
105  return ret;
106 
107  for (j = 0; j < avpkt->size; j++) {
108  int ilow, ihigh, rlow, rhigh, dhigh;
109  int xout[2];
110 
111  ihigh = get_bits(&gb, 2);
112  ilow = get_bits(&gb, 6 - skip);
113  skip_bits(&gb, skip);
114 
115  rlow = av_clip_intp2((c->band[0].scale_factor * quantizer_table[ilow] >> 10)
116  + c->band[0].s_predictor, 14);
117 
118  ff_g722_update_low_predictor(&c->band[0], ilow >> (2 - skip));
119 
120  dhigh = c->band[1].scale_factor * ff_g722_high_inv_quant[ihigh] >> 10;
121  rhigh = av_clip_intp2(dhigh + c->band[1].s_predictor, 14);
122 
123  ff_g722_update_high_predictor(&c->band[1], dhigh, ihigh);
124 
125  c->prev_samples[c->prev_samples_pos++] = rlow + rhigh;
126  c->prev_samples[c->prev_samples_pos++] = rlow - rhigh;
127  c->dsp.apply_qmf(c->prev_samples + c->prev_samples_pos - 24, xout);
128  *out_buf++ = av_clip_int16(xout[0] >> 11);
129  *out_buf++ = av_clip_int16(xout[1] >> 11);
130  if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
131  memmove(c->prev_samples, c->prev_samples + c->prev_samples_pos - 22,
132  22 * sizeof(c->prev_samples[0]));
133  c->prev_samples_pos = 22;
134  }
135  }
136 
137  *got_frame_ptr = 1;
138 
139  return avpkt->size;
140 }
141 
143  .p.name = "g722",
144  CODEC_LONG_NAME("G.722 ADPCM"),
145  .p.type = AVMEDIA_TYPE_AUDIO,
146  .p.id = AV_CODEC_ID_ADPCM_G722,
147  .priv_data_size = sizeof(G722Context),
150  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
151  .p.priv_class = &g722_decoder_class,
152 };
opt.h
OFFSET
#define OFFSET(x)
Definition: g722dec.c:45
PREV_SAMPLES_BUF_SIZE
#define PREV_SAMPLES_BUF_SIZE
Definition: g722.h:32
ff_g722_low_inv_quant4
const int16_t ff_g722_low_inv_quant4[16]
Definition: g722.c:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVOption
AVOption.
Definition: opt.h:429
FFCodec
Definition: codec_internal.h:127
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:401
g722_decode_init
static av_cold int g722_decode_init(AVCodecContext *avctx)
Definition: g722dec.c:59
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
ff_g722_low_inv_quant6
const int16_t ff_g722_low_inv_quant6[64]
Definition: g722.c:63
GetBitContext
Definition: get_bits.h:108
g722_decode_frame
static int g722_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: g722dec.c:87
g722_decoder_class
static const AVClass g722_decoder_class
Definition: g722dec.c:52
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_g722_high_inv_quant
const int16_t ff_g722_high_inv_quant[4]
Definition: g722.c:51
decode.h
get_bits.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
low_inv_quant5
static const int16_t low_inv_quant5[32]
Definition: g722dec.c:76
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
G722Context
Definition: g722.h:34
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
av_clip_int16
#define av_clip_int16
Definition: common.h:115
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:121
ff_g722_update_high_predictor
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
Definition: g722.c:154
options
static const AVOption options[]
Definition: g722dec.c:47
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
options
Definition: swscale.c:42
AD
#define AD
Definition: g722dec.c:46
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:540
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:317
codec_internal.h
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
low_inv_quants
static const int16_t *const low_inv_quants[3]
Definition: g722dec.c:83
g722.h
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCodecContext
main external API structure.
Definition: avcodec.h:451
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:440
ff_adpcm_g722_decoder
const FFCodec ff_adpcm_g722_decoder
Definition: g722dec.c:142
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:392
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
ff_g722_update_low_predictor
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
Definition: g722.c:143
ff_g722dsp_init
av_cold void ff_g722dsp_init(G722DSPContext *c)
Definition: g722dsp.c:68
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375