16d9972f2c7251ccb6934af5dc95f0ad8973eea9
[ffmpeg.git] / libavcodec / libgsm.c
1 /*
2  * Interface to libgsm for gsm encoding/decoding
3  * Copyright (c) 2005 Alban Bedel <albeu@free.fr>
4  * Copyright (c) 2006, 2007 Michel Bardiaux <mbardiaux@mediaxim.be>
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * Interface to libgsm for gsm encoding/decoding
26  */
27
28 // The idiosyncrasies of GSM-in-WAV are explained at http://kbs.cs.tu-berlin.de/~jutta/toast.html
29
30 #include "avcodec.h"
31 #include <gsm/gsm.h>
32
33 // gsm.h misses some essential constants
34 #define GSM_BLOCK_SIZE 33
35 #define GSM_MS_BLOCK_SIZE 65
36 #define GSM_FRAME_SIZE 160
37
38 static av_cold int libgsm_encode_init(AVCodecContext *avctx) {
39     if (avctx->channels > 1) {
40         av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n",
41                avctx->channels);
42         return -1;
43     }
44
45     if (avctx->sample_rate != 8000) {
46         av_log(avctx, AV_LOG_ERROR, "Sample rate 8000Hz required for GSM, got %dHz\n",
47                avctx->sample_rate);
48         if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)
49             return -1;
50     }
51     if (avctx->bit_rate != 13000 /* Official */ &&
52         avctx->bit_rate != 13200 /* Very common */ &&
53         avctx->bit_rate != 0 /* Unknown; a.o. mov does not set bitrate when decoding */ ) {
54         av_log(avctx, AV_LOG_ERROR, "Bitrate 13000bps required for GSM, got %dbps\n",
55                avctx->bit_rate);
56         if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)
57             return -1;
58     }
59
60     avctx->priv_data = gsm_create();
61
62     switch(avctx->codec_id) {
63     case CODEC_ID_GSM:
64         avctx->frame_size = GSM_FRAME_SIZE;
65         avctx->block_align = GSM_BLOCK_SIZE;
66         break;
67     case CODEC_ID_GSM_MS: {
68         int one = 1;
69         gsm_option(avctx->priv_data, GSM_OPT_WAV49, &one);
70         avctx->frame_size = 2*GSM_FRAME_SIZE;
71         avctx->block_align = GSM_MS_BLOCK_SIZE;
72         }
73     }
74
75     avctx->coded_frame= avcodec_alloc_frame();
76     avctx->coded_frame->key_frame= 1;
77
78     return 0;
79 }
80
81 static av_cold int libgsm_encode_close(AVCodecContext *avctx) {
82     av_freep(&avctx->coded_frame);
83     gsm_destroy(avctx->priv_data);
84     avctx->priv_data = NULL;
85     return 0;
86 }
87
88 static int libgsm_encode_frame(AVCodecContext *avctx,
89                                unsigned char *frame, int buf_size, void *data) {
90     // we need a full block
91     if(buf_size < avctx->block_align) return 0;
92
93     switch(avctx->codec_id) {
94     case CODEC_ID_GSM:
95         gsm_encode(avctx->priv_data,data,frame);
96         break;
97     case CODEC_ID_GSM_MS:
98         gsm_encode(avctx->priv_data,data,frame);
99         gsm_encode(avctx->priv_data,((short*)data)+GSM_FRAME_SIZE,frame+32);
100     }
101     return avctx->block_align;
102 }
103
104
105 AVCodec ff_libgsm_encoder = {
106     .name           = "libgsm",
107     .type           = AVMEDIA_TYPE_AUDIO,
108     .id             = CODEC_ID_GSM,
109     .init           = libgsm_encode_init,
110     .encode         = libgsm_encode_frame,
111     .close          = libgsm_encode_close,
112     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
113     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
114 };
115
116 AVCodec ff_libgsm_ms_encoder = {
117     .name           = "libgsm_ms",
118     .type           = AVMEDIA_TYPE_AUDIO,
119     .id             = CODEC_ID_GSM_MS,
120     .init           = libgsm_encode_init,
121     .encode         = libgsm_encode_frame,
122     .close          = libgsm_encode_close,
123     .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
124     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
125 };
126
127 typedef struct LibGSMDecodeContext {
128     AVFrame frame;
129     struct gsm_state *state;
130 } LibGSMDecodeContext;
131
132 static av_cold int libgsm_decode_init(AVCodecContext *avctx) {
133     LibGSMDecodeContext *s = avctx->priv_data;
134
135     if (avctx->channels > 1) {
136         av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n",
137                avctx->channels);
138         return -1;
139     }
140
141     if (!avctx->channels)
142         avctx->channels = 1;
143
144     if (!avctx->sample_rate)
145         avctx->sample_rate = 8000;
146
147     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
148
149     s->state = gsm_create();
150
151     switch(avctx->codec_id) {
152     case CODEC_ID_GSM:
153         avctx->frame_size  = GSM_FRAME_SIZE;
154         avctx->block_align = GSM_BLOCK_SIZE;
155         break;
156     case CODEC_ID_GSM_MS: {
157         int one = 1;
158         gsm_option(s->state, GSM_OPT_WAV49, &one);
159         avctx->frame_size  = 2 * GSM_FRAME_SIZE;
160         avctx->block_align = GSM_MS_BLOCK_SIZE;
161         }
162     }
163
164     avcodec_get_frame_defaults(&s->frame);
165     avctx->coded_frame = &s->frame;
166
167     return 0;
168 }
169
170 static av_cold int libgsm_decode_close(AVCodecContext *avctx) {
171     LibGSMDecodeContext *s = avctx->priv_data;
172
173     gsm_destroy(s->state);
174     s->state = NULL;
175     return 0;
176 }
177
178 static int libgsm_decode_frame(AVCodecContext *avctx, void *data,
179                                int *got_frame_ptr, AVPacket *avpkt)
180 {
181     int i, ret;
182     LibGSMDecodeContext *s = avctx->priv_data;
183     uint8_t *buf = avpkt->data;
184     int buf_size = avpkt->size;
185     int16_t *samples;
186
187     if (buf_size < avctx->block_align) {
188         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
189         return AVERROR_INVALIDDATA;
190     }
191
192     /* get output buffer */
193     s->frame.nb_samples = avctx->frame_size;
194     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
195         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
196         return ret;
197     }
198     samples = (int16_t *)s->frame.data[0];
199
200     for (i = 0; i < avctx->frame_size / GSM_FRAME_SIZE; i++) {
201         if ((ret = gsm_decode(s->state, buf, samples)) < 0)
202             return -1;
203         buf     += GSM_BLOCK_SIZE;
204         samples += GSM_FRAME_SIZE;
205     }
206
207     *got_frame_ptr   = 1;
208     *(AVFrame *)data = s->frame;
209
210     return avctx->block_align;
211 }
212
213 static void libgsm_flush(AVCodecContext *avctx) {
214     LibGSMDecodeContext *s = avctx->priv_data;
215     int one = 1;
216
217     gsm_destroy(s->state);
218     s->state = gsm_create();
219     if (avctx->codec_id == CODEC_ID_GSM_MS)
220         gsm_option(s->state, GSM_OPT_WAV49, &one);
221 }
222
223 AVCodec ff_libgsm_decoder = {
224     .name           = "libgsm",
225     .type           = AVMEDIA_TYPE_AUDIO,
226     .id             = CODEC_ID_GSM,
227     .priv_data_size = sizeof(LibGSMDecodeContext),
228     .init           = libgsm_decode_init,
229     .close          = libgsm_decode_close,
230     .decode         = libgsm_decode_frame,
231     .flush          = libgsm_flush,
232     .capabilities   = CODEC_CAP_DR1,
233     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
234 };
235
236 AVCodec ff_libgsm_ms_decoder = {
237     .name           = "libgsm_ms",
238     .type           = AVMEDIA_TYPE_AUDIO,
239     .id             = CODEC_ID_GSM_MS,
240     .priv_data_size = sizeof(LibGSMDecodeContext),
241     .init           = libgsm_decode_init,
242     .close          = libgsm_decode_close,
243     .decode         = libgsm_decode_frame,
244     .flush          = libgsm_flush,
245     .capabilities   = CODEC_CAP_DR1,
246     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
247 };