libavcodec/binkaudio.c:333: error: Memory Leak
  memory dynamically allocated by call to `av_realloc()` at line 314, column 15 is not reachable after line 333, column 9.

libavcodec/binkaudio.c:296:1: start of procedure decode_frame()
294. }
295. 
296. static int decode_frame(AVCodecContext *avctx, void *data,
     ^
297.                         int *got_frame_ptr, AVPacket *avpkt)
298. {

libavcodec/binkaudio.c:299:5: 
297.                         int *got_frame_ptr, AVPacket *avpkt)
298. {
299.     BinkAudioContext *s = avctx->priv_data;
         ^
300.     GetBitContext *gb = &s->gb;
301.     int ret, consumed = 0;

libavcodec/binkaudio.c:300:5: 
298. {
299.     BinkAudioContext *s = avctx->priv_data;
300.     GetBitContext *gb = &s->gb;
         ^
301.     int ret, consumed = 0;
302. 

libavcodec/binkaudio.c:301:5: 
299.     BinkAudioContext *s = avctx->priv_data;
300.     GetBitContext *gb = &s->gb;
301.     int ret, consumed = 0;
         ^
302. 
303.     if (!get_bits_left(gb)) {

libavcodec/binkaudio.c:303:10: 
301.     int ret, consumed = 0;
302. 
303.     if (!get_bits_left(gb)) {
              ^
304.         uint8_t *buf;
305.         /* handle end-of-stream */

libavcodec/get_bits.h:505:1: start of procedure get_bits_left()
  503. }
  504. 
  505. static inline int get_bits_left(GetBitContext *gb)
       ^
  506. {
  507.     return gb->size_in_bits - get_bits_count(gb);

libavcodec/get_bits.h:507:5: 
  505. static inline int get_bits_left(GetBitContext *gb)
  506. {
  507.     return gb->size_in_bits - get_bits_count(gb);
           ^
  508. }
  509. 

libavcodec/get_bits.h:192:1: start of procedure get_bits_count()
    190. #define GET_CACHE(name, gb) ((uint32_t)name##_cache)
    191. 
    192. static inline int get_bits_count(const GetBitContext *s)
         ^
    193. {
    194.     return s->index;

libavcodec/get_bits.h:194:5: 
    192. static inline int get_bits_count(const GetBitContext *s)
    193. {
    194.     return s->index;
             ^
    195. }
    196. 

libavcodec/get_bits.h:195:1: return from a call to get_bits_count
    193. {
    194.     return s->index;
    195. }
         ^
    196. 
    197. static inline void skip_bits_long(GetBitContext *s, int n){

libavcodec/get_bits.h:508:1: return from a call to get_bits_left
  506. {
  507.     return gb->size_in_bits - get_bits_count(gb);
  508. }
       ^
  509. 
  510. //#define TRACE

libavcodec/binkaudio.c:303:10: Taking true branch
301.     int ret, consumed = 0;
302. 
303.     if (!get_bits_left(gb)) {
              ^
304.         uint8_t *buf;
305.         /* handle end-of-stream */

libavcodec/binkaudio.c:306:14: Taking false branch
304.         uint8_t *buf;
305.         /* handle end-of-stream */
306.         if (!avpkt->size) {
                  ^
307.             *got_frame_ptr = 0;
308.             return 0;

libavcodec/binkaudio.c:310:13: Taking false branch
308.             return 0;
309.         }
310.         if (avpkt->size < 4) {
                 ^
311.             av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
312.             return AVERROR_INVALIDDATA;

libavcodec/binkaudio.c:314:9: 
312.             return AVERROR_INVALIDDATA;
313.         }
314.         buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
             ^
315.         if (!buf)
316.             return AVERROR(ENOMEM);

libavutil/mem.c:119:1: start of procedure av_realloc()
  117. }
  118. 
  119. void *av_realloc(void *ptr, size_t size)
       ^
  120. {
  121. #if CONFIG_MEMALIGN_HACK

libavutil/mem.c:126:8: Taking false branch
  124. 
  125.     /* let's disallow possible ambiguous cases */
  126.     if(size > (INT_MAX-16) )
              ^
  127.         return NULL;
  128. 

libavutil/mem.c:137:5: 
  135.     return _aligned_realloc(ptr, size, 32);
  136. #else
  137.     return realloc(ptr, size);
           ^
  138. #endif
  139. }

libavutil/mem.c:139:1: return from a call to av_realloc
  137.     return realloc(ptr, size);
  138. #endif
  139. }
       ^
  140. 
  141. void av_free(void *ptr)

libavcodec/binkaudio.c:315:14: Taking false branch
313.         }
314.         buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
315.         if (!buf)
                  ^
316.             return AVERROR(ENOMEM);
317.         s->packet_buffer = buf;

libavcodec/binkaudio.c:317:9: 
315.         if (!buf)
316.             return AVERROR(ENOMEM);
317.         s->packet_buffer = buf;
             ^
318.         memcpy(s->packet_buffer, avpkt->data, avpkt->size);
319.         init_get_bits(gb, s->packet_buffer, avpkt->size * 8);

libavcodec/binkaudio.c:318:9: 
316.             return AVERROR(ENOMEM);
317.         s->packet_buffer = buf;
318.         memcpy(s->packet_buffer, avpkt->data, avpkt->size);
             ^
319.         init_get_bits(gb, s->packet_buffer, avpkt->size * 8);
320.         consumed = avpkt->size;

libavcodec/binkaudio.c:319:9: 
317.         s->packet_buffer = buf;
318.         memcpy(s->packet_buffer, avpkt->data, avpkt->size);
319.         init_get_bits(gb, s->packet_buffer, avpkt->size * 8);
             ^
320.         consumed = avpkt->size;
321. 

libavcodec/get_bits.h:352:1: start of procedure init_get_bits()
  350.  * @param bit_size the size of the buffer in bits
  351.  */
  352. static inline void init_get_bits(GetBitContext *s, const uint8_t *buffer,
       ^
  353.                                  int bit_size)
  354. {

libavcodec/get_bits.h:355:5: 
  353.                                  int bit_size)
  354. {
  355.     int buffer_size = (bit_size+7)>>3;
           ^
  356.     if (buffer_size < 0 || bit_size < 0) {
  357.         buffer_size = bit_size = 0;

libavcodec/get_bits.h:356:9: Taking false branch
  354. {
  355.     int buffer_size = (bit_size+7)>>3;
  356.     if (buffer_size < 0 || bit_size < 0) {
               ^
  357.         buffer_size = bit_size = 0;
  358.         buffer = NULL;

libavcodec/get_bits.h:356:28: Taking false branch
  354. {
  355.     int buffer_size = (bit_size+7)>>3;
  356.     if (buffer_size < 0 || bit_size < 0) {
                                  ^
  357.         buffer_size = bit_size = 0;
  358.         buffer = NULL;

libavcodec/get_bits.h:361:5: 
  359.     }
  360. 
  361.     s->buffer       = buffer;
           ^
  362.     s->size_in_bits = bit_size;
  363. #if !UNCHECKED_BITSTREAM_READER

libavcodec/get_bits.h:362:5: 
  360. 
  361.     s->buffer       = buffer;
  362.     s->size_in_bits = bit_size;
           ^
  363. #if !UNCHECKED_BITSTREAM_READER
  364.     s->size_in_bits_plus8 = bit_size + 8;

libavcodec/get_bits.h:364:5: 
  362.     s->size_in_bits = bit_size;
  363. #if !UNCHECKED_BITSTREAM_READER
  364.     s->size_in_bits_plus8 = bit_size + 8;
           ^
  365. #endif
  366.     s->buffer_end   = buffer + buffer_size;

libavcodec/get_bits.h:366:5: 
  364.     s->size_in_bits_plus8 = bit_size + 8;
  365. #endif
  366.     s->buffer_end   = buffer + buffer_size;
           ^
  367.     s->index        = 0;
  368. }

libavcodec/get_bits.h:367:5: 
  365. #endif
  366.     s->buffer_end   = buffer + buffer_size;
  367.     s->index        = 0;
           ^
  368. }
  369. 

libavcodec/get_bits.h:368:1: return from a call to init_get_bits
  366.     s->buffer_end   = buffer + buffer_size;
  367.     s->index        = 0;
  368. }
       ^
  369. 
  370. static inline void align_get_bits(GetBitContext *s)

libavcodec/binkaudio.c:320:9: 
318.         memcpy(s->packet_buffer, avpkt->data, avpkt->size);
319.         init_get_bits(gb, s->packet_buffer, avpkt->size * 8);
320.         consumed = avpkt->size;
             ^
321. 
322.         /* skip reported size */

libavcodec/binkaudio.c:323:9: 
321. 
322.         /* skip reported size */
323.         skip_bits_long(gb, 32);
             ^
324.     }
325. 

libavcodec/get_bits.h:197:1: start of procedure skip_bits_long()
  195. }
  196. 
  197. static inline void skip_bits_long(GetBitContext *s, int n){
       ^
  198. #if UNCHECKED_BITSTREAM_READER
  199.     s->index += n;

libavcodec/get_bits.h:199:5: 
  197. static inline void skip_bits_long(GetBitContext *s, int n){
  198. #if UNCHECKED_BITSTREAM_READER
  199.     s->index += n;
           ^
  200. #else
  201.     s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);

libavcodec/get_bits.h:203:1: return from a call to skip_bits_long
  201.     s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
  202. #endif
  203. }
       ^
  204. 
  205. /**

libavcodec/binkaudio.c:327:5: 
325. 
326.     /* get output buffer */
327.     s->frame.nb_samples = s->frame_len;
         ^
328.     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
329.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

libavcodec/binkaudio.c:328:9: Taking false branch
326.     /* get output buffer */
327.     s->frame.nb_samples = s->frame_len;
328.     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
             ^
329.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
330.         return ret;

libavcodec/binkaudio.c:334:22: Condition is false
332. 
333.     if (decode_block(s, (float **)s->frame.extended_data,
334.                      avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {
                          ^
335.         av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
336.         return AVERROR_INVALIDDATA;

libavcodec/binkaudio.c:333:9: Skipping decode_block(): empty list of specs
331.     }
332. 
333.     if (decode_block(s, (float **)s->frame.extended_data,
             ^
334.                      avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {
335.         av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
