libavformat/4xm.c:186: error: Null Dereference
  pointer `fourxm->tracks` last assigned on line 106 could be null and is dereferenced at line 186, column 13.

libavformat/4xm.c:94:1: start of procedure fourxm_read_header()
92. }
93. 
94. static int fourxm_read_header(AVFormatContext *s)
    ^
95. {
96.     AVIOContext *pb = s->pb;

libavformat/4xm.c:96:5: 
94. static int fourxm_read_header(AVFormatContext *s)
95. {
96.     AVIOContext *pb = s->pb;
        ^
97.     unsigned int fourcc_tag;
98.     unsigned int size;

libavformat/4xm.c:100:5: 
 98.     unsigned int size;
 99.     int header_size;
100.     FourxmDemuxContext *fourxm = s->priv_data;
         ^
101.     unsigned char *header;
102.     int i, ret;

libavformat/4xm.c:105:5: 
103.     AVStream *st;
104. 
105.     fourxm->track_count = 0;
         ^
106.     fourxm->tracks = NULL;
107.     fourxm->fps = 1.0;

libavformat/4xm.c:106:5: 
104. 
105.     fourxm->track_count = 0;
106.     fourxm->tracks = NULL;
         ^
107.     fourxm->fps = 1.0;
108. 

libavformat/4xm.c:107:5: 
105.     fourxm->track_count = 0;
106.     fourxm->tracks = NULL;
107.     fourxm->fps = 1.0;
         ^
108. 
109.     /* skip the first 3 32-bit numbers */

libavformat/4xm.c:110:5: 
108. 
109.     /* skip the first 3 32-bit numbers */
110.     avio_skip(pb, 12);
         ^
111. 
112.     /* check for LIST-HEAD */

libavformat/avio.h:210:1: start of procedure avio_skip()
  208.  * @return new position or AVERROR.
  209.  */
  210. static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
       ^
  211. {
  212.     return avio_seek(s, offset, SEEK_CUR);

libavformat/avio.h:212:5: Skipping avio_seek(): empty list of specs
  210. static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
  211. {
  212.     return avio_seek(s, offset, SEEK_CUR);
           ^
  213. }
  214. 

libavformat/avio.h:213:1: return from a call to avio_skip
  211. {
  212.     return avio_seek(s, offset, SEEK_CUR);
  213. }
       ^
  214. 
  215. /**

libavformat/4xm.c:113:5: 
111. 
112.     /* check for LIST-HEAD */
113.     GET_LIST_HEADER();
         ^
114.     header_size = size - 4;
115.     if (fourcc_tag != HEAD_TAG || header_size < 0)

libavformat/aviobuf.c:519:1: start of procedure avio_rl32()
  517. }
  518. 
  519. unsigned int avio_rl32(AVIOContext *s)
       ^
  520. {
  521.     unsigned int val;

libavformat/aviobuf.c:522:5: 
  520. {
  521.     unsigned int val;
  522.     val = avio_rl16(s);
           ^
  523.     val |= avio_rl16(s) << 16;
  524.     return val;

libavformat/aviobuf.c:503:1: start of procedure avio_rl16()
    501. }
    502. 
    503. unsigned int avio_rl16(AVIOContext *s)
         ^
    504. {
    505.     unsigned int val;

libavformat/aviobuf.c:506:5: 
    504. {
    505.     unsigned int val;
    506.     val = avio_r8(s);
             ^
    507.     val |= avio_r8(s) << 8;
    508.     return val;

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:507:5: 
    505.     unsigned int val;
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
             ^
    508.     return val;
    509. }

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:508:5: 
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
    508.     return val;
             ^
    509. }
    510. 

libavformat/aviobuf.c:509:1: return from a call to avio_rl16
    507.     val |= avio_r8(s) << 8;
    508.     return val;
    509. }
         ^
    510. 
    511. unsigned int avio_rl24(AVIOContext *s)

libavformat/aviobuf.c:523:5: 
  521.     unsigned int val;
  522.     val = avio_rl16(s);
  523.     val |= avio_rl16(s) << 16;
           ^
  524.     return val;
  525. }

libavformat/aviobuf.c:503:1: start of procedure avio_rl16()
    501. }
    502. 
    503. unsigned int avio_rl16(AVIOContext *s)
         ^
    504. {
    505.     unsigned int val;

libavformat/aviobuf.c:506:5: 
    504. {
    505.     unsigned int val;
    506.     val = avio_r8(s);
             ^
    507.     val |= avio_r8(s) << 8;
    508.     return val;

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:507:5: 
    505.     unsigned int val;
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
             ^
    508.     return val;
    509. }

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:508:5: 
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
    508.     return val;
             ^
    509. }
    510. 

