← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libav/oneiric

« back to all changes in this revision

Viewing changes to libavcodec/libgsm.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 12:09:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110320120931-nfhi9tiok27gxhw1
Tags: upstream-0.6.2
Import upstream version 0.6.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 FFmpeg.
 
7
 *
 
8
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; 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_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->codec->decode){
 
46
        if(!avctx->channels)
 
47
            avctx->channels= 1;
 
48
 
 
49
        if(!avctx->sample_rate)
 
50
            avctx->sample_rate= 8000;
 
51
 
 
52
        avctx->sample_fmt = SAMPLE_FMT_S16;
 
53
    }else{
 
54
        if (avctx->sample_rate != 8000) {
 
55
            av_log(avctx, AV_LOG_ERROR, "Sample rate 8000Hz required for GSM, got %dHz\n",
 
56
                avctx->sample_rate);
 
57
            if(avctx->strict_std_compliance > FF_COMPLIANCE_INOFFICIAL)
 
58
                return -1;
 
59
        }
 
60
        if (avctx->bit_rate != 13000 /* Official */ &&
 
61
            avctx->bit_rate != 13200 /* Very common */ &&
 
62
            avctx->bit_rate != 0 /* Unknown; a.o. mov does not set bitrate when decoding */ ) {
 
63
            av_log(avctx, AV_LOG_ERROR, "Bitrate 13000bps required for GSM, got %dbps\n",
 
64
                avctx->bit_rate);
 
65
            if(avctx->strict_std_compliance > FF_COMPLIANCE_INOFFICIAL)
 
66
                return -1;
 
67
        }
 
68
    }
 
69
 
 
70
    avctx->priv_data = gsm_create();
 
71
 
 
72
    switch(avctx->codec_id) {
 
73
    case CODEC_ID_GSM:
 
74
        avctx->frame_size = GSM_FRAME_SIZE;
 
75
        avctx->block_align = GSM_BLOCK_SIZE;
 
76
        break;
 
77
    case CODEC_ID_GSM_MS: {
 
78
        int one = 1;
 
79
        gsm_option(avctx->priv_data, GSM_OPT_WAV49, &one);
 
80
        avctx->frame_size = 2*GSM_FRAME_SIZE;
 
81
        avctx->block_align = GSM_MS_BLOCK_SIZE;
 
82
        }
 
83
    }
 
84
 
 
85
    avctx->coded_frame= avcodec_alloc_frame();
 
86
    avctx->coded_frame->key_frame= 1;
 
87
 
 
88
    return 0;
 
89
}
 
90
 
 
91
static av_cold int libgsm_close(AVCodecContext *avctx) {
 
92
    av_freep(&avctx->coded_frame);
 
93
    gsm_destroy(avctx->priv_data);
 
94
    avctx->priv_data = NULL;
 
95
    return 0;
 
96
}
 
97
 
 
98
static int libgsm_encode_frame(AVCodecContext *avctx,
 
99
                               unsigned char *frame, int buf_size, void *data) {
 
100
    // we need a full block
 
101
    if(buf_size < avctx->block_align) return 0;
 
102
 
 
103
    switch(avctx->codec_id) {
 
104
    case CODEC_ID_GSM:
 
105
        gsm_encode(avctx->priv_data,data,frame);
 
106
        break;
 
107
    case CODEC_ID_GSM_MS:
 
108
        gsm_encode(avctx->priv_data,data,frame);
 
109
        gsm_encode(avctx->priv_data,((short*)data)+GSM_FRAME_SIZE,frame+32);
 
110
    }
 
111
    return avctx->block_align;
 
112
}
 
113
 
 
114
 
 
115
AVCodec libgsm_encoder = {
 
116
    "libgsm",
 
117
    AVMEDIA_TYPE_AUDIO,
 
118
    CODEC_ID_GSM,
 
119
    0,
 
120
    libgsm_init,
 
121
    libgsm_encode_frame,
 
122
    libgsm_close,
 
123
    .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
 
124
    .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
 
125
};
 
126
 
 
127
AVCodec libgsm_ms_encoder = {
 
128
    "libgsm_ms",
 
129
    AVMEDIA_TYPE_AUDIO,
 
130
    CODEC_ID_GSM_MS,
 
131
    0,
 
132
    libgsm_init,
 
133
    libgsm_encode_frame,
 
134
    libgsm_close,
 
135
    .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
 
136
    .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
 
137
};
 
138
 
 
139
static int libgsm_decode_frame(AVCodecContext *avctx,
 
140
                               void *data, int *data_size,
 
141
                               AVPacket *avpkt) {
 
142
    const uint8_t *buf = avpkt->data;
 
143
    int buf_size = avpkt->size;
 
144
    *data_size = 0; /* In case of error */
 
145
    if(buf_size < avctx->block_align) return -1;
 
146
    switch(avctx->codec_id) {
 
147
    case CODEC_ID_GSM:
 
148
        if(gsm_decode(avctx->priv_data,buf,data)) return -1;
 
149
        *data_size = GSM_FRAME_SIZE*sizeof(int16_t);
 
150
        break;
 
151
    case CODEC_ID_GSM_MS:
 
152
        if(gsm_decode(avctx->priv_data,buf,data) ||
 
153
           gsm_decode(avctx->priv_data,buf+33,((int16_t*)data)+GSM_FRAME_SIZE)) return -1;
 
154
        *data_size = GSM_FRAME_SIZE*sizeof(int16_t)*2;
 
155
    }
 
156
    return avctx->block_align;
 
157
}
 
158
 
 
159
AVCodec libgsm_decoder = {
 
160
    "libgsm",
 
161
    AVMEDIA_TYPE_AUDIO,
 
162
    CODEC_ID_GSM,
 
163
    0,
 
164
    libgsm_init,
 
165
    NULL,
 
166
    libgsm_close,
 
167
    libgsm_decode_frame,
 
168
    .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
 
169
};
 
170
 
 
171
AVCodec libgsm_ms_decoder = {
 
172
    "libgsm_ms",
 
173
    AVMEDIA_TYPE_AUDIO,
 
174
    CODEC_ID_GSM_MS,
 
175
    0,
 
176
    libgsm_init,
 
177
    NULL,
 
178
    libgsm_close,
 
179
    libgsm_decode_frame,
 
180
    .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
 
181
};