libavcodec/smacker.c:313: error: Null Dereference
  pointer `smk->type_tbl` last assigned on line 312 could be null and is dereferenced at line 313, column 9.

libavcodec/smacker.c:275:1: start of procedure decode_header_trees()
273. }
274. 
275. static int decode_header_trees(SmackVContext *smk) {
     ^
276.     GetBitContext gb;
277.     int mmap_size, mclr_size, full_size, type_size;

libavcodec/smacker.c:279:5: 
277.     int mmap_size, mclr_size, full_size, type_size;
278. 
279.     mmap_size = AV_RL32(smk->avctx->extradata);
         ^
280.     mclr_size = AV_RL32(smk->avctx->extradata + 4);
281.     full_size = AV_RL32(smk->avctx->extradata + 8);

libavcodec/smacker.c:280:5: 
278. 
279.     mmap_size = AV_RL32(smk->avctx->extradata);
280.     mclr_size = AV_RL32(smk->avctx->extradata + 4);
         ^
281.     full_size = AV_RL32(smk->avctx->extradata + 8);
282.     type_size = AV_RL32(smk->avctx->extradata + 12);

libavcodec/smacker.c:281:5: 
279.     mmap_size = AV_RL32(smk->avctx->extradata);
280.     mclr_size = AV_RL32(smk->avctx->extradata + 4);
281.     full_size = AV_RL32(smk->avctx->extradata + 8);
         ^
282.     type_size = AV_RL32(smk->avctx->extradata + 12);
283. 

libavcodec/smacker.c:282:5: 
280.     mclr_size = AV_RL32(smk->avctx->extradata + 4);
281.     full_size = AV_RL32(smk->avctx->extradata + 8);
282.     type_size = AV_RL32(smk->avctx->extradata + 12);
         ^
283. 
284.     init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);

libavcodec/smacker.c:284:5: 
282.     type_size = AV_RL32(smk->avctx->extradata + 12);
283. 
284.     init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);
         ^