libavformat/aviobuf.c:509:1: return from a call to avio_rl16
    507.     val |= avio_r8(s) << 8;
    508.     return val;
    509. }
         ^
    510. 
    511. unsigned int avio_rl24(AVIOContext *s)

libavformat/aviobuf.c:524:5: 
  522.     val = avio_rl16(s);
  523.     val |= avio_rl16(s) << 16;
  524.     return val;
           ^
  525. }
  526. 

libavformat/aviobuf.c:525:1: return from a call to avio_rl32
  523.     val |= avio_rl16(s) << 16;
  524.     return val;
  525. }
       ^
  526. 
  527. uint64_t avio_rl64(AVIOContext *s)

libavformat/4xm.c:113:5: 
111. 
112.     /* check for LIST-HEAD */
113.     GET_LIST_HEADER();
         ^
114.     header_size = size - 4;
115.     if (fourcc_tag != HEAD_TAG || header_size < 0)

libavformat/aviobuf.c:519:1: start of procedure avio_rl32()
  517. }
  518. 
  519. unsigned int avio_rl32(AVIOContext *s)
       ^
  520. {
  521.     unsigned int val;

libavformat/aviobuf.c:522:5: 
  520. {
  521.     unsigned int val;
  522.     val = avio_rl16(s);
           ^
  523.     val |= avio_rl16(s) << 16;
  524.     return val;

libavformat/aviobuf.c:503:1: start of procedure avio_rl16()
    501. }
    502. 
    503. unsigned int avio_rl16(AVIOContext *s)
         ^
    504. {
    505.     unsigned int val;

libavformat/aviobuf.c:506:5: 
    504. {
    505.     unsigned int val;
    506.     val = avio_r8(s);
             ^
    507.     val |= avio_r8(s) << 8;
    508.     return val;

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:507:5: 
    505.     unsigned int val;
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
             ^
    508.     return val;
    509. }

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:508:5: 
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
    508.     return val;
             ^
    509. }
    510. 

libavformat/aviobuf.c:509:1: return from a call to avio_rl16
    507.     val |= avio_r8(s) << 8;
    508.     return val;
    509. }
         ^
    510. 
    511. unsigned int avio_rl24(AVIOContext *s)

libavformat/aviobuf.c:523:5: 
  521.     unsigned int val;
  522.     val = avio_rl16(s);
  523.     val |= avio_rl16(s) << 16;
           ^
  524.     return val;
  525. }

libavformat/aviobuf.c:503:1: start of procedure avio_rl16()
    501. }
    502. 
    503. unsigned int avio_rl16(AVIOContext *s)
         ^
    504. {
    505.     unsigned int val;

libavformat/aviobuf.c:506:5: 
    504. {
    505.     unsigned int val;
    506.     val = avio_r8(s);
             ^
    507.     val |= avio_r8(s) << 8;
    508.     return val;

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:507:5: 
    505.     unsigned int val;
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
             ^
    508.     return val;
    509. }

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:508:5: 
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
    508.     return val;
             ^
    509. }
    510. 

libavformat/aviobuf.c:509:1: return from a call to avio_rl16
    507.     val |= avio_r8(s) << 8;
    508.     return val;
    509. }
         ^
    510. 
    511. unsigned int avio_rl24(AVIOContext *s)

libavformat/aviobuf.c:524:5: 
  522.     val = avio_rl16(s);
  523.     val |= avio_rl16(s) << 16;
  524.     return val;
           ^
  525. }
  526. 

libavformat/aviobuf.c:525:1: return from a call to avio_rl32
  523.     val |= avio_rl16(s) << 16;
  524.     return val;
  525. }
       ^
  526. 
  527. uint64_t avio_rl64(AVIOContext *s)

libavformat/4xm.c:113:5: Taking false branch
111. 
112.     /* check for LIST-HEAD */
113.     GET_LIST_HEADER();
         ^
114.     header_size = size - 4;
115.     if (fourcc_tag != HEAD_TAG || header_size < 0)

