adpcmenc: cosmetics: pretty-printing

Signed-off-by: Justin Ruggles <justin.ruggles@gmail.com>

1 files changed, 264 insertions, 229 deletions

diff --git a/libavcodec/adpcmenc.c b/libavcodec/adpcmenc.c
index 7027e373dc..9697f829d2 100644
--- a/libavcodec/adpcmenc.c
+++ b/libavcodec/adpcmenc.c
@@ -66,37 +66,46 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
     if (avctx->channels > 2)
         return -1; /* only stereo or mono =) */
 
-    if(avctx->trellis && (unsigned)avctx->trellis > 16U){
+    if (avctx->trellis && (unsigned)avctx->trellis > 16U) {
         av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n");
         return -1;
     }
 
     if (avctx->trellis) {
-        int frontier = 1 << avctx->trellis;
+        int frontier  = 1 << avctx->trellis;
         int max_paths =  frontier * FREEZE_INTERVAL;
-        FF_ALLOC_OR_GOTO(avctx, s->paths,     max_paths * sizeof(*s->paths), error);
-        FF_ALLOC_OR_GOTO(avctx, s->node_buf,  2 * frontier * sizeof(*s->node_buf), error);
-        FF_ALLOC_OR_GOTO(avctx, s->nodep_buf, 2 * frontier * sizeof(*s->nodep_buf), error);
-        FF_ALLOC_OR_GOTO(avctx, s->trellis_hash, 65536 * sizeof(*s->trellis_hash), error);
+        FF_ALLOC_OR_GOTO(avctx, s->paths,
+                         max_paths * sizeof(*s->paths), error);
+        FF_ALLOC_OR_GOTO(avctx, s->node_buf,
+                         2 * frontier * sizeof(*s->node_buf),  error);
+        FF_ALLOC_OR_GOTO(avctx, s->nodep_buf,
+                         2 * frontier * sizeof(*s->nodep_buf), error);
+        FF_ALLOC_OR_GOTO(avctx, s->trellis_hash,
+                         65536 * sizeof(*s->trellis_hash), error);
     }
 
     avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
 
-    switch(avctx->codec->id) {
+    switch (avctx->codec->id) {
     case CODEC_ID_ADPCM_IMA_WAV:
-        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */
-                                                             /* and we have 4 bytes per channel overhead */
+        /* each 16 bits sample gives one nibble
+           and we have 4 bytes per channel overhead */
+        avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 /
+                            (4 * avctx->channels) + 1;
+        /* seems frame_size isn't taken into account...
+           have to buffer the samples :-( */
         avctx->block_align = BLKSIZE;
-        /* seems frame_size isn't taken into account... have to buffer the samples :-( */
         break;
     case CODEC_ID_ADPCM_IMA_QT:
-        avctx->frame_size = 64;
+        avctx->frame_size  = 64;
         avctx->block_align = 34 * avctx->channels;
         break;
     case CODEC_ID_ADPCM_MS:
-        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */
-                                                             /* and we have 7 bytes per channel overhead */
-        avctx->block_align = BLKSIZE;
+        /* each 16 bits sample gives one nibble
+           and we have 7 bytes per channel overhead */
+        avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 /
+                             avctx->channels + 2;
+        avctx->block_align    = BLKSIZE;
         avctx->extradata_size = 32;
         extradata = avctx->extradata = av_malloc(avctx->extradata_size);
         if (!extradata)
@@ -109,14 +118,15 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
         }
         break;
     case CODEC_ID_ADPCM_YAMAHA:
-        avctx->frame_size = BLKSIZE * avctx->channels;
+        avctx->frame_size  = BLKSIZE * avctx->channels;
         avctx->block_align = BLKSIZE;
         break;
     case CODEC_ID_ADPCM_SWF:
         if (avctx->sample_rate != 11025 &&
             avctx->sample_rate != 22050 &&
             avctx->sample_rate != 44100) {
-            av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n");
+            av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, "
+                   "22050 or 44100\n");
             goto error;
         }
         avctx->frame_size = 512 * (avctx->sample_rate / 11025);
@@ -125,7 +135,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
         goto error;
     }
 
-    avctx->coded_frame= avcodec_alloc_frame();
+    avctx->coded_frame = avcodec_alloc_frame();
     avctx->coded_frame->key_frame= 1;
 
     return 0;
@@ -150,33 +160,37 @@ static av_cold int adpcm_encode_close(AVCodecContext *avctx)
 }
 
 
