Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

cosmetics: K&R coding style, indent correctly, break overly long lines

Browse Source 
Originally committed as revision 18850 to svn://svn.ffmpeg.org/ffmpeg/trunk
release/0.6
Diego Biurrun 16 years ago
parent e0c1e12a62
commit d8ed5bae6f
1 changed files with 102 additions and 120 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 222
      libavcodec/libamr.c

222
libavcodec/libamr.c
Unescape View File

@ -66,9 +66,8 @@ static const char wb_bitrate_unsupported[] =
"bitrate not supported: use one of 6.6k, 8.85k, 12.65k, 14.25k, 15.85k, 18.25k, 19.85k, 23.05k, or 23.85k\n";
/* Common code for fixed and float version*/
typedef struct AMR_bitrates
{
int rate;
typedef struct AMR_bitrates {
int rate;
enum Mode mode;
} AMR_bitrates;
@ -76,32 +75,31 @@ typedef struct AMR_bitrates
static int getBitrateMode(int bitrate)
{
/* make the correspondance between bitrate and mode */
AMR_bitrates rates[]={ {4750,MR475},
{5150,MR515},
{5900,MR59},
{6700,MR67},
{7400,MR74},
{7950,MR795},
{10200,MR102},
{12200,MR122},
};
AMR_bitrates rates[] = { { 4750, MR475},
{ 5150, MR515},
{ 5900, MR59},
{ 6700, MR67},
{ 7400, MR74},
{ 7950, MR795},
{10200, MR102},
{12200, MR122}, };
int i;
for(i=0;i<8;i++)
if(rates[i].rate==bitrate)
for (i = 0; i < 8; i++)
if (rates[i].rate == bitrate)
return rates[i].mode;
/* no bitrate matching, return an error */
return -1;
}
static void amr_decode_fix_avctx(AVCodecContext * avctx)
static void amr_decode_fix_avctx(AVCodecContext *avctx)
{
const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
if(!avctx->sample_rate)
if (!avctx->sample_rate)
avctx->sample_rate = 8000 * is_amr_wb;
if(!avctx->channels)
if (!avctx->channels)
avctx->channels = 1;
avctx->frame_size = 160 * is_amr_wb;
@ -111,28 +109,26 @@ static void amr_decode_fix_avctx(AVCodecContext * avctx)
#if CONFIG_LIBAMR_NB
typedef struct AMRContext {
int frameCount;
void * decState;
int *enstate;
int enc_bitrate;
int frameCount;
void *decState;
int *enstate;
int enc_bitrate;
} AMRContext;
static av_cold int amr_nb_decode_init(AVCodecContext * avctx)
static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
{
AMRContext *s = avctx->priv_data;
s->frameCount=0;
s->decState=Decoder_Interface_init();
if(!s->decState)
{
s->frameCount = 0;
s->decState = Decoder_Interface_init();
if (!s->decState) {
av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
return -1;
}
amr_decode_fix_avctx(avctx);
if(avctx->channels > 1)
{
if (avctx->channels > 1) {
av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
return -1;
}
@ -140,7 +136,7 @@ static av_cold int amr_nb_decode_init(AVCodecContext * avctx)
return 0;
}
static av_cold int amr_nb_decode_close(AVCodecContext * avctx)
static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
{
AMRContext *s = avctx->priv_data;
@ -148,39 +144,40 @@ static av_cold int amr_nb_decode_close(AVCodecContext * avctx)
return 0;
}
static int amr_nb_decode_frame(AVCodecContext * avctx,
void *data, int *data_size,
AVPacket *avpkt)
static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int buf_size = avpkt->size;
AMRContext *s = avctx->priv_data;
const uint8_t*amrData=buf;
static const uint8_t block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
const uint8_t *amrData = buf;
static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
enum Mode dec_mode;
int packet_size;
/* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */
/* av_log(NULL, AV_LOG_DEBUG, "amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",
buf, buf_size, s->frameCount); */
dec_mode = (buf[0] >> 3) & 0x000F;
packet_size = block_size[dec_mode]+1;
packet_size = block_size[dec_mode] + 1;
if(packet_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
if (packet_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
buf_size, packet_size);
return -1;
}
s->frameCount++;
/* av_log(NULL,AV_LOG_DEBUG,"packet_size=%d amrData= 0x%X %X %X %X\n",packet_size,amrData[0],amrData[1],amrData[2],amrData[3]); */
/* av_log(NULL, AV_LOG_DEBUG, "packet_size=%d amrData= 0x%X %X %X %X\n",
packet_size, amrData[0], amrData[1], amrData[2], amrData[3]); */
/* call decoder */
Decoder_Interface_Decode(s->decState, amrData, data, 0);
*data_size=160*2;
*data_size = 160 * 2;
return packet_size;
}
AVCodec libamr_nb_decoder =
{
AVCodec libamr_nb_decoder = {
"libamr_nb",
CODEC_TYPE_AUDIO,
CODEC_ID_AMR_NB,
@ -192,36 +189,32 @@ AVCodec libamr_nb_decoder =
.long_name = NULL_IF_CONFIG_SMALL("libamr-nb Adaptive Multi-Rate (AMR) Narrow-Band"),
};
static av_cold int amr_nb_encode_init(AVCodecContext * avctx)
static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
{
AMRContext *s = avctx->priv_data;
s->frameCount=0;
s->frameCount = 0;
if(avctx->sample_rate!=8000)
{
if (avctx->sample_rate != 8000) {
av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
return -1;
}
if(avctx->channels!=1)
{
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
return -1;
}
avctx->frame_size=160;
avctx->coded_frame= avcodec_alloc_frame();
avctx->frame_size = 160;
avctx->coded_frame = avcodec_alloc_frame();
s->enstate=Encoder_Interface_init(0);
if(!s->enstate)
{
if (!s->enstate) {
av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
return -1;
}
if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
{
if ((s->enc_bitrate = getBitrateMode(avctx->bit_rate)) < 0) {
av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
return -1;
}
@ -229,7 +222,7 @@ static av_cold int amr_nb_encode_init(AVCodecContext * avctx)
return 0;
}
static av_cold int amr_nb_encode_close(AVCodecContext * avctx)
static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
{
AMRContext *s = avctx->priv_data;
@ -239,29 +232,26 @@ static av_cold int amr_nb_encode_close(AVCodecContext * avctx)
}
static int amr_nb_encode_frame(AVCodecContext *avctx,
unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
unsigned char *frame/*out*/,
int buf_size, void *data/*in*/)
{
AMRContext *s = avctx->priv_data;
int written;
if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
{
if ((s->enc_bitrate = getBitrateMode(avctx->bit_rate)) < 0) {
av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
return -1;
}
written = Encoder_Interface_Encode(s->enstate,
s->enc_bitrate,
data,
frame,
0);
/* av_log(NULL,AV_LOG_DEBUG,"amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",written, s->enc_bitrate, frame[0] ); */
written = Encoder_Interface_Encode(s->enstate, s->enc_bitrate, data,
frame, 0);
/* av_log(NULL, AV_LOG_DEBUG, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
written, s->enc_bitrate, frame[0] ); */
return written;
}
AVCodec libamr_nb_encoder =
{
AVCodec libamr_nb_encoder = {
"libamr_nb",
CODEC_TYPE_AUDIO,
CODEC_ID_AMR_NB,
@ -288,16 +278,15 @@ AVCodec libamr_nb_encoder =
#include <amrwb/if_rom.h>
/* Common code for fixed and float version*/
typedef struct AMRWB_bitrates
{
typedef struct AMRWB_bitrates {
int rate;
int mode;
} AMRWB_bitrates;
typedef struct AMRWBContext {
int frameCount;
void *state;
int mode;
int frameCount;
void *state;
int mode;
Word16 allow_dtx;
} AMRWBContext;
@ -308,59 +297,55 @@ typedef struct AMRWBContext {
static int getWBBitrateMode(int bitrate)
{
/* make the correspondance between bitrate and mode */
AMRWB_bitrates rates[]={ {6600,0},
{8850,1},
{12650,2},
{14250,3},
{15850,4},
{18250,5},
{19850,6},
{23050,7},
{23850,8},
};
AMRWB_bitrates rates[] = { { 6600, 0},
{ 8850, 1},
{12650, 2},
{14250, 3},
{15850, 4},
{18250, 5},
{19850, 6},
{23050, 7},
{23850, 8}, };
int i;
for(i=0;i<9;i++)
if(rates[i].rate==bitrate)
for (i = 0; i < 9; i++)
if (rates[i].rate == bitrate)
return rates[i].mode;
/* no bitrate matching, return an error */
return -1;
}
static av_cold int amr_wb_encode_init(AVCodecContext * avctx)
static av_cold int amr_wb_encode_init(AVCodecContext *avctx)
{
AMRWBContext *s = avctx->priv_data;
s->frameCount=0;
s->frameCount = 0;
if(avctx->sample_rate!=16000)
{
if (avctx->sample_rate != 16000) {
av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
return -1;
}
if(avctx->channels!=1)
{
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
return -1;
}
if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
{
if ((s->mode = getWBBitrateMode(avctx->bit_rate)) < 0) {
av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
return -1;
}
avctx->frame_size=320;
avctx->coded_frame= avcodec_alloc_frame();
avctx->frame_size = 320;
avctx->coded_frame = avcodec_alloc_frame();
s->state = E_IF_init();
s->allow_dtx=0;
s->state = E_IF_init();
s->allow_dtx = 0;
return 0;
}
static int amr_wb_encode_close(AVCodecContext * avctx)
static int amr_wb_encode_close(AVCodecContext *avctx)
{
AMRWBContext *s = avctx->priv_data;
@ -371,13 +356,13 @@ static int amr_wb_encode_close(AVCodecContext * avctx)
}
static int amr_wb_encode_frame(AVCodecContext *avctx,
unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
unsigned char *frame/*out*/,
int buf_size, void *data/*in*/)
{
AMRWBContext *s = avctx->priv_data;
int size;
if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
{
if ((s->mode = getWBBitrateMode(avctx->bit_rate)) < 0) {
av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
return -1;
}
@ -385,8 +370,7 @@ static int amr_wb_encode_frame(AVCodecContext *avctx,
return size;
}
AVCodec libamr_wb_encoder =
{
AVCodec libamr_wb_encoder = {
"libamr_wb",
CODEC_TYPE_AUDIO,
CODEC_ID_AMR_WB,
@ -401,17 +385,16 @@ AVCodec libamr_wb_encoder =
#endif
static av_cold int amr_wb_decode_init(AVCodecContext * avctx)
static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
{
AMRWBContext *s = avctx->priv_data;
s->frameCount=0;
s->state = D_IF_init();
s->frameCount = 0;
s->state = D_IF_init();
amr_decode_fix_avctx(avctx);
if(avctx->channels > 1)
{
if (avctx->channels > 1) {
av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
return -1;
}
@ -419,37 +402,37 @@ static av_cold int amr_wb_decode_init(AVCodecContext * avctx)
return 0;
}
static int amr_wb_decode_frame(AVCodecContext * avctx,
void *data, int *data_size,
AVPacket *avpkt)
static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int buf_size = avpkt->size;
AMRWBContext *s = avctx->priv_data;
const uint8_t*amrData=buf;
const uint8_t *amrData = buf;
int mode;
int packet_size;
static const uint8_t block_size[16] = {18, 23, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
if(!buf_size)
if (!buf_size)
/* nothing to do */
return 0;
mode = (amrData[0] >> 3) & 0x000F;
packet_size = block_size[mode];
if(packet_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
if (packet_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
buf_size, packet_size + 1);
return -1;
}
s->frameCount++;
D_IF_decode( s->state, amrData, data, _good_frame);
*data_size=320*2;
D_IF_decode(s->state, amrData, data, _good_frame);
*data_size = 320 * 2;
return packet_size;
}
static int amr_wb_decode_close(AVCodecContext * avctx)
static int amr_wb_decode_close(AVCodecContext *avctx)
{
AMRWBContext *s = avctx->priv_data;
@ -457,8 +440,7 @@ static int amr_wb_decode_close(AVCodecContext * avctx)
return 0;
}
AVCodec libamr_wb_decoder =
{
AVCodec libamr_wb_decoder = {
"libamr_wb",
CODEC_TYPE_AUDIO,
CODEC_ID_AMR_WB,

Write Preview
Loading…
Cancel
Save