libavformat/aviobuf.c:519:1: start of procedure avio_rl32()
  517. }
  518. 
  519. unsigned int avio_rl32(AVIOContext *s)
       ^
  520. {
  521.     unsigned int val;

libavformat/aviobuf.c:522:5: 
  520. {
  521.     unsigned int val;
  522.     val = avio_rl16(s);
           ^
  523.     val |= avio_rl16(s) << 16;
  524.     return val;

libavformat/aviobuf.c:503:1: start of procedure avio_rl16()
    501. }
    502. 
    503. unsigned int avio_rl16(AVIOContext *s)
         ^
    504. {
    505.     unsigned int val;

libavformat/aviobuf.c:506:5: 
    504. {
    505.     unsigned int val;
    506.     val = avio_r8(s);
             ^
    507.     val |= avio_r8(s) << 8;
    508.     return val;

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:507:5: 
    505.     unsigned int val;
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
             ^
    508.     return val;
    509. }

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:508:5: 
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
    508.     return val;
             ^
    509. }
    510. 

libavformat/aviobuf.c:509:1: return from a call to avio_rl16
    507.     val |= avio_r8(s) << 8;
    508.     return val;
    509. }
         ^
    510. 
    511. unsigned int avio_rl24(AVIOContext *s)

libavformat/aviobuf.c:523:5: 
  521.     unsigned int val;
  522.     val = avio_rl16(s);
  523.     val |= avio_rl16(s) << 16;
           ^
  524.     return val;
  525. }

libavformat/aviobuf.c:503:1: start of procedure avio_rl16()
    501. }
    502. 
    503. unsigned int avio_rl16(AVIOContext *s)
         ^
    504. {
    505.     unsigned int val;

libavformat/aviobuf.c:506:5: 
    504. {
    505.     unsigned int val;
    506.     val = avio_r8(s);
             ^
    507.     val |= avio_r8(s) << 8;
    508.     return val;

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:507:5: 
    505.     unsigned int val;
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
             ^
    508.     return val;
    509. }

libavformat/aviobuf.c:424:1: start of procedure avio_r8()
      422. 
      423. /* XXX: put an inline version */
      424. int avio_r8(AVIOContext *s)
           ^
      425. {
      426.     if (s->buf_ptr >= s->buf_end)

libavformat/aviobuf.c:426:9: Taking false branch
      424. int avio_r8(AVIOContext *s)
      425. {
      426.     if (s->buf_ptr >= s->buf_end)
                   ^
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)

libavformat/aviobuf.c:428:9: Taking true branch
      426.     if (s->buf_ptr >= s->buf_end)
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
                   ^
      429.         return *s->buf_ptr++;
      430.     return 0;

libavformat/aviobuf.c:429:9: 
      427.         fill_buffer(s);
      428.     if (s->buf_ptr < s->buf_end)
      429.         return *s->buf_ptr++;
                   ^
      430.     return 0;
      431. }

libavformat/aviobuf.c:431:1: return from a call to avio_r8
      429.         return *s->buf_ptr++;
      430.     return 0;
      431. }
           ^
      432. 
      433. int avio_read(AVIOContext *s, unsigned char *buf, int size)

libavformat/aviobuf.c:508:5: 
    506.     val = avio_r8(s);
    507.     val |= avio_r8(s) << 8;
    508.     return val;
             ^
    509. }
    510. 

libavformat/aviobuf.c:509:1: return from a call to avio_rl16
    507.     val |= avio_r8(s) << 8;
    508.     return val;
    509. }
         ^
    510. 
    511. unsigned int avio_rl24(AVIOContext *s)

libavformat/aviobuf.c:524:5: 
  522.     val = avio_rl16(s);
  523.     val |= avio_rl16(s) << 16;
  524.     return val;
           ^
  525. }
  526. 

libavformat/aviobuf.c:525:1: return from a call to avio_rl32
  523.     val |= avio_rl16(s) << 16;
  524.     return val;
  525. }
       ^
  526. 
  527. uint64_t avio_rl64(AVIOContext *s)

libavformat/4xm.c:114:5: 
112.     /* check for LIST-HEAD */
113.     GET_LIST_HEADER();
114.     header_size = size - 4;
         ^
115.     if (fourcc_tag != HEAD_TAG || header_size < 0)
116.         return AVERROR_INVALIDDATA;

libavformat/4xm.c:115:9: Taking false branch
113.     GET_LIST_HEADER();
114.     header_size = size - 4;
115.     if (fourcc_tag != HEAD_TAG || header_size < 0)
             ^
116.         return AVERROR_INVALIDDATA;
117. 

libavformat/4xm.c:115:35: Taking false branch
113.     GET_LIST_HEADER();
114.     header_size = size - 4;
115.     if (fourcc_tag != HEAD_TAG || header_size < 0)
                                       ^
116.         return AVERROR_INVALIDDATA;
117. 

libavformat/4xm.c:119:5: 
117. 
118.     /* allocate space for the header and load the whole thing */
119.     header = av_malloc(header_size);
         ^
