cosmetics: reindent and pretty-print
[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 static av_cold int libgsm_decode_init(AVCodecContext *avctx) {
128     if (avctx->channels > 1) {
129         av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n",
130                avctx->channels);
131         return -1;
132     }
133
134     if (!avctx->channels)
135         avctx->channels = 1;
136
137     if (!avctx->sample_rate)
138         avctx->sample_rate = 8000;
139
140     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
141
142     avctx->priv_data = gsm_create();
143
144     switch(avctx->codec_id) {
145     case CODEC_ID_GSM:
146         avctx->frame_size  = GSM_FRAME_SIZE;
147         avctx->block_align = GSM_BLOCK_SIZE;
148         break;
149     case CODEC_ID_GSM_MS: {
150         int one = 1;
151         gsm_option(avctx->priv_data, GSM_OPT_WAV49, &one);
152         avctx->frame_size  = 2 * GSM_FRAME_SIZE;
153         avctx->block_align = GSM_MS_BLOCK_SIZE;
154         }
155     }
156
157     return 0;
158 }
159
160 static av_cold int libgsm_decode_close(AVCodecContext *avctx) {
161     gsm_destroy(avctx->priv_data);
162     avctx->priv_data = NULL;
163     return 0;
164 }
165
166 static int libgsm_decode_frame(AVCodecContext *avctx,
167                                void *data, int *data_size,
168                                AVPacket *avpkt) {
169     uint8_t *buf = avpkt->data;
170     int buf_size = avpkt->size;
171     *data_size = 0; /* In case of error */
172     if(buf_size < avctx->block_align) return -1;
173     switch(avctx->codec_id) {
174     case CODEC_ID_GSM:
175         if(gsm_decode(avctx->priv_data,buf,data)) return -1;
176         *data_size = GSM_FRAME_SIZE*sizeof(int16_t);
177         break;
178     case CODEC_ID_GSM_MS:
179         if(gsm_decode(avctx->priv_data,buf,data) ||
180            gsm_decode(avctx->priv_data,buf+33,((int16_t*)data)+GSM_FRAME_SIZE)) return -1;
181         *data_size = GSM_FRAME_SIZE*sizeof(int16_t)*2;
182     }
183     return avctx->block_align;
184 }
185
186 AVCodec ff_libgsm_decoder = {
187     .name           = "libgsm",
188     .type           = AVMEDIA_TYPE_AUDIO,
189     .id             = CODEC_ID_GSM,
190     .init           = libgsm_decode_init,
191     .close          = libgsm_decode_close,
192     .decode         = libgsm_decode_frame,
193     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
194 };
195
196 AVCodec ff_libgsm_ms_decoder = {
197     .name           = "libgsm_ms",
198     .type           = AVMEDIA_TYPE_AUDIO,
199     .id             = CODEC_ID_GSM_MS,
200     .init           = libgsm_decode_init,
201     .close          = libgsm_decode_close,
202     .decode         = libgsm_decode_frame,
203     .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
204 };