-static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample)
+static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c,
+                                                      short sample)
 {
-    int delta = sample - c->prev_sample;
-    int nibble = FFMIN(7, abs(delta)*4/ff_adpcm_step_table[c->step_index]) + (delta<0)*8;
-    c->prev_sample += ((ff_adpcm_step_table[c->step_index] * ff_adpcm_yamaha_difflookup[nibble]) / 8);
+    int delta  = sample - c->prev_sample;
+    int nibble = FFMIN(7, abs(delta) * 4 /
+                       ff_adpcm_step_table[c->step_index]) + (delta < 0) * 8;
+    c->prev_sample += ((ff_adpcm_step_table[c->step_index] *
+                        ff_adpcm_yamaha_difflookup[nibble]) / 8);
     c->prev_sample = av_clip_int16(c->prev_sample);
-    c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
+    c->step_index  = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
     return nibble;
 }
 
-static inline unsigned char adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c, short sample)
+static inline unsigned char adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c,
+                                                         short sample)
 {
-    int delta = sample - c->prev_sample;
+    int delta  = sample - c->prev_sample;
     int mask, step = ff_adpcm_step_table[c->step_index];
-    int diff = step >> 3;
+    int diff   = step >> 3;
     int nibble = 0;
 
     if (delta < 0) {
         nibble = 8;
-        delta = -delta;
+        delta  = -delta;
     }
 
     for (mask = 4; mask;) {
         if (delta >= step) {
             nibble |= mask;
-            delta -= step;
-            diff += step;
+            delta  -= step;
+            diff   += step;
         }
         step >>= 1;
         mask >>= 1;
@@ -188,47 +202,53 @@ static inline unsigned char adpcm_ima_qt_compress_sample(ADPCMChannelStatus *c,
         c->prev_sample += diff;
 
     c->prev_sample = av_clip_int16(c->prev_sample);
-    c->step_index = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
+    c->step_index  = av_clip(c->step_index + ff_adpcm_index_table[nibble], 0, 88);
 
     return nibble;
 }
 
-static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample)
+static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c,
+                                                     short sample)
 {
     int predictor, nibble, bias;
 
-    predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;
+    predictor = (((c->sample1) * (c->coeff1)) +
+                (( c->sample2) * (c->coeff2))) / 64;
 
-    nibble= sample - predictor;
-    if(nibble>=0) bias= c->idelta/2;
-    else          bias=-c->idelta/2;
+    nibble = sample - predictor;
+    if (nibble >= 0)
+        bias =  c->idelta / 2;
+    else
+        bias = -c->idelta / 2;
 
-    nibble= (nibble + bias) / c->idelta;
-    nibble= av_clip(nibble, -8, 7)&0x0F;
+    nibble = (nibble + bias) / c->idelta;
+    nibble = av_clip(nibble, -8, 7) & 0x0F;
 
-    predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;
+    predictor += (signed)((nibble & 0x08) ? (nibble - 0x10) : nibble) * c->idelta;
 
     c->sample2 = c->sample1;
     c->sample1 = av_clip_int16(predictor);
 
     c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;
-    if (c->idelta < 16) c->idelta = 16;
+    if (c->idelta < 16)
+        c->idelta = 16;
 
     return nibble;
 }
 