120.     if (!header)
121.         return AVERROR(ENOMEM);

libavutil/mem.c:66:1: start of procedure av_malloc()
  64.  * linker will do it automatically. */
  65. 
  66. void *av_malloc(size_t size)
      ^
  67. {
  68.     void *ptr = NULL;

libavutil/mem.c:68:5: 
  66. void *av_malloc(size_t size)
  67. {
  68.     void *ptr = NULL;
          ^
  69. #if CONFIG_MEMALIGN_HACK
  70.     long diff;

libavutil/mem.c:74:9: Taking false branch
  72. 
  73.     /* let's disallow possible ambiguous cases */
  74.     if (size > (INT_MAX - 32) || !size)
              ^
  75.         return NULL;
  76. 

libavutil/mem.c:74:35: Taking false branch
  72. 
  73.     /* let's disallow possible ambiguous cases */
  74.     if (size > (INT_MAX - 32) || !size)
                                        ^
  75.         return NULL;
  76. 

libavutil/mem.c:85:9: Taking false branch
  83.     ((char *)ptr)[-1] = diff;
  84. #elif HAVE_POSIX_MEMALIGN
  85.     if (posix_memalign(&ptr, 32, size))
              ^
  86.         ptr = NULL;
  87. #elif HAVE_ALIGNED_MALLOC

libavutil/mem.c:118:5: 
  116.     ptr = malloc(size);
  117. #endif
  118.     return ptr;
           ^
  119. }
  120. 

libavutil/mem.c:119:1: return from a call to av_malloc
  117. #endif
  118.     return ptr;
  119. }
       ^
  120. 
  121. void *av_realloc(void *ptr, size_t size)

libavformat/4xm.c:120:10: Taking false branch
118.     /* allocate space for the header and load the whole thing */
119.     header = av_malloc(header_size);
120.     if (!header)
              ^
