Convert a video

[PATCH 2/2] rtmp: Pass the proper return code in rtmp_handshake

---
 libavformat/rtmpproto.c |   13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/libavformat/rtmpproto.c b/libavformat/rtmpproto.c
index 1f78d1c..9af4584 100644
--- a/libavformat/rtmpproto.c
+++ b/libavformat/rtmpproto.c
@@ -639,15 +639,16 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
         return ret;
     }

-    i = ffurl_read_complete(rt->stream, serverdata, RTMP_HANDSHAKE_PACKET_SIZE + 1);
-    if (i != RTMP_HANDSHAKE_PACKET_SIZE + 1) {
+    if ((ret = ffurl_read_complete(rt->stream, serverdata,
+                                   RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
         av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
-        return AVERROR(EIO);
+        return ret;
     }
-    i = ffurl_read_complete(rt->stream, clientdata, RTMP_HANDSHAKE_PACKET_SIZE);
-    if (i != RTMP_HANDSHAKE_PACKET_SIZE) {
+
+    if ((ret = ffurl_read_complete(rt->stream, clientdata,
+                                   RTMP_HANDSHAKE_PACKET_SIZE)) < 0) {
         av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
-        return AVERROR(EIO);
+        return ret;
     }

     av_log(s, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
--

-- 
1.7.10.2

[PATCH] rtmp: Check return codes of net IO operations

---
 libavformat/rtmppkt.c   |   14 ++++++---
 libavformat/rtmpproto.c |   75 +++++++++++++++++++++++++++++++++++------------
 2 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/libavformat/rtmppkt.c b/libavformat/rtmppkt.c
index 474f637..0b333bf 100644
--- a/libavformat/rtmppkt.c
+++ b/libavformat/rtmppkt.c
@@ -151,7 +151,10 @@ int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p,
         offset    += chunk_size;
         size      += chunk_size;
         if (data_size > 0) {
-            ffurl_read_complete(h, &t, 1); //marker
+            if (ffurl_read_complete(h, &t, 1) != 1) { // marker
+                ff_rtmp_packet_destroy(p);
+                return AVERROR(EIO);
+            }
             size++;
             if (t != (0xC0 + channel_id))
                 return -1;
@@ -218,15 +221,18 @@ int ff_rtmp_packet_write(URLContext *h, RTMPPacket *pkt,
     }
     prev_pkt[pkt->channel_id].extra      = pkt->extra;

-    ffurl_write(h, pkt_hdr, p-pkt_hdr);
+    if (ffurl_write(h, pkt_hdr, p - pkt_hdr) != p - pkt_hdr)
+        return AVERROR(EIO);
     size = p - pkt_hdr + pkt->data_size;
     while (off < pkt->data_size) {
         int towrite = FFMIN(chunk_size, pkt->data_size - off);
-        ffurl_write(h, pkt->data + off, towrite);
+        if (ffurl_write(h, pkt->data + off, towrite) != towrite)
+            return AVERROR(EIO);
         off += towrite;
         if (off < pkt->data_size) {
             uint8_t marker = 0xC0 | pkt->channel_id;
-            ffurl_write(h, &marker, 1);
+            if (ffurl_write(h, &marker, 1) != 1)
+                return AVERROR(EIO);
             size++;
         }
     }
diff --git a/libavformat/rtmpproto.c b/libavformat/rtmpproto.c
index 31cc194..5ad396a 100644
--- a/libavformat/rtmpproto.c
+++ b/libavformat/rtmpproto.c
@@ -167,7 +167,9 @@ static int gen_connect(URLContext *s, RTMPContext *rt)

     pkt.data_size = p - pkt.data;

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -194,7 +196,9 @@ static int gen_release_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -221,7 +225,9 @@ static int gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -248,7 +254,9 @@ static int gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -276,7 +284,9 @@ static int gen_create_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     rt->create_stream_invoke = rt->nb_invokes;

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -305,7 +315,9 @@ static int gen_delete_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_number(&p, rt->main_channel_id);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -336,7 +348,9 @@ static int gen_play(URLContext *s, RTMPContext *rt)
     ff_amf_write_string(&p, rt->playpath);
     ff_amf_write_number(&p, rt->live);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     // set client buffer time disguised in ping packet
@@ -349,7 +363,9 @@ static int gen_play(URLContext *s, RTMPContext *rt)
     bytestream_put_be32(&p, 1);
     bytestream_put_be32(&p, 256); //TODO: what is a good value here?

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -379,7 +395,9 @@ static int gen_publish(URLContext *s, RTMPContext *rt)
     ff_amf_write_string(&p, rt->playpath);
     ff_amf_write_string(&p, "live");

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return ret;
@@ -401,7 +419,9 @@ static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
     p = pkt.data;
     bytestream_put_be16(&p, 7);
     bytestream_put_be32(&p, AV_RB32(ppkt->data+2));
-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -422,7 +442,9 @@ static int gen_server_bw(URLContext *s, RTMPContext *rt)

     p = pkt.data;
     bytestream_put_be32(&p, 2500000);
-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -446,7 +468,9 @@ static int gen_check_bw(URLContext *s, RTMPContext *rt)
     ff_amf_write_number(&p, ++rt->nb_invokes);
     ff_amf_write_null(&p);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return ret;
@@ -467,7 +491,9 @@ static int gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)

     p = pkt.data;
     bytestream_put_be32(&p, rt->bytes_read);
-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    if ((ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                                    rt->prev_pkt[1])) < 0)
+        return ret;
     ff_rtmp_packet_destroy(&pkt);

     return 0;
@@ -617,7 +643,12 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
     if (client_pos < 0)
         return client_pos;

-    ffurl_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE + 1);
+    i = ffurl_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE + 1);
+    if (i != RTMP_HANDSHAKE_PACKET_SIZE + 1) {
+        av_log(s, AV_LOG_ERROR, "Cannot write RTMP handshake response\n");
+        return AVERROR(EIO);
+    }
+
     i = ffurl_read_complete(rt->stream, serverdata, RTMP_HANDSHAKE_PACKET_SIZE + 1);
     if (i != RTMP_HANDSHAKE_PACKET_SIZE + 1) {
         av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
@@ -678,9 +709,13 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
             return ret;

         // write reply back to the server
-        ffurl_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE);
+        i = ffurl_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE);
+        if (i != RTMP_HANDSHAKE_PACKET_SIZE)
+            return AVERROR(EIO);
     } else {
-        ffurl_write(rt->stream, serverdata+1, RTMP_HANDSHAKE_PACKET_SIZE);
+        i = ffurl_write(rt->stream, serverdata+1, RTMP_HANDSHAKE_PACKET_SIZE);
+        if (i != RTMP_HANDSHAKE_PACKET_SIZE)
+            return AVERROR(EIO);
     }

     return 0;
@@ -710,7 +745,9 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
             return -1;
         }
         if (!rt->is_input)