-static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample)
+static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c,
+                                                         short sample)
 {
     int nibble, delta;
 
-    if(!c->step) {
+    if (!c->step) {
         c->predictor = 0;
-        c->step = 127;
+        c->step      = 127;
     }
 
     delta = sample - c->predictor;
 
-    nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8;
+    nibble = FFMIN(7, abs(delta) * 4 / c->step) + (delta < 0) * 8;
 
     c->predictor += ((c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8);
     c->predictor = av_clip_int16(c->predictor);
@@ -244,57 +264,61 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
     //FIXME 6% faster if frontier is a compile-time constant
     ADPCMEncodeContext *s = avctx->priv_data;
     const int frontier = 1 << avctx->trellis;
-    const int stride = avctx->channels;
-    const int version = avctx->codec->id;
-    TrellisPath *paths = s->paths, *p;
-    TrellisNode *node_buf = s->node_buf;
-    TrellisNode **nodep_buf = s->nodep_buf;
-    TrellisNode **nodes = nodep_buf; // nodes[] is always sorted by .ssd
+    const int stride   = avctx->channels;
+    const int version  = avctx->codec->id;
+    TrellisPath *paths       = s->paths, *p;
+    TrellisNode *node_buf    = s->node_buf;
+    TrellisNode **nodep_buf  = s->nodep_buf;
+    TrellisNode **nodes      = nodep_buf; // nodes[] is always sorted by .ssd
     TrellisNode **nodes_next = nodep_buf + frontier;
     int pathn = 0, froze = -1, i, j, k, generation = 0;
     uint8_t *hash = s->trellis_hash;
     memset(hash, 0xff, 65536 * sizeof(*hash));
 
     memset(nodep_buf, 0, 2 * frontier * sizeof(*nodep_buf));
-    nodes[0] = node_buf + frontier;
-    nodes[0]->ssd = 0;
-    nodes[0]->path = 0;
-    nodes[0]->step = c->step_index;
+    nodes[0]          = node_buf + frontier;
+    nodes[0]->ssd     = 0;
+    nodes[0]->path    = 0;
+    nodes[0]->step    = c->step_index;
     nodes[0]->sample1 = c->sample1;
     nodes[0]->sample2 = c->sample2;
-    if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_IMA_QT) || (version == CODEC_ID_ADPCM_SWF))
+    if (version == CODEC_ID_ADPCM_IMA_WAV ||
+        version == CODEC_ID_ADPCM_IMA_QT  ||
+        version == CODEC_ID_ADPCM_SWF)
         nodes[0]->sample1 = c->prev_sample;
-    if(version == CODEC_ID_ADPCM_MS)
+    if (version == CODEC_ID_ADPCM_MS)
         nodes[0]->step = c->idelta;
-    if(version == CODEC_ID_ADPCM_YAMAHA) {
-        if(c->step == 0) {
-            nodes[0]->step = 127;
+    if (version == CODEC_ID_ADPCM_YAMAHA) {
+        if (c->step == 0) {
+            nodes[0]->step    = 127;
             nodes[0]->sample1 = 0;
         } else {
-            nodes[0]->step = c->step;
+            nodes[0]->step    = c->step;
             nodes[0]->sample1 = c->predictor;
         }
     }
 
-    for(i=0; i<n; i++) {
+    for (i = 0; i < n; i++) {
         TrellisNode *t = node_buf + frontier*(i&1);
         TrellisNode **u;
-        int sample = samples[i*stride];
+        int sample   = samples[i * stride];
         int heap_pos = 0;
-        memset(nodes_next, 0, frontier*sizeof(TrellisNode*));
-        for(j=0; j<frontier && nodes[j]; j++) {
-            // higher j have higher ssd already, so they're likely to yield a suboptimal next sample too
-            const int range = (j < frontier/2) ? 1 : 0;
-            const int step = nodes[j]->step;
+        memset(nodes_next, 0, frontier * sizeof(TrellisNode*));
+        for (j = 0; j < frontier && nodes[j]; j++) {
+            // higher j have higher ssd already, so they're likely
+            // to yield a suboptimal next sample too
+            const int range = (j < frontier / 2) ? 1 : 0;
+            const int step  = nodes[j]->step;
             int nidx;
-            if(version == CODEC_ID_ADPCM_MS) {
-                const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 64;
-                const int div = (sample - predictor) / step;
+            if (version == CODEC_ID_ADPCM_MS) {
+                const int predictor = ((nodes[j]->sample1 * c->coeff1) +
+                                       (nodes[j]->sample2 * c->coeff2)) / 64;
+                const int div  = (sample - predictor) / step;
                 const int nmin = av_clip(div-range, -8, 6);
                 const int nmax = av_clip(div+range, -7, 7);
-                for(nidx=nmin; nidx<=nmax; nidx++) {
+                for (nidx = nmin; nidx <= nmax; nidx++) {
                     const int nibble = nidx & 0xf;
-                    int dec_sample = predictor + nidx * step;
+                    int dec_sample   = predictor + nidx * step;
 #define STORE_NODE(NAME, STEP_INDEX)\
                     int d;\
                     uint32_t ssd;\
@@ -329,25 +353,26 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
                     } else {\
                         /* Try to replace one of the leaf nodes with the new \
                          * one, but try a different slot each time. */\
-                        pos = (frontier >> 1) + (heap_pos & ((frontier >> 1) - 1));\
+                        pos = (frontier >> 1) +\
+                              (heap_pos & ((frontier >> 1) - 1));\
                         if (ssd > nodes_next[pos]->ssd)\
                             goto next_##NAME;\
                         heap_pos++;\
                     }\
                     *h = generation;\
-                    u = nodes_next[pos];\
-                    if(!u) {\
-                        assert(pathn < FREEZE_INTERVAL<<avctx->trellis);\
+                    u  = nodes_next[pos];\
+                    if (!u) {\
+                        assert(pathn < FREEZE_INTERVAL << avctx->trellis);\
                         u = t++;\
                         nodes_next[pos] = u;\
                         u->path = pathn++;\
                     }\
-                    u->ssd = ssd;\
+                    u->ssd  = ssd;\
                     u->step = STEP_INDEX;\
                     u->sample2 = nodes[j]->sample1;\
                     u->sample1 = dec_sample;\
                     paths[u->path].nibble = nibble;\
-                    paths[u->path].prev = nodes[j]->path;\
+                    paths[u->path].prev   = nodes[j]->path;\
                     /* Sift the newly inserted node up in the heap to \
                      * restore the heap property. */\
                     while (pos > 0) {\
@@ -358,24 +383,34 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
                         pos = parent;\
                     }\
                     next_##NAME:;
-                    STORE_NODE(ms, FFMAX(16, (ff_adpcm_AdaptationTable[nibble] * step) >> 8));
+                    STORE_NODE(ms, FFMAX(16,
+                               (ff_adpcm_AdaptationTable[nibble] * step) >> 8));
                 }
-            } else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_IMA_QT)|| (version == CODEC_ID_ADPCM_SWF)) {
+            } else if (version == CODEC_ID_ADPCM_IMA_WAV ||
+                       version == CODEC_ID_ADPCM_IMA_QT  ||
+                       version == CODEC_ID_ADPCM_SWF) {
 #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\
                 const int predictor = nodes[j]->sample1;\
                 const int div = (sample - predictor) * 4 / STEP_TABLE;\
-                int nmin = av_clip(div-range, -7, 6);\
-                int nmax = av_clip(div+range, -6, 7);\
-                if(nmin<=0) nmin--; /* distinguish -0 from +0 */\
-                if(nmax<0) nmax--;\
-                for(nidx=nmin; nidx<=nmax; nidx++) {\
-                    const int nibble = nidx<0 ? 7-nidx : nidx;\
-                    int dec_sample = predictor + (STEP_TABLE * ff_adpcm_yamaha_difflookup[nibble]) / 8;\
+                int nmin = av_clip(div - range, -7, 6);\
+                int nmax = av_clip(div + range, -6, 7);\
+                if (nmin <= 0)\
+                    nmin--; /* distinguish -0 from +0 */\
+                if (nmax < 0)\
+                    nmax--;\
+                for (nidx = nmin; nidx <= nmax; nidx++) {\
+                    const int nibble = nidx < 0 ? 7 - nidx : nidx;\
+                    int dec_sample = predictor +\
+                                    (STEP_TABLE *\
+                                     ff_adpcm_yamaha_difflookup[nibble]) / 8;\
                     STORE_NODE(NAME, STEP_INDEX);\
                 }
-                LOOP_NODES(ima, ff_adpcm_step_table[step], av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
+                LOOP_NODES(ima, ff_adpcm_step_table[step],
+                           av_clip(step + ff_adpcm_index_table[nibble], 0, 88));
             } else { //CODEC_ID_ADPCM_YAMAHA
-                LOOP_NODES(yamaha, step, av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8, 127, 24567));
+                LOOP_NODES(yamaha, step,
+                           av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
+                                   127, 24567));
 #undef LOOP_NODES
 #undef STORE_NODE
             }
@@ -392,16 +427,16 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
         }
 
         // prevent overflow
-        if(nodes[0]->ssd > (1<<28)) {
-            for(j=1; j<frontier && nodes[j]; j++)
+        if (nodes[0]->ssd > (1 << 28)) {
+            for (j = 1; j < frontier && nodes[j]; j++)
                 nodes[j]->ssd -= nodes[0]->ssd;
             nodes[0]->ssd = 0;
         }
 
         // merge old paths to save memory
-        if(i == froze + FREEZE_INTERVAL) {
+        if (i == froze + FREEZE_INTERVAL) {
             p = &paths[nodes[0]->path];
-            for(k=i; k>froze; k--) {
+            for (k = i; k > froze; k--) {
                 dst[k] = p->nibble;
                 p = &paths[p->prev];
             }
@@ -410,26 +445,26 @@ static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples,
             // other nodes might use paths that don't coincide with the frozen one.
             // checking which nodes do so is too slow, so just kill them all.
             // this also slightly improves quality, but I don't know why.
-            memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*));
+            memset(nodes + 1, 0, (frontier - 1) * sizeof(TrellisNode*));
         }
     }
 
     p = &paths[nodes[0]->path];
-    for(i=n-1; i>froze; i--) {
+    for (i = n - 1; i > froze; i--) {
         dst[i] = p->nibble;
         p = &paths[p->prev];
     }
 
-    c->predictor = nodes[0]->sample1;
-    c->sample1 = nodes[0]->sample1;
-    c->sample2 = nodes[0]->sample2;
+    c->predictor  = nodes[0]->sample1;
+    c->sample1    = nodes[0]->sample1;
+    c->sample2    = nodes[0]->sample2;
     c->step_index = nodes[0]->step;
-    c->step = nodes[0]->step;
-    c->idelta = nodes[0]->step;
+    c->step       = nodes[0]->step;
+    c->idelta     = nodes[0]->step;
 }
 
 static int adpcm_encode_frame(AVCodecContext *avctx,
-                            unsigned char *frame, int buf_size, void *data)
+                              unsigned char *frame, int buf_size, void *data)
 {
     int n, i, st;
     short *samples;
@@ -439,98 +474,96 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
 
     dst = frame;
     samples = (short *)data;
-    st= avctx->channels == 2;
-/*    n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
+    st = avctx->channels == 2;
+    /* n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */
 
     switch(avctx->codec->id) {
     case CODEC_ID_ADPCM_IMA_WAV:
         n = avctx->frame_size / 8;
-            c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
-/*            c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */
-            bytestream_put_le16(&dst, c->status[0].prev_sample);
-            *dst++ = (unsigned char)c->status[0].step_index;
-            *dst++ = 0; /* unknown */
+        c->status[0].prev_sample = (signed short)samples[0]; /* XXX */
+        /* c->status[0].step_index = 0;
+        XXX: not sure how to init the state machine */
+        bytestream_put_le16(&dst, c->status[0].prev_sample);
+        *dst++ = (unsigned char)c->status[0].step_index;
+        *dst++ = 0; /* unknown */
+        samples++;
+        if (avctx->channels == 2) {
+            c->status[1].prev_sample = (signed short)samples[0];
+            /* c->status[1].step_index = 0; */
+            bytestream_put_le16(&dst, c->status[1].prev_sample);
+            *dst++ = (unsigned char)c->status[1].step_index;
+            *dst++ = 0;
             samples++;
-            if (avctx->channels == 2) {
-                c->status[1].prev_sample = (signed short)samples[0];
-/*                c->status[1].step_index = 0; */
-                bytestream_put_le16(&dst, c->status[1].prev_sample);
-                *dst++ = (unsigned char)c->status[1].step_index;
-                *dst++ = 0;
-                samples++;
-            }
+        }
 
-            /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */
-            if(avctx->trellis > 0) {
-                FF_ALLOC_OR_GOTO(avctx, buf, 2*n*8, error);
-                adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n*8);
-                if(avctx->channels == 2)
-                    adpcm_compress_trellis(avctx, samples+1, buf + n*8, &c->status[1], n*8);
-                for(i=0; i<n; i++) {
-                    *dst++ = buf[8*i+0] | (buf[8*i+1] << 4);
-                    *dst++ = buf[8*i+2] | (buf[8*i+3] << 4);
-                    *dst++ = buf[8*i+4] | (buf[8*i+5] << 4);
-                    *dst++ = buf[8*i+6] | (buf[8*i+7] << 4);
-                    if (avctx->channels == 2) {
-                        uint8_t *buf1 = buf + n*8;
-                        *dst++ = buf1[8*i+0] | (buf1[8*i+1] << 4);
-                        *dst++ = buf1[8*i+2] | (buf1[8*i+3] << 4);
-                        *dst++ = buf1[8*i+4] | (buf1[8*i+5] << 4);
-                        *dst++ = buf1[8*i+6] | (buf1[8*i+7] << 4);
-                    }
+        /* stereo: 4 bytes (8 samples) for left,
+            4 bytes for right, 4 bytes left, ... */
+        if (avctx->trellis > 0) {
+            FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 8, error);
+            adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n * 8);
+            if (avctx->channels == 2)
+                adpcm_compress_trellis(avctx, samples + 1, buf + n * 8,
+                                       &c->status[1], n * 8);
+            for (i = 0; i < n; i++) {
+                *dst++ = buf[8 * i + 0] | (buf[8 * i + 1] << 4);
+                *dst++ = buf[8 * i + 2] | (buf[8 * i + 3] << 4);
+                *dst++ = buf[8 * i + 4] | (buf[8 * i + 5] << 4);
+                *dst++ = buf[8 * i + 6] | (buf[8 * i + 7] << 4);
+                if (avctx->channels == 2) {
+                    uint8_t *buf1 = buf + n * 8;
+                    *dst++ = buf1[8 * i + 0] | (buf1[8 * i + 1] << 4);
+                    *dst++ = buf1[8 * i + 2] | (buf1[8 * i + 3] << 4);
+                    *dst++ = buf1[8 * i + 4] | (buf1[8 * i + 5] << 4);
+                    *dst++ = buf1[8 * i + 6] | (buf1[8 * i + 7] << 4);
                 }
-                av_free(buf);
-            } else
-            for (; n>0; n--) {
-                *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]);
-                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4;
-                dst++;
-                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]);
-                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4;
-                dst++;
-                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]);
-                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4;
-                dst++;
-                *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]);
-                *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4;
-                dst++;
+            }
+            av_free(buf);
+        } else {
+            for (; n > 0; n--) {
+                *dst    = adpcm_ima_compress_sample(&c->status[0], samples[0]);
+                *dst++ |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels    ]) << 4;
+                *dst    = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]);
+                *dst++ |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4;
+                *dst    = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]);
+                *dst++ |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4;
+                *dst    = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]);
+                *dst++ |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4;
                 /* right channel */
                 if (avctx->channels == 2) {
-                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]);
-                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4;
-                    dst++;
-                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]);
-                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4;
-                    dst++;
-                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]);
-                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
-                    dst++;
-                    *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]);
-                    *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
-                    dst++;
+                    *dst    = adpcm_ima_compress_sample(&c->status[1], samples[1 ]);
+                    *dst++ |= adpcm_ima_compress_sample(&c->status[1], samples[3 ]) << 4;
+                    *dst    = adpcm_ima_compress_sample(&c->status[1], samples[5 ]);
+                    *dst++ |= adpcm_ima_compress_sample(&c->status[1], samples[7 ]) << 4;
+                    *dst    = adpcm_ima_compress_sample(&c->status[1], samples[9 ]);
+                    *dst++ |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4;
+                    *dst    = adpcm_ima_compress_sample(&c->status[1], samples[13]);
+                    *dst++ |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4;
                 }
                 samples += 8 * avctx->channels;
             }
