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
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 200
      libavcodec/libamr.c

200
libavcodec/libamr.c
Unescape View File

@ -66,8 +66,7 @@ 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"; "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*/ /* Common code for fixed and float version*/
typedef struct AMR_bitrates typedef struct AMR_bitrates {
{
int rate; int rate;
enum Mode mode; enum Mode mode;
} AMR_bitrates; } AMR_bitrates;
@ -76,32 +75,31 @@ typedef struct AMR_bitrates
static int getBitrateMode(int bitrate) static int getBitrateMode(int bitrate)
{ {
/* make the correspondance between bitrate and mode */ /* make the correspondance between bitrate and mode */
AMR_bitrates rates[]={ {4750,MR475}, AMR_bitrates rates[] = { { 4750, MR475},
{5150,MR515}, { 5150, MR515},
{5900,MR59}, { 5900, MR59},
{6700,MR67}, { 6700, MR67},
{7400,MR74}, { 7400, MR74},
{7950,MR795}, { 7950, MR795},
{10200,MR102}, {10200, MR102},
{12200,MR122}, {12200, MR122}, };
};
int i; int i;
for(i=0;i<8;i++) for (i = 0; i < 8; i++)
if(rates[i].rate==bitrate) if (rates[i].rate == bitrate)
return rates[i].mode; return rates[i].mode;
/* no bitrate matching, return an error */ /* no bitrate matching, return an error */
return -1; 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); 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; avctx->sample_rate = 8000 * is_amr_wb;
if(!avctx->channels) if (!avctx->channels)
avctx->channels = 1; avctx->channels = 1;
avctx->frame_size = 160 * is_amr_wb; avctx->frame_size = 160 * is_amr_wb;
@ -112,27 +110,25 @@ static void amr_decode_fix_avctx(AVCodecContext * avctx)
typedef struct AMRContext { typedef struct AMRContext {
int frameCount; int frameCount;
void * decState; void *decState;
int *enstate; int *enstate;
int enc_bitrate; int enc_bitrate;
} AMRContext; } 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; AMRContext *s = avctx->priv_data;
s->frameCount=0; s->frameCount = 0;
s->decState=Decoder_Interface_init(); s->decState = Decoder_Interface_init();
if(!s->decState) if (!s->decState) {
{
av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n"); av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
return -1; return -1;
} }
amr_decode_fix_avctx(avctx); 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"); av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
return -1; return -1;
} }
@ -140,7 +136,7 @@ static av_cold int amr_nb_decode_init(AVCodecContext * avctx)
return 0; 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; AMRContext *s = avctx->priv_data;
@ -148,39 +144,40 @@ static av_cold int amr_nb_decode_close(AVCodecContext * avctx)
return 0; return 0;
} }
static int amr_nb_decode_frame(AVCodecContext * avctx, static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
void *data, int *data_size, int *data_size, AVPacket *avpkt)
AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
AMRContext *s = avctx->priv_data; AMRContext *s = avctx->priv_data;
const uint8_t*amrData=buf; 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 }; 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; enum Mode dec_mode;
int packet_size; 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; 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) { if (packet_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size); av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
buf_size, packet_size);
return -1; return -1;
} }
s->frameCount++; 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 */ /* call decoder */
Decoder_Interface_Decode(s->decState, amrData, data, 0); Decoder_Interface_Decode(s->decState, amrData, data, 0);
*data_size=160*2; *data_size = 160 * 2;
return packet_size; return packet_size;
} }
AVCodec libamr_nb_decoder = AVCodec libamr_nb_decoder = {
{
"libamr_nb", "libamr_nb",
CODEC_TYPE_AUDIO, CODEC_TYPE_AUDIO,
CODEC_ID_AMR_NB, 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"), .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; 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"); av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
return -1; return -1;
} }
if(avctx->channels!=1) if (avctx->channels != 1) {
{
av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
return -1; return -1;
} }
avctx->frame_size=160; avctx->frame_size = 160;
avctx->coded_frame= avcodec_alloc_frame(); avctx->coded_frame = avcodec_alloc_frame();
s->enstate=Encoder_Interface_init(0); s->enstate=Encoder_Interface_init(0);
if(!s->enstate) if (!s->enstate) {
{
av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n"); av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
return -1; 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); av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
return -1; return -1;
} }
@ -229,7 +222,7 @@ static av_cold int amr_nb_encode_init(AVCodecContext * avctx)
return 0; 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; 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, 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; AMRContext *s = avctx->priv_data;
int written; 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); av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
return -1; return -1;
} }
written = Encoder_Interface_Encode(s->enstate, written = Encoder_Interface_Encode(s->enstate, s->enc_bitrate, data,
s->enc_bitrate, frame, 0);
data, /* av_log(NULL, AV_LOG_DEBUG, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
frame, written, s->enc_bitrate, frame[0] ); */
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; return written;
} }
AVCodec libamr_nb_encoder = AVCodec libamr_nb_encoder = {
{
"libamr_nb", "libamr_nb",
CODEC_TYPE_AUDIO, CODEC_TYPE_AUDIO,
CODEC_ID_AMR_NB, CODEC_ID_AMR_NB,
@ -288,8 +278,7 @@ AVCodec libamr_nb_encoder =
#include <amrwb/if_rom.h> #include <amrwb/if_rom.h>
/* Common code for fixed and float version*/ /* Common code for fixed and float version*/
typedef struct AMRWB_bitrates typedef struct AMRWB_bitrates {
{
int rate; int rate;
int mode; int mode;
} AMRWB_bitrates; } AMRWB_bitrates;
@ -308,59 +297,55 @@ typedef struct AMRWBContext {
static int getWBBitrateMode(int bitrate) static int getWBBitrateMode(int bitrate)
{ {
/* make the correspondance between bitrate and mode */ /* make the correspondance between bitrate and mode */
AMRWB_bitrates rates[]={ {6600,0}, AMRWB_bitrates rates[] = { { 6600, 0},
{8850,1}, { 8850, 1},
{12650,2}, {12650, 2},
{14250,3}, {14250, 3},
{15850,4}, {15850, 4},
{18250,5}, {18250, 5},
{19850,6}, {19850, 6},
{23050,7}, {23050, 7},
{23850,8}, {23850, 8}, };
};
int i; int i;
for(i=0;i<9;i++) for (i = 0; i < 9; i++)
if(rates[i].rate==bitrate) if (rates[i].rate == bitrate)
return rates[i].mode; return rates[i].mode;
/* no bitrate matching, return an error */ /* no bitrate matching, return an error */
return -1; 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; 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"); av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
return -1; return -1;
} }
if(avctx->channels!=1) if (avctx->channels != 1) {
{
av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
return -1; 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); av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
return -1; return -1;
} }
avctx->frame_size=320; avctx->frame_size = 320;
avctx->coded_frame= avcodec_alloc_frame(); avctx->coded_frame = avcodec_alloc_frame();
s->state = E_IF_init(); s->state = E_IF_init();
s->allow_dtx=0; s->allow_dtx = 0;
return 0; return 0;
} }
static int amr_wb_encode_close(AVCodecContext * avctx) static int amr_wb_encode_close(AVCodecContext *avctx)
{ {
AMRWBContext *s = avctx->priv_data; 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, 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; AMRWBContext *s = avctx->priv_data;
int size; 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); av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
return -1; return -1;
} }
@ -385,8 +370,7 @@ static int amr_wb_encode_frame(AVCodecContext *avctx,
return size; return size;
} }
AVCodec libamr_wb_encoder = AVCodec libamr_wb_encoder = {
{
"libamr_wb", "libamr_wb",
CODEC_TYPE_AUDIO, CODEC_TYPE_AUDIO,
CODEC_ID_AMR_WB, CODEC_ID_AMR_WB,
@ -401,17 +385,16 @@ AVCodec libamr_wb_encoder =
#endif #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; AMRWBContext *s = avctx->priv_data;
s->frameCount=0; s->frameCount = 0;
s->state = D_IF_init(); s->state = D_IF_init();
amr_decode_fix_avctx(avctx); 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"); av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
return -1; return -1;
} }
@ -419,37 +402,37 @@ static av_cold int amr_wb_decode_init(AVCodecContext * avctx)
return 0; return 0;
} }
static int amr_wb_decode_frame(AVCodecContext * avctx, static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
void *data, int *data_size, int *data_size, AVPacket *avpkt)
AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
AMRWBContext *s = avctx->priv_data; AMRWBContext *s = avctx->priv_data;
const uint8_t*amrData=buf; const uint8_t *amrData = buf;
int mode; int mode;
int packet_size; 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}; 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 */ /* nothing to do */
return 0; return 0;
mode = (amrData[0] >> 3) & 0x000F; mode = (amrData[0] >> 3) & 0x000F;
packet_size = block_size[mode]; packet_size = block_size[mode];
if(packet_size > buf_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+1); av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
buf_size, packet_size + 1);
return -1; return -1;
} }
s->frameCount++; s->frameCount++;
D_IF_decode( s->state, amrData, data, _good_frame); D_IF_decode(s->state, amrData, data, _good_frame);
*data_size=320*2; *data_size = 320 * 2;
return packet_size; return packet_size;
} }
static int amr_wb_decode_close(AVCodecContext * avctx) static int amr_wb_decode_close(AVCodecContext *avctx)
{ {
AMRWBContext *s = avctx->priv_data; AMRWBContext *s = avctx->priv_data;
@ -457,8 +440,7 @@ static int amr_wb_decode_close(AVCodecContext * avctx)
return 0; return 0;
} }
AVCodec libamr_wb_decoder = AVCodec libamr_wb_decoder = {
{
"libamr_wb", "libamr_wb",
CODEC_TYPE_AUDIO, CODEC_TYPE_AUDIO,
CODEC_ID_AMR_WB, CODEC_ID_AMR_WB,

Write Preview
Loading…
Cancel
Save