121.         return AVERROR(ENOMEM);
122.     if (avio_read(pb, header, header_size) != header_size){

libavformat/4xm.c:122:9: Taking false branch
120.     if (!header)
121.         return AVERROR(ENOMEM);
122.     if (avio_read(pb, header, header_size) != header_size){
             ^
123.         av_free(header);
124.         return AVERROR(EIO);

libavformat/4xm.c:128:10: 
126. 
127.     /* take the lazy approach and search for any and all vtrk and strk chunks */
128.     for (i = 0; i < header_size - 8; i++) {
              ^
129.         fourcc_tag = AV_RL32(&header[i]);
130.         size = AV_RL32(&header[i + 4]);

libavformat/4xm.c:128:17: Loop condition is true. Entering loop body
126. 
127.     /* take the lazy approach and search for any and all vtrk and strk chunks */
128.     for (i = 0; i < header_size - 8; i++) {
                     ^
129.         fourcc_tag = AV_RL32(&header[i]);
130.         size = AV_RL32(&header[i + 4]);

libavformat/4xm.c:129:9: 
127.     /* take the lazy approach and search for any and all vtrk and strk chunks */
128.     for (i = 0; i < header_size - 8; i++) {
129.         fourcc_tag = AV_RL32(&header[i]);
             ^
130.         size = AV_RL32(&header[i + 4]);
131. 

libavutil/ppc/intreadwrite.h:44:1: start of procedure AV_RL32()
  42. 
  43. #define AV_RL32 AV_RL32
  44. static av_always_inline uint32_t AV_RL32(const void *p)
      ^
  45. {
  46.     uint32_t v;

libavutil/ppc/intreadwrite.h:47:5: Skipping __infer_skip_gcc_asm_stmt(): function or method not found
  45. {
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
          ^
  48.     return v;
  49. }

libavutil/ppc/intreadwrite.h:48:5: 
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
          ^
  49. }
  50. 

libavutil/ppc/intreadwrite.h:49:1: return from a call to AV_RL32
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
  49. }
      ^
  50. 
  51. #define AV_WL32 AV_WL32

libavformat/4xm.c:130:9: 
128.     for (i = 0; i < header_size - 8; i++) {
129.         fourcc_tag = AV_RL32(&header[i]);
130.         size = AV_RL32(&header[i + 4]);
             ^
131. 
132.         if (fourcc_tag == std__TAG) {

libavutil/ppc/intreadwrite.h:44:1: start of procedure AV_RL32()
  42. 
  43. #define AV_RL32 AV_RL32
  44. static av_always_inline uint32_t AV_RL32(const void *p)
      ^
  45. {
  46.     uint32_t v;

libavutil/ppc/intreadwrite.h:47:5: Skipping __infer_skip_gcc_asm_stmt(): function or method not found
  45. {
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
          ^
  48.     return v;
  49. }

libavutil/ppc/intreadwrite.h:48:5: 
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
          ^
  49. }
  50. 

libavutil/ppc/intreadwrite.h:49:1: return from a call to AV_RL32
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
  49. }
      ^
  50. 
  51. #define AV_WL32 AV_WL32

libavformat/4xm.c:132:13: Taking false branch
130.         size = AV_RL32(&header[i + 4]);
131. 
132.         if (fourcc_tag == std__TAG) {
                 ^
133.             fourxm->fps = av_int2float(AV_RL32(&header[i + 12]));
134.         } else if (fourcc_tag == vtrk_TAG) {

libavformat/4xm.c:134:20: Taking false branch
132.         if (fourcc_tag == std__TAG) {
133.             fourxm->fps = av_int2float(AV_RL32(&header[i + 12]));
134.         } else if (fourcc_tag == vtrk_TAG) {
                        ^
135.             /* check that there is enough data */
136.             if (size != vtrk_SIZE) {

libavformat/4xm.c:162:20: Taking true branch
160. 
161.             i += 8 + size;
162.         } else if (fourcc_tag == strk_TAG) {
                        ^
163.             int current_track;
164.             /* check that there is enough data */

libavformat/4xm.c:165:17: Taking false branch
163.             int current_track;
164.             /* check that there is enough data */
165.             if (size != strk_SIZE) {
                     ^
166.                 ret= AVERROR_INVALIDDATA;
167.                 goto fail;

libavformat/4xm.c:169:13: 
167.                 goto fail;
168.             }
169.             current_track = AV_RL32(&header[i + 8]);
                 ^
170.             if((unsigned)current_track >= UINT_MAX / sizeof(AudioTrack) - 1){
171.                 av_log(s, AV_LOG_ERROR, "current_track too large\n");

libavutil/ppc/intreadwrite.h:44:1: start of procedure AV_RL32()
  42. 
  43. #define AV_RL32 AV_RL32
  44. static av_always_inline uint32_t AV_RL32(const void *p)
      ^
  45. {
  46.     uint32_t v;

libavutil/ppc/intreadwrite.h:47:5: Skipping __infer_skip_gcc_asm_stmt(): function or method not found
  45. {
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
          ^
  48.     return v;
  49. }

libavutil/ppc/intreadwrite.h:48:5: 
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
          ^
  49. }
  50. 

libavutil/ppc/intreadwrite.h:49:1: return from a call to AV_RL32
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
  49. }
      ^
  50. 
  51. #define AV_WL32 AV_WL32

libavformat/4xm.c:170:16: Taking false branch
168.             }
169.             current_track = AV_RL32(&header[i + 8]);
170.             if((unsigned)current_track >= UINT_MAX / sizeof(AudioTrack) - 1){
                    ^
171.                 av_log(s, AV_LOG_ERROR, "current_track too large\n");
172.                 ret= -1;

libavformat/4xm.c:175:17: Taking false branch
173.                 goto fail;
174.             }
175.             if (current_track + 1 > fourxm->track_count) {
                     ^
176.                 fourxm->tracks = av_realloc(fourxm->tracks,
177.                     (current_track + 1) * sizeof(AudioTrack));

libavformat/4xm.c:186:13: 
184.                 fourxm->track_count = current_track + 1;
185.             }
186.             fourxm->tracks[current_track].adpcm       = AV_RL32(&header[i + 12]);
                 ^
187.             fourxm->tracks[current_track].channels    = AV_RL32(&header[i + 36]);
188.             fourxm->tracks[current_track].sample_rate = AV_RL32(&header[i + 40]);

libavutil/ppc/intreadwrite.h:44:1: start of procedure AV_RL32()
  42. 
  43. #define AV_RL32 AV_RL32
  44. static av_always_inline uint32_t AV_RL32(const void *p)
      ^
  45. {
  46.     uint32_t v;

libavutil/ppc/intreadwrite.h:47:5: Skipping __infer_skip_gcc_asm_stmt(): function or method not found
  45. {
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
          ^
  48.     return v;
  49. }

libavutil/ppc/intreadwrite.h:48:5: 
  46.     uint32_t v;
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
          ^
  49. }
  50. 

libavutil/ppc/intreadwrite.h:49:1: return from a call to AV_RL32
  47.     __asm__ ("lwbrx   %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
  48.     return v;
  49. }
      ^
  50. 
  51. #define AV_WL32 AV_WL32