285. 
286.     if(!get_bits1(&gb)) {

libavcodec/bitstream.h:737:1: start of procedure init_get_bits()
  735.  * @param bit_size the size of the buffer in bits
  736.  */
  737. static inline void init_get_bits(GetBitContext *s,
       ^
  738.                    const uint8_t *buffer, int bit_size)
  739. {

libavcodec/bitstream.h:740:5: 
  738.                    const uint8_t *buffer, int bit_size)
  739. {
  740.     int buffer_size= (bit_size+7)>>3;
           ^
  741.     if(buffer_size < 0 || bit_size < 0) {
  742.         buffer_size = bit_size = 0;

libavcodec/bitstream.h:741:8: Taking false branch
  739. {
  740.     int buffer_size= (bit_size+7)>>3;
  741.     if(buffer_size < 0 || bit_size < 0) {
              ^
  742.         buffer_size = bit_size = 0;
  743.         buffer = NULL;

libavcodec/bitstream.h:741:27: Taking false branch
  739. {
  740.     int buffer_size= (bit_size+7)>>3;
  741.     if(buffer_size < 0 || bit_size < 0) {
                                 ^
  742.         buffer_size = bit_size = 0;
  743.         buffer = NULL;

libavcodec/bitstream.h:746:5: 
  744.     }
  745. 
  746.     s->buffer= buffer;
           ^
  747.     s->size_in_bits= bit_size;
  748.     s->buffer_end= buffer + buffer_size;

libavcodec/bitstream.h:747:5: 
  745. 
  746.     s->buffer= buffer;
  747.     s->size_in_bits= bit_size;
           ^
  748.     s->buffer_end= buffer + buffer_size;
  749. #ifdef ALT_BITSTREAM_READER

libavcodec/bitstream.h:748:5: 
  746.     s->buffer= buffer;
  747.     s->size_in_bits= bit_size;
  748.     s->buffer_end= buffer + buffer_size;
           ^
  749. #ifdef ALT_BITSTREAM_READER
  750.     s->index=0;

libavcodec/bitstream.h:750:5: 
  748.     s->buffer_end= buffer + buffer_size;
  749. #ifdef ALT_BITSTREAM_READER
  750.     s->index=0;
           ^
  751. #elif defined LIBMPEG2_BITSTREAM_READER
  752.     s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1));

libavcodec/bitstream.h:760:1: return from a call to init_get_bits
  758.     skip_bits_long(s, 0);
  759. #endif
  760. }
       ^
  761. 
  762. static inline void align_get_bits(GetBitContext *s)

libavcodec/smacker.c:286:9: 
284.     init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);
285. 
286.     if(!get_bits1(&gb)) {
             ^
287.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
288.         smk->mmap_tbl = av_malloc(sizeof(int) * 2);

libavcodec/bitstream.h:665:1: start of procedure get_bits1()
  663. }
  664. 
  665. static inline unsigned int get_bits1(GetBitContext *s){
       ^
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;

libavcodec/bitstream.h:667:5: 
  665. static inline unsigned int get_bits1(GetBitContext *s){
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
           ^
  668.     uint8_t result= s->buffer[ index>>3 ];
  669. #ifdef ALT_BITSTREAM_READER_LE

libavcodec/bitstream.h:668:5: 
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
  668.     uint8_t result= s->buffer[ index>>3 ];
           ^
  669. #ifdef ALT_BITSTREAM_READER_LE
  670.     result>>= (index&0x07);

libavcodec/bitstream.h:673:5: 
  671.     result&= 1;
  672. #else
  673.     result<<= (index&0x07);
           ^
  674.     result>>= 8 - 1;
  675. #endif

libavcodec/bitstream.h:674:5: 
  672. #else
  673.     result<<= (index&0x07);
  674.     result>>= 8 - 1;
           ^
  675. #endif
  676.     index++;

libavcodec/bitstream.h:676:5: 
  674.     result>>= 8 - 1;
  675. #endif
  676.     index++;
           ^
  677.     s->index= index;
  678. 

libavcodec/bitstream.h:677:5: 
  675. #endif
  676.     index++;
  677.     s->index= index;
           ^
  678. 
  679.     return result;

libavcodec/bitstream.h:679:5: 
  677.     s->index= index;
  678. 
  679.     return result;
           ^
  680. #else
  681.     return get_bits(s, 1);

libavcodec/bitstream.h:683:1: return from a call to get_bits1
  681.     return get_bits(s, 1);
  682. #endif
  683. }
       ^
  684. 
  685. static inline unsigned int show_bits1(GetBitContext *s){

libavcodec/smacker.c:286:9: Taking true branch
284.     init_get_bits(&gb, smk->avctx->extradata + 16, (smk->avctx->extradata_size - 16) * 8);
285. 
286.     if(!get_bits1(&gb)) {
             ^
287.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
288.         smk->mmap_tbl = av_malloc(sizeof(int) * 2);

libavcodec/smacker.c:287:9: Skipping av_log(): empty list of specs
285. 
286.     if(!get_bits1(&gb)) {
287.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
             ^
288.         smk->mmap_tbl = av_malloc(sizeof(int) * 2);
289.         smk->mmap_tbl[0] = 0;

libavcodec/smacker.c:288:9: 
286.     if(!get_bits1(&gb)) {
287.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
288.         smk->mmap_tbl = av_malloc(sizeof(int) * 2);
             ^
289.         smk->mmap_tbl[0] = 0;
290.         smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;

libavutil/mem.c:47:1: start of procedure av_malloc()
  45.    linker will do it automatically. */
  46. 
  47. void *av_malloc(unsigned int size)
      ^
  48. {
  49.     void *ptr = NULL;

libavutil/mem.c:49:5: 
  47. void *av_malloc(unsigned int size)
  48. {
  49.     void *ptr = NULL;
          ^
  50. #if CONFIG_MEMALIGN_HACK
  51.     long diff;

libavutil/mem.c:55:8: Taking false branch
  53. 
  54.     /* let's disallow possible ambiguous cases */
  55.     if(size > (INT_MAX-16) )
             ^
  56.         return NULL;
  57. 

libavutil/mem.c:66:9: Taking false branch
  64.     ((char*)ptr)[-1]= diff;
  65. #elif HAVE_POSIX_MEMALIGN
  66.     if (posix_memalign(&ptr,16,size))
              ^
  67.         ptr = NULL;
  68. #elif HAVE_MEMALIGN

libavutil/mem.c:99:5: 
   97.     ptr = malloc(size);
   98. #endif
   99.     return ptr;
           ^
  100. }
  101. 

libavutil/mem.c:100:1: return from a call to av_malloc
   98. #endif
   99.     return ptr;
  100. }
       ^
  101. 
  102. void *av_realloc(void *ptr, unsigned int size)

libavcodec/smacker.c:289:9: 
287.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MMAP tree\n");
288.         smk->mmap_tbl = av_malloc(sizeof(int) * 2);
289.         smk->mmap_tbl[0] = 0;
             ^
290.         smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
291.     } else {

libavcodec/smacker.c:290:9: 
288.         smk->mmap_tbl = av_malloc(sizeof(int) * 2);
289.         smk->mmap_tbl[0] = 0;
290.         smk->mmap_last[0] = smk->mmap_last[1] = smk->mmap_last[2] = 1;
             ^
291.     } else {
292.         smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);

libavcodec/smacker.c:294:9: 
292.         smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
293.     }
294.     if(!get_bits1(&gb)) {
             ^
295.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
296.         smk->mclr_tbl = av_malloc(sizeof(int) * 2);

libavcodec/bitstream.h:665:1: start of procedure get_bits1()
  663. }
  664. 
  665. static inline unsigned int get_bits1(GetBitContext *s){
       ^
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;

libavcodec/bitstream.h:667:5: 
  665. static inline unsigned int get_bits1(GetBitContext *s){
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
           ^
  668.     uint8_t result= s->buffer[ index>>3 ];
  669. #ifdef ALT_BITSTREAM_READER_LE

libavcodec/bitstream.h:668:5: 
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
  668.     uint8_t result= s->buffer[ index>>3 ];
           ^
  669. #ifdef ALT_BITSTREAM_READER_LE
  670.     result>>= (index&0x07);

libavcodec/bitstream.h:673:5: 
  671.     result&= 1;
  672. #else
  673.     result<<= (index&0x07);
           ^
  674.     result>>= 8 - 1;
  675. #endif

libavcodec/bitstream.h:674:5: 
  672. #else
  673.     result<<= (index&0x07);
  674.     result>>= 8 - 1;
           ^
  675. #endif
  676.     index++;

libavcodec/bitstream.h:676:5: 
  674.     result>>= 8 - 1;
  675. #endif
  676.     index++;
           ^
  677.     s->index= index;
  678. 

libavcodec/bitstream.h:677:5: 
  675. #endif
  676.     index++;
  677.     s->index= index;
           ^
  678. 
  679.     return result;

libavcodec/bitstream.h:679:5: 
  677.     s->index= index;
  678. 
  679.     return result;
           ^
  680. #else
  681.     return get_bits(s, 1);

libavcodec/bitstream.h:683:1: return from a call to get_bits1
  681.     return get_bits(s, 1);
  682. #endif
  683. }
       ^
  684. 
  685. static inline unsigned int show_bits1(GetBitContext *s){

libavcodec/smacker.c:294:9: Taking true branch
292.         smacker_decode_header_tree(smk, &gb, &smk->mmap_tbl, smk->mmap_last, mmap_size);
293.     }
294.     if(!get_bits1(&gb)) {
             ^
295.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
296.         smk->mclr_tbl = av_malloc(sizeof(int) * 2);

libavcodec/smacker.c:295:9: Skipping av_log(): empty list of specs
293.     }
294.     if(!get_bits1(&gb)) {
295.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
             ^
296.         smk->mclr_tbl = av_malloc(sizeof(int) * 2);
297.         smk->mclr_tbl[0] = 0;

libavcodec/smacker.c:296:9: 
294.     if(!get_bits1(&gb)) {
295.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
296.         smk->mclr_tbl = av_malloc(sizeof(int) * 2);
             ^
297.         smk->mclr_tbl[0] = 0;
298.         smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;

libavutil/mem.c:47:1: start of procedure av_malloc()
  45.    linker will do it automatically. */
  46. 
  47. void *av_malloc(unsigned int size)
      ^
  48. {
  49.     void *ptr = NULL;

libavutil/mem.c:49:5: 
  47. void *av_malloc(unsigned int size)
  48. {
  49.     void *ptr = NULL;
          ^
  50. #if CONFIG_MEMALIGN_HACK
  51.     long diff;

libavutil/mem.c:55:8: Taking false branch
  53. 
  54.     /* let's disallow possible ambiguous cases */
  55.     if(size > (INT_MAX-16) )
             ^
  56.         return NULL;
  57. 

libavutil/mem.c:66:9: Taking false branch
  64.     ((char*)ptr)[-1]= diff;
  65. #elif HAVE_POSIX_MEMALIGN
  66.     if (posix_memalign(&ptr,16,size))
              ^
  67.         ptr = NULL;
  68. #elif HAVE_MEMALIGN

libavutil/mem.c:99:5: 
   97.     ptr = malloc(size);
   98. #endif
   99.     return ptr;
           ^
  100. }
  101. 

libavutil/mem.c:100:1: return from a call to av_malloc
   98. #endif
   99.     return ptr;
  100. }
       ^
  101. 
  102. void *av_realloc(void *ptr, unsigned int size)

libavcodec/smacker.c:297:9: 
295.         av_log(smk->avctx, AV_LOG_INFO, "Skipping MCLR tree\n");
296.         smk->mclr_tbl = av_malloc(sizeof(int) * 2);
297.         smk->mclr_tbl[0] = 0;
             ^
298.         smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
299.     } else {

libavcodec/smacker.c:298:9: 
296.         smk->mclr_tbl = av_malloc(sizeof(int) * 2);
297.         smk->mclr_tbl[0] = 0;
298.         smk->mclr_last[0] = smk->mclr_last[1] = smk->mclr_last[2] = 1;
             ^
299.     } else {
300.         smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);

libavcodec/smacker.c:302:9: 
300.         smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
301.     }
302.     if(!get_bits1(&gb)) {
             ^
303.         av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
304.         smk->full_tbl = av_malloc(sizeof(int) * 2);

libavcodec/bitstream.h:665:1: start of procedure get_bits1()
  663. }
  664. 
  665. static inline unsigned int get_bits1(GetBitContext *s){
       ^
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;

libavcodec/bitstream.h:667:5: 
  665. static inline unsigned int get_bits1(GetBitContext *s){
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
           ^
  668.     uint8_t result= s->buffer[ index>>3 ];
  669. #ifdef ALT_BITSTREAM_READER_LE

libavcodec/bitstream.h:668:5: 
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
  668.     uint8_t result= s->buffer[ index>>3 ];
           ^
  669. #ifdef ALT_BITSTREAM_READER_LE
  670.     result>>= (index&0x07);

libavcodec/bitstream.h:673:5: 
  671.     result&= 1;
  672. #else
  673.     result<<= (index&0x07);
           ^
  674.     result>>= 8 - 1;
  675. #endif

libavcodec/bitstream.h:674:5: 
  672. #else
  673.     result<<= (index&0x07);
  674.     result>>= 8 - 1;
           ^
  675. #endif
  676.     index++;

libavcodec/bitstream.h:676:5: 
  674.     result>>= 8 - 1;
  675. #endif
  676.     index++;
           ^
  677.     s->index= index;
  678. 

libavcodec/bitstream.h:677:5: 
  675. #endif
  676.     index++;
  677.     s->index= index;
           ^
  678. 
  679.     return result;

libavcodec/bitstream.h:679:5: 
  677.     s->index= index;
  678. 
  679.     return result;
           ^
  680. #else
  681.     return get_bits(s, 1);

libavcodec/bitstream.h:683:1: return from a call to get_bits1
  681.     return get_bits(s, 1);
  682. #endif
  683. }
       ^
  684. 
  685. static inline unsigned int show_bits1(GetBitContext *s){

libavcodec/smacker.c:302:9: Taking true branch
300.         smacker_decode_header_tree(smk, &gb, &smk->mclr_tbl, smk->mclr_last, mclr_size);
301.     }
302.     if(!get_bits1(&gb)) {
             ^
303.         av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
304.         smk->full_tbl = av_malloc(sizeof(int) * 2);

libavcodec/smacker.c:303:9: Skipping av_log(): empty list of specs
301.     }
302.     if(!get_bits1(&gb)) {
303.         av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
             ^
304.         smk->full_tbl = av_malloc(sizeof(int) * 2);
305.         smk->full_tbl[0] = 0;

libavcodec/smacker.c:304:9: 
302.     if(!get_bits1(&gb)) {
303.         av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
304.         smk->full_tbl = av_malloc(sizeof(int) * 2);
             ^
305.         smk->full_tbl[0] = 0;
306.         smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;

libavutil/mem.c:47:1: start of procedure av_malloc()
  45.    linker will do it automatically. */
  46. 
  47. void *av_malloc(unsigned int size)
      ^
  48. {
  49.     void *ptr = NULL;

libavutil/mem.c:49:5: 
  47. void *av_malloc(unsigned int size)
  48. {
  49.     void *ptr = NULL;
          ^
  50. #if CONFIG_MEMALIGN_HACK
  51.     long diff;

libavutil/mem.c:55:8: Taking false branch
  53. 
  54.     /* let's disallow possible ambiguous cases */
  55.     if(size > (INT_MAX-16) )
             ^
  56.         return NULL;
  57. 

libavutil/mem.c:66:9: Taking false branch
  64.     ((char*)ptr)[-1]= diff;
  65. #elif HAVE_POSIX_MEMALIGN
  66.     if (posix_memalign(&ptr,16,size))
              ^
  67.         ptr = NULL;
  68. #elif HAVE_MEMALIGN

libavutil/mem.c:99:5: 
   97.     ptr = malloc(size);
   98. #endif
   99.     return ptr;
           ^
  100. }
  101. 

libavutil/mem.c:100:1: return from a call to av_malloc
   98. #endif
   99.     return ptr;
  100. }
       ^
  101. 
  102. void *av_realloc(void *ptr, unsigned int size)

libavcodec/smacker.c:305:9: 
303.         av_log(smk->avctx, AV_LOG_INFO, "Skipping FULL tree\n");
304.         smk->full_tbl = av_malloc(sizeof(int) * 2);
305.         smk->full_tbl[0] = 0;
             ^
306.         smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
307.     } else {

libavcodec/smacker.c:306:9: 
304.         smk->full_tbl = av_malloc(sizeof(int) * 2);
305.         smk->full_tbl[0] = 0;
306.         smk->full_last[0] = smk->full_last[1] = smk->full_last[2] = 1;
             ^
307.     } else {
308.         smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);

libavcodec/smacker.c:310:9: 
308.         smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
309.     }
310.     if(!get_bits1(&gb)) {
             ^
311.         av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
312.         smk->type_tbl = av_malloc(sizeof(int) * 2);

libavcodec/bitstream.h:665:1: start of procedure get_bits1()
  663. }
  664. 
  665. static inline unsigned int get_bits1(GetBitContext *s){
       ^
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;

libavcodec/bitstream.h:667:5: 
  665. static inline unsigned int get_bits1(GetBitContext *s){
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
           ^
  668.     uint8_t result= s->buffer[ index>>3 ];
  669. #ifdef ALT_BITSTREAM_READER_LE

libavcodec/bitstream.h:668:5: 
  666. #ifdef ALT_BITSTREAM_READER
  667.     int index= s->index;
  668.     uint8_t result= s->buffer[ index>>3 ];
           ^
  669. #ifdef ALT_BITSTREAM_READER_LE
  670.     result>>= (index&0x07);

libavcodec/bitstream.h:673:5: 
  671.     result&= 1;
  672. #else
  673.     result<<= (index&0x07);
           ^
  674.     result>>= 8 - 1;
  675. #endif

libavcodec/bitstream.h:674:5: 
  672. #else
  673.     result<<= (index&0x07);
  674.     result>>= 8 - 1;
           ^
  675. #endif
  676.     index++;

libavcodec/bitstream.h:676:5: 
  674.     result>>= 8 - 1;
  675. #endif
  676.     index++;
           ^
  677.     s->index= index;
  678. 

libavcodec/bitstream.h:677:5: 
  675. #endif
  676.     index++;
  677.     s->index= index;
           ^
  678. 
  679.     return result;

libavcodec/bitstream.h:679:5: 
  677.     s->index= index;
  678. 
  679.     return result;
           ^
  680. #else
  681.     return get_bits(s, 1);

libavcodec/bitstream.h:683:1: return from a call to get_bits1
  681.     return get_bits(s, 1);
  682. #endif
  683. }
       ^
  684. 
  685. static inline unsigned int show_bits1(GetBitContext *s){

libavcodec/smacker.c:310:9: Taking true branch
308.         smacker_decode_header_tree(smk, &gb, &smk->full_tbl, smk->full_last, full_size);
309.     }
310.     if(!get_bits1(&gb)) {
             ^
311.         av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
312.         smk->type_tbl = av_malloc(sizeof(int) * 2);

libavcodec/smacker.c:311:9: Skipping av_log(): empty list of specs
309.     }
310.     if(!get_bits1(&gb)) {
311.         av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
             ^
312.         smk->type_tbl = av_malloc(sizeof(int) * 2);
313.         smk->type_tbl[0] = 0;

libavcodec/smacker.c:312:9: 
310.     if(!get_bits1(&gb)) {
311.         av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
312.         smk->type_tbl = av_malloc(sizeof(int) * 2);
             ^
313.         smk->type_tbl[0] = 0;
314.         smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;

libavutil/mem.c:47:1: start of procedure av_malloc()
  45.    linker will do it automatically. */
  46. 
  47. void *av_malloc(unsigned int size)
      ^
  48. {
  49.     void *ptr = NULL;

libavutil/mem.c:49:5: 
  47. void *av_malloc(unsigned int size)
  48. {
  49.     void *ptr = NULL;
          ^
  50. #if CONFIG_MEMALIGN_HACK
  51.     long diff;

libavutil/mem.c:55:8: Taking false branch
  53. 
  54.     /* let's disallow possible ambiguous cases */
  55.     if(size > (INT_MAX-16) )
             ^
  56.         return NULL;
  57. 

libavutil/mem.c:66:9: Taking true branch
  64.     ((char*)ptr)[-1]= diff;
  65. #elif HAVE_POSIX_MEMALIGN
  66.     if (posix_memalign(&ptr,16,size))
              ^
  67.         ptr = NULL;
  68. #elif HAVE_MEMALIGN

libavutil/mem.c:67:9: 
  65. #elif HAVE_POSIX_MEMALIGN
  66.     if (posix_memalign(&ptr,16,size))
  67.         ptr = NULL;
              ^
  68. #elif HAVE_MEMALIGN
  69.     ptr = memalign(16,size);

libavutil/mem.c:99:5: 
   97.     ptr = malloc(size);
   98. #endif
   99.     return ptr;
           ^
  100. }
  101. 

libavutil/mem.c:100:1: return from a call to av_malloc
   98. #endif
   99.     return ptr;
  100. }
       ^
  101. 
  102. void *av_realloc(void *ptr, unsigned int size)

libavcodec/smacker.c:313:9: 
311.         av_log(smk->avctx, AV_LOG_INFO, "Skipping TYPE tree\n");
312.         smk->type_tbl = av_malloc(sizeof(int) * 2);
313.         smk->type_tbl[0] = 0;
             ^
314.         smk->type_last[0] = smk->type_last[1] = smk->type_last[2] = 1;
315.     } else {