+        }
         break;
     case CODEC_ID_ADPCM_IMA_QT:
     {
         int ch, i;
         PutBitContext pb;
-        init_put_bits(&pb, dst, buf_size*8);
+        init_put_bits(&pb, dst, buf_size * 8);
 
-        for(ch=0; ch<avctx->channels; ch++){
+        for (ch = 0; ch < avctx->channels; ch++) {
             put_bits(&pb, 9, (c->status[ch].prev_sample + 0x10000) >> 7);
-            put_bits(&pb, 7, c->status[ch].step_index);
-            if(avctx->trellis > 0) {
+            put_bits(&pb, 7,  c->status[ch].step_index);
+            if (avctx->trellis > 0) {
                 uint8_t buf[64];
                 adpcm_compress_trellis(avctx, samples+ch, buf, &c->status[ch], 64);
-                for(i=0; i<64; i++)
-                    put_bits(&pb, 4, buf[i^1]);
+                for (i = 0; i < 64; i++)
+                    put_bits(&pb, 4, buf[i ^ 1]);
             } else {
-                for (i=0; i<64; i+=2){
+                for (i = 0; i < 64; i += 2) {
                     int t1, t2;
-                    t1 = adpcm_ima_qt_compress_sample(&c->status[ch], samples[avctx->channels*(i+0)+ch]);
-                    t2 = adpcm_ima_qt_compress_sample(&c->status[ch], samples[avctx->channels*(i+1)+ch]);
+                    t1 = adpcm_ima_qt_compress_sample(&c->status[ch],
+                                                      samples[avctx->channels * (i + 0) + ch]);
+                    t2 = adpcm_ima_qt_compress_sample(&c->status[ch],
+                                                      samples[avctx->channels * (i + 1) + ch]);
                     put_bits(&pb, 4, t2);
                     put_bits(&pb, 4, t1);
                 }
@@ -538,119 +571,120 @@ static int adpcm_encode_frame(AVCodecContext *avctx,
         }
 
         flush_put_bits(&pb);
-        dst += put_bits_count(&pb)>>3;
+        dst += put_bits_count(&pb) >> 3;
         break;
     }
     case CODEC_ID_ADPCM_SWF:
     {
         int i;
         PutBitContext pb;
-        init_put_bits(&pb, dst, buf_size*8);
+        init_put_bits(&pb, dst, buf_size * 8);
 
-        n = avctx->frame_size-1;
+        n = avctx->frame_size - 1;
 
-        //Store AdpcmCodeSize
-        put_bits(&pb, 2, 2);                //Set 4bits flash adpcm format
+        // store AdpcmCodeSize
+        put_bits(&pb, 2, 2);    // set 4-bit flash adpcm format
 
-        //Init the encoder state
-        for(i=0; i<avctx->channels; i++){
-            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits
+        // init the encoder state
+        for (i = 0; i < avctx->channels; i++) {
+            // clip step so it fits 6 bits
+            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63);
             put_sbits(&pb, 16, samples[i]);
             put_bits(&pb, 6, c->status[i].step_index);
             c->status[i].prev_sample = (signed short)samples[i];
         }
 
-        if(avctx->trellis > 0) {
-            FF_ALLOC_OR_GOTO(avctx, buf, 2*n, error);
-            adpcm_compress_trellis(avctx, samples+2, buf, &c->status[0], n);
+        if (avctx->trellis > 0) {
+            FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error);
+            adpcm_compress_trellis(avctx, samples + 2, buf, &c->status[0], n);
             if (avctx->channels == 2)
-                adpcm_compress_trellis(avctx, samples+3, buf+n, &c->status[1], n);
-            for(i=0; i<n; i++) {
+                adpcm_compress_trellis(avctx, samples + 3, buf + n,
+                                       &c->status[1], n);
+            for (i = 0; i < n; i++) {
                 put_bits(&pb, 4, buf[i]);
                 if (avctx->channels == 2)
-                    put_bits(&pb, 4, buf[n+i]);
+                    put_bits(&pb, 4, buf[n + i]);
             }
             av_free(buf);
         } else {
-            for (i=1; i<avctx->frame_size; i++) {
-                put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i]));
+            for (i = 1; i < avctx->frame_size; i++) {
+                put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0],
+                         samples[avctx->channels * i]));
                 if (avctx->channels == 2)
-                    put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1]));
+                    put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1],
+                             samples[2 * i + 1]));
             }
         }
         flush_put_bits(&pb);