-            ff_rtmp_packet_write(rt->stream, pkt, rt->chunk_size, rt->prev_pkt[1]);
+            if ((ret = ff_rtmp_packet_write(rt->stream, pkt, rt->chunk_size,
+                                            rt->prev_pkt[1])) < 0)
+                return ret;
         rt->chunk_size = AV_RB32(pkt->data);
         if (rt->chunk_size <= 0) {
             av_log(s, AV_LOG_ERROR, "Incorrect chunk size %d\n", rt->chunk_size);
@@ -1201,7 +1238,9 @@ static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
         if (rt->flv_off == rt->flv_size) {
             rt->skip_bytes = 4;

-            ff_rtmp_packet_write(rt->stream, &rt->out_pkt, rt->chunk_size, rt->prev_pkt[1]);
+            if ((ret = ff_rtmp_packet_write(rt->stream, &rt->out_pkt,
+                                            rt->chunk_size, rt->prev_pkt[1])) < 0)
+                return ret;
             ff_rtmp_packet_destroy(&rt->out_pkt);
             rt->flv_size = 0;
             rt->flv_off = 0;
--

-- 
1.7.10.2

[PATCH] rtmp: WIP: check retcodes of net IO operations

Samuel, while you're at enhancing rtmp proto, could you please add also checks on net connection IO
operations? I planned to do it by myself, but as you are already preparing the patchset, it makes more sense
to ask you for this.
The reason for this patch is case when RTMP server is shut down while we publish the stream onto it. Currently
it just strikes the application with SIGPIPE. I have an environment for testing this issue.
Thanks in advance, Samuel.
---8<---
---
 libavformat/rtmppkt.c   |    9 +++-
 libavformat/rtmpproto.c |  103 ++++++++++++++++++++++++++++++++--------------
 2 files changed, 77 insertions(+), 35 deletions(-)

diff --git a/libavformat/rtmppkt.c b/libavformat/rtmppkt.c
index 61e159b..8e8ca26 100644
--- a/libavformat/rtmppkt.c
+++ b/libavformat/rtmppkt.c
@@ -216,15 +216,18 @@ int ff_rtmp_packet_write(URLContext *h, RTMPPacket *pkt,
     }
     prev_pkt[pkt->channel_id].extra      = pkt->extra;

-    ffurl_write(h, pkt_hdr, p-pkt_hdr);
+    if (ffurl_write(h, pkt_hdr, p-pkt_hdr) < 0)
+        return AVERROR(EIO);
     size = p - pkt_hdr + pkt->data_size;
     while (off < pkt->data_size) {
         int towrite = FFMIN(chunk_size, pkt->data_size - off);
-        ffurl_write(h, pkt->data + off, towrite);
+        if (ffurl_write(h, pkt->data + off, towrite) < 0)
+            return AVERROR(EIO);
         off += towrite;
         if (off < pkt->data_size) {
             uint8_t marker = 0xC0 | pkt->channel_id;
-            ffurl_write(h, &marker, 1);
+            if (ffurl_write(h, &marker, 1) < 0)
+                return AVERROR(EIO);
             size++;
         }
     }
diff --git a/libavformat/rtmpproto.c b/libavformat/rtmpproto.c
index a2c7b5d..6304895 100644
--- a/libavformat/rtmpproto.c
+++ b/libavformat/rtmpproto.c
@@ -104,9 +104,10 @@ static const uint8_t rtmp_server_key[] = {
 /**
  * Generate 'connect' call and send it to the server.
  */
-static void gen_connect(URLContext *s, RTMPContext *rt, const char *proto,
+static int gen_connect(URLContext *s, RTMPContext *rt, const char *proto,
                         const char *host, int port)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t ver[64], *p;
     char tcurl[512];
@@ -149,16 +150,18 @@ static void gen_connect(URLContext *s, RTMPContext *rt, const char *proto,

     pkt.data_size = p - pkt.data;

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate 'releaseStream' call and send it to the server. It should make
  * the server release some channel for media streams.
  */
-static void gen_release_stream(URLContext *s, RTMPContext *rt)
+static int gen_release_stream(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -172,16 +175,18 @@ static void gen_release_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate 'FCPublish' call and send it to the server. It should make
  * the server preapare for receiving media streams.
  */
-static void gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
+static int gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -195,16 +200,18 @@ static void gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate 'FCUnpublish' call and send it to the server. It should make
  * the server destroy stream.
  */
-static void gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
+static int gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -218,16 +225,18 @@ static void gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate 'createStream' call and send it to the server. It should make
  * the server allocate some channel for media streams.
  */
-static void gen_create_stream(URLContext *s, RTMPContext *rt)
+static int gen_create_stream(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -240,8 +249,9 @@ static void gen_create_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     rt->create_stream_invoke = rt->nb_invokes;

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 
@@ -249,8 +259,9 @@ static void gen_create_stream(URLContext *s, RTMPContext *rt)
  * Generate 'deleteStream' call and send it to the server. It should make
  * the server remove some channel for media streams.
  */
-static void gen_delete_stream(URLContext *s, RTMPContext *rt)
+static int gen_delete_stream(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -263,16 +274,18 @@ static void gen_delete_stream(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_number(&p, rt->main_channel_id);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate 'play' call and send it to the server, then ping the server
  * to start actual playing.
  */
-static void gen_play(URLContext *s, RTMPContext *rt)
+static int gen_play(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -287,8 +300,10 @@ static void gen_play(URLContext *s, RTMPContext *rt)
     ff_amf_write_null(&p);
     ff_amf_write_string(&p, rt->playpath);

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    if (ret)
+        return ret;

     // set client buffer time disguised in ping packet
     ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING, 1, 10);
@@ -298,15 +313,17 @@ static void gen_play(URLContext *s, RTMPContext *rt)
     bytestream_put_be32(&p, 1);
     bytestream_put_be32(&p, 256); //TODO: what is a good value here?

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate 'publish' call and send it to the server.
  */
-static void gen_publish(URLContext *s, RTMPContext *rt)
+static int gen_publish(URLContext *s, RTMPContext *rt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -322,15 +339,17 @@ static void gen_publish(URLContext *s, RTMPContext *rt)
     ff_amf_write_string(&p, rt->playpath);
     ff_amf_write_string(&p, "live");

-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate ping reply and send it to the server.
  */
-static void gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
+static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

@@ -338,23 +357,26 @@ static void gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
     p = pkt.data;
     bytestream_put_be16(&p, 7);
     bytestream_put_be32(&p, AV_RB32(ppkt->data+2));
-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 /**
  * Generate report on bytes read so far and send it to the server.
  */
-static void gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)
+static int gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)
 {
+    int ret;
     RTMPPacket pkt;
     uint8_t *p;

     ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_BYTES_READ, ts, 4);
     p = pkt.data;
     bytestream_put_be32(&p, rt->bytes_read);
-    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
+    return ret;
 }

 //TODO: Move HMAC code somewhere. Eventually.
@@ -548,6 +570,7 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
  */
 static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
 {
+    int ret;
     int i, t;
     const uint8_t *data_end = pkt->data + pkt->data_size;

@@ -563,7 +586,8 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
             return -1;
         }
         if (!rt->is_input)
-            ff_rtmp_packet_write(rt->stream, pkt, rt->chunk_size, rt->prev_pkt[1]);
+            if (ret = ff_rtmp_packet_write(rt->stream, pkt, rt->chunk_size, rt->prev_pkt[1]))
+                return ret;
         rt->chunk_size = AV_RB32(pkt->data);
         if (rt->chunk_size <= 0) {
             av_log(s, AV_LOG_ERROR, "Incorrect chunk size %d\n", rt->chunk_size);
@@ -574,7 +598,8 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
     case RTMP_PT_PING:
         t = AV_RB16(pkt->data);
         if (t == 6)
-            gen_pong(s, rt, pkt);
+            if (ret = gen_pong(s, rt, pkt))
+                return ret;
         break;
     case RTMP_PT_CLIENT_BW:
         if (pkt->data_size < 4) {
@@ -599,13 +624,16 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
             switch (rt->state) {
             case STATE_HANDSHAKED:
                 if (!rt->is_input) {
-                    gen_release_stream(s, rt);
-                    gen_fcpublish_stream(s, rt);
+                    if (ret = gen_release_stream(s, rt))
+                        return ret;
+                    if (ret = gen_fcpublish_stream(s, rt))
+                        return ret;
                     rt->state = STATE_RELEASING;
                 } else {
                     rt->state = STATE_CONNECTING;
                 }
-                gen_create_stream(s, rt);
+                if (ret = gen_create_stream(s, rt))
+                    return ret;
                 break;
             case STATE_FCPUBLISH:
                 rt->state = STATE_CONNECTING;
@@ -629,9 +657,11 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
                     rt->main_channel_id = av_int2double(AV_RB64(pkt->data + 21));
                 }
                 if (rt->is_input) {
-                    gen_play(s, rt);
+                    if (ret = gen_play(s, rt))
+                        return ret;
                 } else {
-                    gen_publish(s, rt);
+                    if (ret = gen_publish(s, rt))
+                        return ret;
                 }
                 rt->state = STATE_READY;
                 break;
@@ -702,7 +732,8 @@ static int get_packet(URLContext *s, int for_header)
         rt->bytes_read += ret;
         if (rt->bytes_read - rt->last_bytes_read > rt->client_report_size) {
             av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
-            gen_bytes_read(s, rt, rpkt.timestamp + 1);
+            if (ret = gen_bytes_read(s, rt, rpkt.timestamp + 1))
+                return ret;
             rt->last_bytes_read = rt->bytes_read;
         }

@@ -772,14 +803,17 @@ static int get_packet(URLContext *s, int for_header)

 static int rtmp_close(URLContext *h)
 {
+    int ret;
     RTMPContext *rt = h->priv_data;

     if (!rt->is_input) {
         rt->flv_data = NULL;
         if (rt->out_pkt.data_size)
             ff_rtmp_packet_destroy(&rt->out_pkt);
-        if (rt->state > STATE_FCPUBLISH)
-            gen_fcunpublish_stream(h, rt);
+        if (rt->state > STATE_FCPUBLISH) {
+            if (ret = gen_fcunpublish_stream(h, rt))
+                return ret;
+        }
     }
     if (rt->state > STATE_HANDSHAKED)
         gen_delete_stream(h, rt);
@@ -867,6 +901,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)

     do {
         ret = get_packet(s, 1);
+        av_log(s, AV_LOG_DEBUG, "get_packet ret %d\n", ret);
     } while (ret == EAGAIN);
     if (ret < 0)
         goto fail;
@@ -889,6 +924,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
     return 0;

 fail:
+    av_log(s, AV_LOG_ERROR, "RTMP open fail\n");
     rtmp_close(s);
     return AVERROR(EIO);
 }
@@ -922,6 +958,7 @@ static int rtmp_read(URLContext *s, uint8_t *buf, int size)

 static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
 {
+    int ret;
     RTMPContext *rt = s->priv_data;
     int size_temp = size;
     int pktsize, pkttype;
@@ -983,8 +1020,10 @@ static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
         if (rt->flv_off == rt->flv_size) {
             rt->skip_bytes = 4;

-            ff_rtmp_packet_write(rt->stream, &rt->out_pkt, rt->chunk_size, rt->prev_pkt[1]);
+            ret = ff_rtmp_packet_write(rt->stream, &rt->out_pkt, rt->chunk_size, rt->prev_pkt[1]);
             ff_rtmp_packet_destroy(&rt->out_pkt);
+            if (ret)
+                return ret;
             rt->flv_size = 0;
             rt->flv_off = 0;
             rt->flv_header_bytes = 0;
--

-- 
1.7.3.4

[PATCH] movenc: Don't write the 'wave' atom or its child 'enda' for lpcm audio.

It's left over from stsd v0. QuickTime 7 no longer writes 'wave' or 'enda'
when 'lpcm' is the audio tag.
---
 libavformat/movenc.c |    5 +----
 1 files changed, 1 insertions(+), 4 deletions(-)

diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index 35c03dd..9a57d46 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -403,8 +403,6 @@ static int mov_write_wave_tag(AVIOContext *pb, MOVTrack *track)
         ffio_wfourcc(pb, "mp4a");
         avio_wb32(pb, 0);
         mov_write_esds_tag(pb, track);
-    } else if (mov_pcm_le_gt16(track->enc->codec_id)) {
-        mov_write_enda_tag(pb);
     } else if (track->enc->codec_id == CODEC_ID_AMR_NB) {
         mov_write_amr_tag(pb, track);
     } else if (track->enc->codec_id == CODEC_ID_AC3) {
@@ -641,8 +639,7 @@ static int mov_write_audio_tag(AVIOContext *pb, MOVTrack *track)
         track->enc->codec_id == CODEC_ID_AMR_NB ||
         track->enc->codec_id == CODEC_ID_ALAC ||
         track->enc->codec_id == CODEC_ID_ADPCM_MS ||
-        track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV ||
-        mov_pcm_le_gt16(track->enc->codec_id)))
+        track->enc->codec_id == CODEC_ID_ADPCM_IMA_WAV))
         mov_write_wave_tag(pb, track);
     else if(track->tag == MKTAG('m','p','4','a'))
         mov_write_esds_tag(pb, track);
--

-- 
1.7.7.3

[PATCH] flvdec: Make sure sample_rate is set to the updated value

The sample_rate variable is used for checks for audio format
changes at the end of the function.

This fixes cases where the sample rate was set from the codec
id by flv_set_audio_codec (as for nellymoser 8 kHz/16 kHz),
so the value set to last_sample_rate wasn't equal to sample_rate
at this point. This caused the demuxer otherwise reports a spurious
change to 5512 Hz and back to the correct one.

Updating channels in the same way is only done for consistency.
Currently, flv_set_audio_codec doesn't update that value.
---
 libavformat/flvdec.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libavformat/flvdec.c b/libavformat/flvdec.c
index 7c4b792..b9d65a6 100644
--- a/libavformat/flvdec.c
+++ b/libavformat/flvdec.c
@@ -571,8 +571,8 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
         }
         if(!st->codec->codec_id){
             flv_set_audio_codec(s, st, st->codec, flags & FLV_AUDIO_CODECID_MASK);
-            flv->last_sample_rate = st->codec->sample_rate;
-            flv->last_channels    = st->codec->channels;
+            flv->last_sample_rate = sample_rate = st->codec->sample_rate;
+            flv->last_channels    = channels    = st->codec->channels;
         } else {
             AVCodecContext ctx;
             ctx.sample_rate = sample_rate;
--

-- 
1.7.9.4

[PATCH 1/2] adpcm: Fix crash with broken, non-stereo samples

From: Michael Niedermayer <michaelni@...>

Fixes half of http://ffmpeg.org/trac/ffmpeg/ticket/794
Adresses CVE-2012-0852

Bug found by: Oana Stratulat
CC: libav-stable@...

Signed-off-by: Michael Niedermayer <michaelni@...>
Signed-off-by: Reinhard Tartler <siretart@...>
(cherry picked from commit 608708009f69ba4cecebf05120c696167494c897)
---
 libavcodec/adpcm.c |    3 +++
 1 file changed, 3 insertions(+)

diff --git a/libavcodec/adpcm.c b/libavcodec/adpcm.c
index 8170e7f..dc63fcd 100644
--- a/libavcodec/adpcm.c
+++ b/libavcodec/adpcm.c
@@ -926,6 +926,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx, void *data,
         /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
            each coding 28 stereo samples. */

+        if(avctx->channels != 2)
+            return AVERROR_INVALIDDATA;
+
         current_left_sample   = sign_extend(bytestream2_get_le16u(&gb), 16);
         previous_left_sample  = sign_extend(bytestream2_get_le16u(&gb), 16);
         current_right_sample  = sign_extend(bytestream2_get_le16u(&gb), 16);
--

-- 
1.7.9.5

[PATCH] Define SHUT_RD, SHUT_WR and SHUT_RDWR on OS/2

---
 libavformat/os_support.h |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)

diff --git a/libavformat/os_support.h b/libavformat/os_support.h
index 1088c6c..223203a 100644
--- a/libavformat/os_support.h
+++ b/libavformat/os_support.h
@@ -45,6 +45,12 @@ static inline int is_dos_path(const char *path)
     return 0;
 }

+#if defined(__OS2__)
+#define SHUT_RD 0
+#define SHUT_WR 1
+#define SHUT_RDWR 2
+#endif
+
 #if defined(_WIN32)
 #define SHUT_RD SD_RECEIVE
 #define SHUT_WR SD_SEND
--
1.7.2.3

[PATCH] aacdec: Turn PS off when switching to stereo and turn it to implicit when switching to mono.

---
 libavcodec/aacdec.c |    3 +++
 1 files changed, 3 insertions(+), 0 deletions(-)

diff --git a/libavcodec/aacdec.c b/libavcodec/aacdec.c
index bd5ba00..ddc7eef 100644
--- a/libavcodec/aacdec.c
+++ b/libavcodec/aacdec.c
@@ -461,6 +461,7 @@ static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
             return NULL;

         ac->oc[1].m4ac.chan_config = 2;
+        ac->oc[1].m4ac.ps = 0;
     }
     // And vice-versa
     if (!ac->tags_mapped && type == TYPE_SCE && ac->oc[1].m4ac.chan_config == 2) {
@@ -476,6 +477,8 @@ static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
             return NULL;

         ac->oc[1].m4ac.chan_config = 1;
+        if (ac->oc[1].m4ac.sbr)
+            ac->oc[1].m4ac.ps = -1;
     }
     // For indexed channel configurations map the channels solely based on position.
     switch (ac->oc[1].m4ac.chan_config) {
--

-- 
1.7.7.3

Fixes Libav Bugzilla #294

[PATCH] asyncts: reset delta to 0 when it's not used.

Fixes an invalid write.
---
 libavfilter/af_asyncts.c |   11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/libavfilter/af_asyncts.c b/libavfilter/af_asyncts.c
index 5cde0bf..adb5347 100644
--- a/libavfilter/af_asyncts.c
+++ b/libavfilter/af_asyncts.c
@@ -182,10 +182,13 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
     if (labs(delta) > s->min_delta) {
         av_log(ctx, AV_LOG_VERBOSE, "Discontinuity - %"PRId64" samples.\n", delta);
         out_size += delta;
-    } else if (s->resample) {
-        int comp = av_clip(delta, -s-≥max_comp, s->max_comp);
-        av_log(ctx, AV_LOG_VERBOSE, "Compensating %d samples per second.\n", comp);
-        avresample_set_compensation(s->avr, delta, inlink->sample_rate);
+    } else {
+        if (s->resample) {
+            int comp = av_clip(delta, -s-≥max_comp, s->max_comp);
+            av_log(ctx, AV_LOG_VERBOSE, "Compensating %d samples per second.\n", comp);
+            avresample_set_compensation(s->avr, delta, inlink->sample_rate);
+        }
+        delta = 0;
     }

     if (out_size > 0) {
--

-- 
1.7.9.5

[PATCH] imc: some cosmetics

---
I plan to reuse this code for Intel Audio Coder, so I thought it could do with
some diegoing.
---
 libavcodec/imc.c |  329 +++++++++++++++++++++++++++++-------------------------
 1 files changed, 175 insertions(+), 154 deletions(-)

diff --git a/libavcodec/imc.c b/libavcodec/imc.c
index 2c9efb9..5c926c2 100644
--- a/libavcodec/imc.c
+++ b/libavcodec/imc.c
@@ -116,14 +116,14 @@ static av_cold int imc_decode_init(AVCodecContext * avctx)

     q->decoder_reset = 1;

-    for(i = 0; i < BANDS; i++)
+    for (i = 0; i < BANDS; i++)
         q->old_floor[i] = 1.0;

     /* Build mdct window, a simple sine window normalized with sqrt(2) */
     ff_sine_window_init(q->mdct_sine_window, COEFFS);
-    for(i = 0; i < COEFFS; i++)
+    for (i = 0; i < COEFFS; i++)
         q->mdct_sine_window[i] *= sqrt(2.0);
-    for(i = 0; i < COEFFS/2; i++){
+    for (i = 0; i < COEFFS/2; i++) {
         q->post_cos[i] = (1.0f / 32768) * cos(i / 256.0 * M_PI);
         q->post_sin[i] = (1.0f / 32768) * sin(i / 256.0 * M_PI);

@@ -146,13 +146,13 @@ static av_cold int imc_decode_init(AVCodecContext * avctx)

     /* Generate a square root table */

-    for(i = 0; i < 30; i++) {
+    for (i = 0; i < 30; i++) {
         q->sqrt_tab[i] = sqrt(i);
     }

     /* initialize the VLC tables */
-    for(i = 0; i < 4 ; i++) {
-        for(j = 0; j < 4; j++) {
+    for (i = 0; i < 4 ; i++) {
+        for (j = 0; j < 4; j++) {
             huffman_vlc[i][j].table = &vlc_tables[vlc_offsets[i * 4 + j]];
             huffman_vlc[i][j].table_allocated = vlc_offsets[i * 4 + j + 1] - vlc_offsets[i * 4 + j];
             init_vlc(&huffman_vlc[i][j], 9, imc_huffman_sizes[i],
@@ -160,7 +160,7 @@ static av_cold int imc_decode_init(AVCodecContext * avctx)
                      imc_huffman_bits[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
         }
     }
-    q->one_div_log2 = 1/log(2);
+    q->one_div_log2 = 1 / log(2);

     if ((ret = ff_fft_init(&q->fft, 7, 1))) {
         av_log(avctx, AV_LOG_INFO, "FFT init failed\n");
@@ -176,8 +176,9 @@ static av_cold int imc_decode_init(AVCodecContext * avctx)
     return 0;
 }

-static void imc_calculate_coeffs(IMCContext* q, float* flcoeffs1, float* flcoeffs2, int* bandWidthT,
-                                float* flcoeffs3, float* flcoeffs5)
+static void imc_calculate_coeffs(IMCContext* q, float* flcoeffs1,
+                                 float* flcoeffs2, int* bandWidthT,
+                                 float* flcoeffs3, float* flcoeffs5)
 {
     float   workT1[BANDS];
     float   workT2[BANDS];
@@ -186,13 +187,13 @@ static void imc_calculate_coeffs(IMCContext* q, float* flcoeffs1, float* flcoeff
     float   accum = 0.0;
     int i, cnt2;

-    for(i = 0; i < BANDS; i++) {
+    for (i = 0; i < BANDS; i++) {
         flcoeffs5[i] = workT2[i] = 0.0;
-        if (bandWidthT[i]){
+        if (bandWidthT[i]) {
             workT1[i] = flcoeffs1[i] * flcoeffs1[i];
             flcoeffs3[i] = 2.0 * flcoeffs2[i];
         } else {
-            workT1[i] = 0.0;
+            workT1[i]    = 0.0;
             flcoeffs3[i] = -30000.0;
         }
         workT3[i] = bandWidthT[i] * workT1[i] * 0.01;
@@ -200,29 +201,29 @@ static void imc_calculate_coeffs(IMCContext* q, float* flcoeffs1, float* flcoeff
             workT3[i] = 0.0;
     }

-    for(i = 0; i < BANDS; i++) {
-        for(cnt2 = i; cnt2 < cyclTab[i]; cnt2++)
+    for (i = 0; i < BANDS; i++) {
+        for (cnt2 = i; cnt2 < cyclTab[i]; cnt2++)
             flcoeffs5[cnt2] = flcoeffs5[cnt2] + workT3[i];
         workT2[cnt2-1] = workT2[cnt2-1] + workT3[i];
     }

-    for(i = 1; i < BANDS; i++) {
+    for (i = 1; i < BANDS; i++) {
         accum = (workT2[i-1] + accum) * imc_weights1[i-1];
         flcoeffs5[i] += accum;
     }

-    for(i = 0; i < BANDS; i++)
+    for (i = 0; i < BANDS; i++)
         workT2[i] = 0.0;

-    for(i = 0; i < BANDS; i++) {
-        for(cnt2 = i-1; cnt2 > cyclTab2[i]; cnt2--)
+    for (i = 0; i < BANDS; i++) {
+        for (cnt2 = i-1; cnt2 > cyclTab2[i]; cnt2--)
             flcoeffs5[cnt2] += workT3[i];
         workT2[cnt2+1] += workT3[i];
     }

     accum = 0.0;

-    for(i = BANDS-2; i >= 0; i--) {
+    for (i = BANDS-2; i >= 0; i--) {
         accum = (workT2[i+1] + accum) * imc_weights2[i];
         flcoeffs5[i] += accum;
         //there is missing code here, but it seems to never be triggered
@@ -230,7 +231,8 @@ static void imc_calculate_coeffs(IMCContext* q, float* flcoeffs1, float* flcoeff
 }

 
-static void imc_read_level_coeffs(IMCContext* q, int stream_format_code, int* levlCoeffs)
+static void imc_read_level_coeffs(IMCContext* q, int stream_format_code,
+                                  int* levlCoeffs)
 {
     int i;
     VLC *hufftab[4];
@@ -245,41 +247,42 @@ static void imc_read_level_coeffs(IMCContext* q, int stream_format_code, int* le
     hufftab[3] = &huffman_vlc[s][3];
     cb_sel = imc_cb_select[s];

-    if(stream_format_code & 4)
+    if (stream_format_code & 4)
         start = 1;
-    if(start)
+    if (start)
         levlCoeffs[0] = get_bits(&q->gb, 7);
-    for(i = start; i < BANDS; i++){
-        levlCoeffs[i] = get_vlc2(&q->gb, hufftab[cb_sel[i]]->table, hufftab[cb_sel[i]]->bits, 2);
-        if(levlCoeffs[i] == 17)
+    for (i = start; i < BANDS; i++) {
+        levlCoeffs[i] = get_vlc2(&q->gb, hufftab[cb_sel[i]]->table,
+                                 hufftab[cb_sel[i]]->bits, 2);
+        if (levlCoeffs[i] == 17)
             levlCoeffs[i] += get_bits(&q->gb, 4);
     }
 }

-static void imc_decode_level_coefficients(IMCContext* q, int* levlCoeffBuf, float* flcoeffs1,
-                                         float* flcoeffs2)
+static void imc_decode_level_coefficients(IMCContext* q, int* levlCoeffBuf,
+                                          float* flcoeffs1, float* flcoeffs2)
 {
     int i, level;
     float tmp, tmp2;
     //maybe some frequency division thingy

     flcoeffs1[0] = 20000.0 / pow (2, levlCoeffBuf[0] * 0.18945); // 0.18945 = log2(10) * 0.05703125
-    flcoeffs2[0] = log(flcoeffs1[0])/log(2);
-    tmp = flcoeffs1[0];
+    flcoeffs2[0] = log(flcoeffs1[0]) / log(2);
+    tmp  = flcoeffs1[0];
     tmp2 = flcoeffs2[0];

-    for(i = 1; i < BANDS; i++) {
+    for (i = 1; i < BANDS; i++) {
         level = levlCoeffBuf[i];
         if (level == 16) {
             flcoeffs1[i] = 1.0;
             flcoeffs2[i] = 0.0;
         } else {
             if (level < 17)
-                level -=7;
+                level -= 7;
             else if (level <= 24)
-                level -=32;
+                level -= 32;
             else
-                level -=16;
+                level -= 16;

             tmp  *= imc_exp_tab[15 + level];
             tmp2 += 0.83048 * level;  // 0.83048 = log2(10) * 0.25
@@ -290,15 +293,17 @@ static void imc_decode_level_coefficients(IMCContext* q, int* levlCoeffBuf, floa
 }

 
-static void imc_decode_level_coefficients2(IMCContext* q, int* levlCoeffBuf, float* old_floor,
float* flcoeffs1,
-                                          float* flcoeffs2) {
+static void imc_decode_level_coefficients2(IMCContext* q, int* levlCoeffBuf,
+                                           float* old_floor, float* flcoeffs1,
+                                           float* flcoeffs2)
+{
     int i;
-        //FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
-        //      and flcoeffs2 old scale factors
-        //      might be incomplete due to a missing table that is in the binary code
-    for(i = 0; i < BANDS; i++) {
+    //FIXME maybe flag_buf = noise coding and flcoeffs1 = new scale factors
+    //      and flcoeffs2 old scale factors
+    //      might be incomplete due to a missing table that is in the binary code
+    for (i = 0; i < BANDS; i++) {
         flcoeffs1[i] = 0;
-        if(levlCoeffBuf[i] < 16) {
+        if (levlCoeffBuf[i] < 16) {
             flcoeffs1[i] = imc_exp_tab2[levlCoeffBuf[i]] * old_floor[i];
             flcoeffs2[i] = (levlCoeffBuf[i]-7) * 0.83048 + flcoeffs2[i]; // 0.83048 = log2(10) * 0.25
         } else {
@@ -310,7 +315,9 @@ static void imc_decode_level_coefficients2(IMCContext* q, int* levlCoeffBuf, flo
 /**
  * Perform bit allocation depending on bits available
  */
-static int bit_allocation (IMCContext* q, int stream_format_code, int freebits, int flag) {
+static int bit_allocation(IMCContext* q, int stream_format_code, int freebits,
+                          int flag)
+{
     int i, j;
     const float limit = -1.e20;
     float highest = 0.0;
@@ -327,31 +334,31 @@ static int bit_allocation (IMCContext* q, int stream_format_code, int freebits,
     int flg;
     int found_indx = 0;

-    for(i = 0; i < BANDS; i++)
+    for (i = 0; i < BANDS; i++)
         highest = FFMAX(highest, q->flcoeffs1[i]);

-    for(i = 0; i < BANDS-1; i++) {
-        q->flcoeffs4[i] = q->flcoeffs3[i] - log(q->flcoeffs5[i])/log(2);
+    for (i = 0; i < BANDS-1; i++) {
+        q->flcoeffs4[i] = q->flcoeffs3[i] - log(q->flcoeffs5[i]) / log(2);
     }
     q->flcoeffs4[BANDS - 1] = limit;

     highest = highest * 0.25;

-    for(i = 0; i < BANDS; i++) {
+    for (i = 0; i < BANDS; i++) {
         indx = -1;
-        if ((band_tab[i+1] - band_tab[i]) == q->bandWidthT[i])
+        if ((band_tab[i + 1] - band_tab[i]) == q->bandWidthT[i])
             indx = 0;

-        if ((band_tab[i+1] - band_tab[i]) > q->bandWidthT[i])
+        if ((band_tab[i + 1] - band_tab[i]) > q->bandWidthT[i])
             indx = 1;

-        if (((band_tab[i+1] - band_tab[i])/2) >= q->bandWidthT[i])
+        if (((band_tab[i + 1] - band_tab[i])/2) >= q->bandWidthT[i])
             indx = 2;

         if (indx == -1)
             return AVERROR_INVALIDDATA;

-        q->flcoeffs4[i] = q->flcoeffs4[i] + xTab[(indx*2 + (q->flcoeffs1[i] < highest)) * 2 + flag];
+        q->flcoeffs4[i] += xTab[(indx*2 + (q->flcoeffs1[i] < highest)) * 2 + flag];
     }

     if (stream_format_code & 0x2) {
@@ -361,22 +368,22 @@ static int bit_allocation (IMCContext* q, int stream_format_code, int freebits,
         q->flcoeffs4[3] = limit;
     }

-    for(i = (stream_format_code & 0x2)?4:0; i < BANDS-1; i++) {
-        iacc += q->bandWidthT[i];
+    for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS - 1; i++) {
+        iacc  += q->bandWidthT[i];
         summa += q->bandWidthT[i] * q->flcoeffs4[i];
     }
     q->bandWidthT[BANDS-1] = 0;
     summa = (summa * 0.5 - freebits) / iacc;

 
-    for(i = 0; i < BANDS/2; i++) {
+    for (i = 0; i < BANDS/2; i++) {
         rres = summer - freebits;
-        if((rres >= -8) && (rres <= 8)) break;
+        if ((rres >= -8) && (rres <= 8)) break;

         summer = 0;
         iacc = 0;

-        for(j = (stream_format_code & 0x2)?4:0; j < BANDS; j++) {
+        for (j = (stream_format_code & 0x2) ? 4 : 0; j < BANDS; j++) {
             cwlen = av_clipf(((q->flcoeffs4[j] * 0.5) - summa + 0.5), 0, 6);

             q->bitsBandT[j] = cwlen;
@@ -392,32 +399,33 @@ static int bit_allocation (IMCContext* q, int stream_format_code, int freebits,
             t2 = -1;
         if (i == 0)
             flg = t2;
-        if(flg != t2)
+        if (flg != t2)
             t1++;

         summa = (float)(summer - freebits) / ((t1 + 1) * iacc) + summa;
     }

-    for(i = (stream_format_code & 0x2)?4:0; i < BANDS; i++) {
-        for(j = band_tab[i]; j < band_tab[i+1]; j++)
+    for (i = (stream_format_code & 0x2) ? 4 : 0; i < BANDS; i++) {
+        for (j = band_tab[i]; j < band_tab[i + 1]; j++)
             q->CWlengthT[j] = q->bitsBandT[i];
     }

     if (freebits > summer) {
-        for(i = 0; i < BANDS; i++) {
-            workT[i] = (q->bitsBandT[i] == 6) ? -1.e20 : (q->bitsBandT[i] * -2 + q->flcoeffs4[i] - 0.415);
+        for (i = 0; i < BANDS; i++) {
+            workT[i] = (q->bitsBandT[i] == 6) ? -1.e20
+                                              : (q->bitsBandT[i] * -2 + q->flcoeffs4[i] - 0.415);
         }

         highest = 0.0;

-        do{
+        do {
             if (highest <= -1.e20)
                 break;

             found_indx = 0;
             highest = -1.e20;

-            for(i = 0; i < BANDS; i++) {
+            for (i = 0; i < BANDS; i++) {
                 if (workT[i] > highest) {
                     highest = workT[i];
                     found_indx = i;
@@ -429,16 +437,17 @@ static int bit_allocation (IMCContext* q, int stream_format_code, int freebits,
                 if (++(q->bitsBandT[found_indx]) == 6)
                     workT[found_indx] = -1.e20;

-                for(j = band_tab[found_indx]; j < band_tab[found_indx+1] && (freebits > summer); j++){
+                for (j = band_tab[found_indx]; j < band_tab[found_indx + 1] && (freebits > summer); j++) {
                     q->CWlengthT[j]++;
                     summer++;
                 }
             }
-        }while (freebits > summer);
+        } while (freebits > summer);
     }
     if (freebits < summer) {
-        for(i = 0; i < BANDS; i++) {
-            workT[i] = q->bitsBandT[i] ? (q->bitsBandT[i] * -2 + q->flcoeffs4[i] + 1.585) : 1.e20;
+        for (i = 0; i < BANDS; i++) {
+            workT[i] = q->bitsBandT[i] ? (q->bitsBandT[i] * -2 + q->flcoeffs4[i] + 1.585)
+                                       : 1.e20;
         }
         if (stream_format_code & 0x2) {
             workT[0] = 1.e20;
@@ -446,23 +455,23 @@ static int bit_allocation (IMCContext* q, int stream_format_code, int freebits,
             workT[2] = 1.e20;
             workT[3] = 1.e20;
         }
-        while (freebits < summer){
-            lowest = 1.e10;
+        while (freebits < summer) {
+            lowest   = 1.e10;
             low_indx = 0;
-            for(i = 0; i < BANDS; i++) {
+            for (i = 0; i < BANDS; i++) {
                 if (workT[i] < lowest) {
-                    lowest = workT[i];
+                    lowest   = workT[i];
                     low_indx = i;
                 }
             }
-            //if(lowest >= 1.e10) break;
+            //if (lowest >= 1.e10) break;
             workT[low_indx] = lowest + 2.0;

             if (!(--q-≥bitsBandT[low_indx]))
                 workT[low_indx] = 1.e20;

-            for(j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++){
-                if(q->CWlengthT[j] > 0){
+            for (j = band_tab[low_indx]; j < band_tab[low_indx+1] && (freebits < summer); j++) {
+                if (q->CWlengthT[j] > 0) {
                     q->CWlengthT[j]--;
                     summer--;
                 }
@@ -472,49 +481,50 @@ static int bit_allocation (IMCContext* q, int stream_format_code, int freebits,
     return 0;
 }

-static void imc_get_skip_coeff(IMCContext* q) {
+static void imc_get_skip_coeff(IMCContext* q)
+{
     int i, j;

-    memset(q->skipFlagBits, 0, sizeof(q->skipFlagBits));
+    memset(q->skipFlagBits,  0, sizeof(q->skipFlagBits));
     memset(q->skipFlagCount, 0, sizeof(q->skipFlagCount));
-    for(i = 0; i < BANDS; i++) {
+    for (i = 0; i < BANDS; i++) {
         if (!q->bandFlagsBuf[i] || !q->bandWidthT[i])
             continue;

         if (!q->skipFlagRaw[i]) {
-            q->skipFlagBits[i] = band_tab[i+1] - band_tab[i];
+            q->skipFlagBits[i] = band_tab[i + 1] - band_tab[i];

-            for(j = band_tab[i]; j < band_tab[i+1]; j++) {
+            for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
                 if ((q->skipFlags[j] = get_bits1(&q->gb)))
                     q->skipFlagCount[i]++;
             }
         } else {
-            for(j = band_tab[i]; j < (band_tab[i+1]-1); j += 2) {
-                if(!get_bits1(&q->gb)){//0
+            for (j = band_tab[i]; j < (band_tab[i + 1]-1); j += 2) {
+                if (!get_bits1(&q->gb)) {//0
                     q->skipFlagBits[i]++;
-                    q->skipFlags[j]=1;
-                    q->skipFlags[j+1]=1;
+                    q->skipFlags[j]      = 1;
+                    q->skipFlags[j + 1]  = 1;
                     q->skipFlagCount[i] += 2;
-                }else{
-                    if(get_bits1(&q->gb)){//11
-                        q->skipFlagBits[i] +=2;
-                        q->skipFlags[j]=0;
-                        q->skipFlags[j+1]=1;
+                } else {
+                    if (get_bits1(&q->gb)) {//11
+                        q->skipFlagBits[i] += 2;
+                        q->skipFlags[j]     = 0;
+                        q->skipFlags[j + 1] = 1;
                         q->skipFlagCount[i]++;
-                    }else{
-                        q->skipFlagBits[i] +=3;
-                        q->skipFlags[j+1]=0;
-                        if(!get_bits1(&q->gb)){//100
-                            q->skipFlags[j]=1;
+                    } else {
+                        q->skipFlagBits[i] += 3;
+                        q->skipFlags[j + 1] = 0;
+                        if (!get_bits1(&q->gb)) {//100
+                            q->skipFlags[j] = 1;
                             q->skipFlagCount[i]++;
-                        }else{//101
+                        } else {//101
                             q->skipFlags[j]=0;
                         }
                     }
                 }
             }

-            if (j < band_tab[i+1]) {
+            if (j < band_tab[i + 1]) {
                 q->skipFlagBits[i]++;
                 if ((q->skipFlags[j] = get_bits1(&q->gb)))
                     q->skipFlagCount[i]++;
@@ -526,24 +536,26 @@ static void imc_get_skip_coeff(IMCContext* q) {
 /**
  * Increase highest' band coefficient sizes as some bits won't be used
  */
-static void imc_adjust_bit_allocation (IMCContext* q, int summer) {
+static void imc_adjust_bit_allocation(IMCContext* q, int summer)
+{
     float workT[32];
     int corrected = 0;
     int i, j;
-    float highest = 0;
-    int found_indx=0;
+    float highest  = 0;
+    int found_indx = 0;

-    for(i = 0; i < BANDS; i++) {
-        workT[i] = (q->bitsBandT[i] == 6) ? -1.e20 : (q->bitsBandT[i] * -2 + q->flcoeffs4[i] - 0.415);
+    for (i = 0; i < BANDS; i++) {
+        workT[i] = (q->bitsBandT[i] == 6) ? -1.e20
+                                          : (q->bitsBandT[i] * -2 + q->flcoeffs4[i] - 0.415);
     }

     while (corrected < summer) {
-        if(highest <= -1.e20)
+        if (highest <= -1.e20)
             break;

         highest = -1.e20;

-        for(i = 0; i < BANDS; i++) {
+        for (i = 0; i < BANDS; i++) {
             if (workT[i] > highest) {
                 highest = workT[i];
                 found_indx = i;
@@ -555,7 +567,7 @@ static void imc_adjust_bit_allocation (IMCContext* q, int summer) {
             if (++(q->bitsBandT[found_indx]) == 6)
                 workT[found_indx] = -1.e20;

-            for(j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
+            for (j = band_tab[found_indx]; j < band_tab[found_indx+1] && (corrected < summer); j++) {
                 if (!q->skipFlags[j] && (q->CWlengthT[j] < 6)) {
                     q->CWlengthT[j]++;
                     corrected++;
@@ -565,16 +577,17 @@ static void imc_adjust_bit_allocation (IMCContext* q, int summer) {
     }
 }

-static void imc_imdct256(IMCContext *q) {
+static void imc_imdct256(IMCContext *q)
+{
     int i;
     float re, im;

     /* prerotation */
-    for(i=0; i < COEFFS/2; i++){
-        q->samples[i].re = -(q->pre_coef1[i] * q->CWdecoded[COEFFS-1-i*2]) -
-                           (q->pre_coef2[i] * q->CWdecoded[i*2]);
-        q->samples[i].im = (q->pre_coef2[i] * q->CWdecoded[COEFFS-1-i*2]) -
-                           (q->pre_coef1[i] * q->CWdecoded[i*2]);
+    for (i=0; i < COEFFS/2; i++) {
+        q->samples[i].re = -(q->pre_coef1[i] * q->CWdecoded[COEFFS - 1 - i * 2]) -
+                            (q->pre_coef2[i] * q->CWdecoded[i * 2]);
+        q->samples[i].im =  (q->pre_coef2[i] * q->CWdecoded[COEFFS - 1 - i * 2]) -
+                            (q->pre_coef1[i] * q->CWdecoded[i * 2]);
     }

     /* FFT */
@@ -582,44 +595,47 @@ static void imc_imdct256(IMCContext *q) {
     q->fft.fft_calc   (&q->fft, q->samples);

     /* postrotation, window and reorder */
-    for(i = 0; i < COEFFS/2; i++){
-        re = (q->samples[i].re * q->post_cos[i]) + (-q-≥samples[i].im * q->post_sin[i]);
-        im = (-q-≥samples[i].im * q->post_cos[i]) - (q->samples[i].re * q->post_sin[i]);
-        q->out_samples[i*2] = (q->mdct_sine_window[COEFFS-1-i*2] * q->last_fft_im[i]) +
(q->mdct_sine_window[i*2] * re);
-        q->out_samples[COEFFS-1-i*2] = (q->mdct_sine_window[i*2] * q->last_fft_im[i]) -
(q->mdct_sine_window[COEFFS-1-i*2] * re);
+    for (i = 0; i < COEFFS/2; i++) {
+        re = ( q->samples[i].re * q->post_cos[i]) + (-q-≥samples[i].im * q->post_sin[i]);
+        im = (-q-≥samples[i].im * q->post_cos[i]) - ( q->samples[i].re * q->post_sin[i]);
+        q->out_samples[i * 2]              =  (q->mdct_sine_window[COEFFS - 1 - i * 2] * q->last_fft_im[i])
+                                            + (q->mdct_sine_window[i * 2] * re);
+        q->out_samples[COEFFS - 1 - i * 2] =  (q->mdct_sine_window[i * 2] * q->last_fft_im[i])
+                                            - (q->mdct_sine_window[COEFFS - 1 - i * 2] * re);
         q->last_fft_im[i] = im;
     }
 }

-static int inverse_quant_coeff (IMCContext* q, int stream_format_code) {
+static int inverse_quant_coeff(IMCContext* q, int stream_format_code)
+{
     int i, j;
     int middle_value, cw_len, max_size;
     const float* quantizer;

-    for(i = 0; i < BANDS; i++) {
-        for(j = band_tab[i]; j < band_tab[i+1]; j++) {
+    for (i = 0; i < BANDS; i++) {
+        for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
             q->CWdecoded[j] = 0;
             cw_len = q->CWlengthT[j];

             if (cw_len <= 0 || q->skipFlags[j])
                 continue;

-            max_size = 1 << cw_len;
+            max_size     = 1 << cw_len;
             middle_value = max_size >> 1;

             if (q->codewords[j] >= max_size || q->codewords[j] < 0)
                 return AVERROR_INVALIDDATA;

-            if (cw_len >= 4){
+            if (cw_len >= 4) {
                 quantizer = imc_quantizer2[(stream_format_code & 2) >> 1];
                 if (q->codewords[j] >= middle_value)
-                    q->CWdecoded[j] = quantizer[q->codewords[j] - 8] * q->flcoeffs6[i];
+                    q->CWdecoded[j] =  quantizer[q->codewords[j] - 8]                * q->flcoeffs6[i];
                 else
                     q->CWdecoded[j] = -quantizer[max_size - q->codewords[j] - 8 - 1] * q->flcoeffs6[i];
             }else{
                 quantizer = imc_quantizer1[((stream_format_code & 2) >> 1) | (q->bandFlagsBuf[i] << 1)];
                 if (q->codewords[j] >= middle_value)
-                    q->CWdecoded[j] = quantizer[q->codewords[j] - 1] * q->flcoeffs6[i];
+                    q->CWdecoded[j] =  quantizer[q->codewords[j] - 1]            * q->flcoeffs6[i];
                 else
                     q->CWdecoded[j] = -quantizer[max_size - 2 - q->codewords[j]] * q->flcoeffs6[i];
             }
@@ -629,22 +645,24 @@ static int inverse_quant_coeff (IMCContext* q, int stream_format_code) {
 }

 
-static int imc_get_coeffs (IMCContext* q) {
+static int imc_get_coeffs(IMCContext* q)
+{
     int i, j, cw_len, cw;

-    for(i = 0; i < BANDS; i++) {
-        if(!q->sumLenArr[i]) continue;
+    for (i = 0; i < BANDS; i++) {
+        if (!q->sumLenArr[i])
+            continue;
         if (q->bandFlagsBuf[i] || q->bandWidthT[i]) {
-            for(j = band_tab[i]; j < band_tab[i+1]; j++) {
+            for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
                 cw_len = q->CWlengthT[j];
                 cw = 0;

-                if (get_bits_count(&q->gb) + cw_len > 512){
+                if (get_bits_count(&q->gb) + cw_len > 512) {
 //av_log(NULL,0,"Band %i coeff %i cw_len %i\n",i,j,cw_len);
                     return AVERROR_INVALIDDATA;
                 }

-                if(cw_len && (!q->bandFlagsBuf[i] || !q->skipFlags[j]))
+                if (cw_len && (!q->bandFlagsBuf[i] || !q->skipFlags[j]))
                     cw = get_bits(&q->gb, cw_len);

                 q->codewords[j] = cw;
@@ -695,7 +713,7 @@ static int imc_decode_frame(AVCodecContext * avctx, void *data,
     }
     stream_format_code = get_bits(&q->gb, 3);

-    if(stream_format_code & 1){
+    if (stream_format_code & 1) {
         av_log(avctx, AV_LOG_ERROR, "Stream code format %X is not supported\n", stream_format_code);
         return AVERROR_INVALIDDATA;
     }
@@ -705,10 +723,12 @@ static int imc_decode_frame(AVCodecContext * avctx, void *data,
     if (stream_format_code & 0x04)
         q->decoder_reset = 1;

-    if(q->decoder_reset) {
+    if (q->decoder_reset) {
         memset(q->out_samples, 0, sizeof(q->out_samples));
-        for(i = 0; i < BANDS; i++)q->old_floor[i] = 1.0;
-        for(i = 0; i < COEFFS; i++)q->CWdecoded[i] = 0;
+        for (i = 0; i < BANDS; i++)
+             q->old_floor[i] = 1.0;
+        for (i = 0; i < COEFFS; i++)
+             q->CWdecoded[i] = 0;
         q->decoder_reset = 0;
     }

@@ -716,22 +736,22 @@ static int imc_decode_frame(AVCodecContext * avctx, void *data,
     imc_read_level_coeffs(q, stream_format_code, q->levlCoeffBuf);

     if (stream_format_code & 0x4)
-        imc_decode_level_coefficients(q, q->levlCoeffBuf, q->flcoeffs1, q->flcoeffs2);
+        imc_decode_level_coefficients (q, q->levlCoeffBuf, q->flcoeffs1, q->flcoeffs2);
     else
         imc_decode_level_coefficients2(q, q->levlCoeffBuf, q->old_floor, q->flcoeffs1, q->flcoeffs2);

     memcpy(q->old_floor, q->flcoeffs1, 32 * sizeof(float));

     counter = 0;
-    for (i=0 ; i<BANDS ; i++) {
+    for (i = 0; i < BANDS; i++) {
         if (q->levlCoeffBuf[i] == 16) {
             q->bandWidthT[i] = 0;
             counter++;
         } else
-            q->bandWidthT[i] = band_tab[i+1] - band_tab[i];
+            q->bandWidthT[i] = band_tab[i + 1] - band_tab[i];
     }
     memset(q->bandFlagsBuf, 0, BANDS * sizeof(int));
-    for(i = 0; i < BANDS-1; i++) {
+    for (i = 0; i < BANDS - 1; i++) {
         if (q->bandWidthT[i])
             q->bandFlagsBuf[i] = get_bits1(&q->gb);
     }
@@ -747,78 +767,79 @@ static int imc_decode_frame(AVCodecContext * avctx, void *data,
         q->CWlengthT[0] = 5;
         q->CWlengthT[1] = 5;
         q->CWlengthT[2] = 5;
-        for(i = 1; i < 4; i++){
+        for (i = 1; i < 4; i++) {
             bits = (q->levlCoeffBuf[i] == 16) ? 0 : 5;
             q->bitsBandT[i] = bits;
-            for(j = band_tab[i]; j < band_tab[i+1]; j++) {
+            for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
                 q->CWlengthT[j] = bits;
-                bitscount += bits;
+                bitscount      += bits;
             }
         }
     }

-    if((ret = bit_allocation (q, stream_format_code,
-                              512 - bitscount - get_bits_count(&q->gb), flag)) < 0) {
+    if ((ret = bit_allocation(q, stream_format_code,
+                              512 - bitscount - get_bits_count(&q->gb),
+                              flag)) < 0) {
         av_log(avctx, AV_LOG_ERROR, "Bit allocations failed\n");
         q->decoder_reset = 1;
         return ret;
     }

-    for(i = 0; i < BANDS; i++) {
-        q->sumLenArr[i] = 0;
+    for (i = 0; i < BANDS; i++) {
+        q->sumLenArr[i]   = 0;
         q->skipFlagRaw[i] = 0;
-        for(j = band_tab[i]; j < band_tab[i+1]; j++)
+        for (j = band_tab[i]; j < band_tab[i + 1]; j++)
             q->sumLenArr[i] += q->CWlengthT[j];
         if (q->bandFlagsBuf[i])
-            if( (((band_tab[i+1] - band_tab[i]) * 1.5) > q->sumLenArr[i]) && (q->sumLenArr[i] > 0))
+            if ((((band_tab[i + 1] - band_tab[i]) * 1.5) > q->sumLenArr[i]) && (q->sumLenArr[i] > 0))
                 q->skipFlagRaw[i] = 1;
     }

     imc_get_skip_coeff(q);

-    for(i = 0; i < BANDS; i++) {
+    for (i = 0; i < BANDS; i++) {
         q->flcoeffs6[i] = q->flcoeffs1[i];
         /* band has flag set and at least one coded coefficient */
-        if (q->bandFlagsBuf[i] && (band_tab[i+1] - band_tab[i]) != q->skipFlagCount[i]){
-                q->flcoeffs6[i] *= q->sqrt_tab[band_tab[i+1] - band_tab[i]] /
-                                   q->sqrt_tab[(band_tab[i+1] - band_tab[i] - q->skipFlagCount[i])];
+        if (q->bandFlagsBuf[i] && (band_tab[i + 1] - band_tab[i]) != q->skipFlagCount[i]) {
+            q->flcoeffs6[i] *= q->sqrt_tab[ band_tab[i + 1] - band_tab[i]] /
+                               q->sqrt_tab[(band_tab[i + 1] - band_tab[i] - q->skipFlagCount[i])];
         }
     }

     /* calculate bits left, bits needed and adjust bit allocation */
     bits = summer = 0;

-    for(i = 0; i < BANDS; i++) {
+    for (i = 0; i < BANDS; i++) {
         if (q->bandFlagsBuf[i]) {
-            for(j = band_tab[i]; j < band_tab[i+1]; j++) {
-                if(q->skipFlags[j]) {
+            for (j = band_tab[i]; j < band_tab[i + 1]; j++) {
+                if (q->skipFlags[j]) {
                     summer += q->CWlengthT[j];
                     q->CWlengthT[j] = 0;
                 }
             }
-            bits += q->skipFlagBits[i];
+            bits   += q->skipFlagBits[i];
             summer -= q->skipFlagBits[i];
         }
     }
     imc_adjust_bit_allocation(q, summer);

-    for(i = 0; i < BANDS; i++) {
+    for (i = 0; i < BANDS; i++) {
         q->sumLenArr[i] = 0;

-        for(j = band_tab[i]; j < band_tab[i+1]; j++)
+        for (j = band_tab[i]; j < band_tab[i + 1]; j++)
             if (!q->skipFlags[j])
                 q->sumLenArr[i] += q->CWlengthT[j];
     }

     memset(q->codewords, 0, sizeof(q->codewords));

-    if(imc_get_coeffs(q) < 0) {
+    if (imc_get_coeffs(q) < 0) {
         av_log(avctx, AV_LOG_ERROR, "Read coefficients failed\n");
         q->decoder_reset = 1;
         return AVERROR_INVALIDDATA;
     }

-    if(inverse_quant_coeff(q, stream_format_code) < 0) {
+    if (inverse_quant_coeff(q, stream_format_code) < 0) {
         av_log(avctx, AV_LOG_ERROR, "Inverse quantization of coefficients failed\n");
         q->decoder_reset = 1;
         return AVERROR_INVALIDDATA;
--

-- 
1.7.0.4