-        dst += put_bits_count(&pb)>>3;
+        dst += put_bits_count(&pb) >> 3;
         break;
     }
     case CODEC_ID_ADPCM_MS:
-        for(i=0; i<avctx->channels; i++){
-            int predictor=0;
-
+        for (i = 0; i < avctx->channels; i++) {
+            int predictor = 0;
             *dst++ = predictor;
             c->status[i].coeff1 = ff_adpcm_AdaptCoeff1[predictor];
             c->status[i].coeff2 = ff_adpcm_AdaptCoeff2[predictor];
         }
-        for(i=0; i<avctx->channels; i++){
+        for (i = 0; i < avctx->channels; i++) {
             if (c->status[i].idelta < 16)
                 c->status[i].idelta = 16;
-
             bytestream_put_le16(&dst, c->status[i].idelta);
         }
-        for(i=0; i<avctx->channels; i++){
+        for (i = 0; i < avctx->channels; i++)
             c->status[i].sample2= *samples++;
-        }
-        for(i=0; i<avctx->channels; i++){
-            c->status[i].sample1= *samples++;
-
+        for (i = 0; i < avctx->channels; i++) {
+            c->status[i].sample1 = *samples++;
             bytestream_put_le16(&dst, c->status[i].sample1);
         }
-        for(i=0; i<avctx->channels; i++)
+        for (i = 0; i < avctx->channels; i++)
             bytestream_put_le16(&dst, c->status[i].sample2);
 
-        if(avctx->trellis > 0) {
-            int n = avctx->block_align - 7*avctx->channels;
-            FF_ALLOC_OR_GOTO(avctx, buf, 2*n, error);
-            if(avctx->channels == 1) {
+        if (avctx->trellis > 0) {
+            int n = avctx->block_align - 7 * avctx->channels;
+            FF_ALLOC_OR_GOTO(avctx, buf, 2 * n, error);
+            if (avctx->channels == 1) {
                 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
-                for(i=0; i<n; i+=2)
-                    *dst++ = (buf[i] << 4) | buf[i+1];
+                for (i = 0; i < n; i += 2)
+                    *dst++ = (buf[i] << 4) | buf[i + 1];
             } else {
-                adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
-                adpcm_compress_trellis(avctx, samples+1, buf+n, &c->status[1], n);
-                for(i=0; i<n; i++)
-                    *dst++ = (buf[i] << 4) | buf[n+i];
+                adpcm_compress_trellis(avctx, samples,     buf,     &c->status[0], n);
+                adpcm_compress_trellis(avctx, samples + 1, buf + n, &c->status[1], n);
+                for (i = 0; i < n; i++)
+                    *dst++ = (buf[i] << 4) | buf[n + i];
             }
             av_free(buf);
-        } else
-        for(i=7*avctx->channels; i<avctx->block_align; i++) {
-            int nibble;
-            nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4;
-            nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++);
-            *dst++ = nibble;
+        } else {
+            for (i = 7 * avctx->channels; i < avctx->block_align; i++) {
+                int nibble;
+                nibble  = adpcm_ms_compress_sample(&c->status[ 0], *samples++) << 4;
+                nibble |= adpcm_ms_compress_sample(&c->status[st], *samples++);
+                *dst++  = nibble;
+            }
         }
         break;
     case CODEC_ID_ADPCM_YAMAHA:
         n = avctx->frame_size / 2;
-        if(avctx->trellis > 0) {
-            FF_ALLOC_OR_GOTO(avctx, buf, 2*n*2, error);
+        if (avctx->trellis > 0) {
+            FF_ALLOC_OR_GOTO(avctx, buf, 2 * n * 2, error);
             n *= 2;
-            if(avctx->channels == 1) {
+            if (avctx->channels == 1) {
                 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
-                for(i=0; i<n; i+=2)
-                    *dst++ = buf[i] | (buf[i+1] << 4);
+                for (i = 0; i < n; i += 2)
+                    *dst++ = buf[i] | (buf[i + 1] << 4);
             } else {
-                adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n);
-                adpcm_compress_trellis(avctx, samples+1, buf+n, &c->status[1], n);
-                for(i=0; i<n; i++)
-                    *dst++ = buf[i] | (buf[n+i] << 4);
+                adpcm_compress_trellis(avctx, samples,     buf,     &c->status[0], n);
+                adpcm_compress_trellis(avctx, samples + 1, buf + n, &c->status[1], n);
+                for (i = 0; i < n; i++)
+                    *dst++ = buf[i] | (buf[n + i] << 4);
             }
             av_free(buf);
         } else
-            for (n *= avctx->channels; n>0; n--) {
+            for (n *= avctx->channels; n > 0; n--) {
                 int nibble;
                 nibble  = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++);
                 nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4;
-                *dst++ = nibble;
+                *dst++  = nibble;
             }
         break;
     default:
@@ -670,12 +704,13 @@ AVCodec ff_ ## name_ ## _encoder = {                        \
     .init           = adpcm_encode_init,                    \
     .encode         = adpcm_encode_frame,                   \
     .close          = adpcm_encode_close,                   \
-    .sample_fmts    = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, \
+    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,   \
+                                                      AV_SAMPLE_FMT_NONE}, \
     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
 }
 
-ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "ADPCM IMA QuickTime");
+ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt,   "ADPCM IMA QuickTime");
 ADPCM_ENCODER(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "ADPCM IMA WAV");
-ADPCM_ENCODER(CODEC_ID_ADPCM_MS, adpcm_ms, "ADPCM Microsoft");
-ADPCM_ENCODER(CODEC_ID_ADPCM_SWF, adpcm_swf, "ADPCM Shockwave Flash");
-ADPCM_ENCODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha");
+ADPCM_ENCODER(CODEC_ID_ADPCM_MS, adpcm_ms,           "ADPCM Microsoft");
+ADPCM_ENCODER(CODEC_ID_ADPCM_SWF, adpcm_swf,         "ADPCM Shockwave Flash");
+ADPCM_ENCODER(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha,   "ADPCM Yamaha");