libavcodec/alacenc.c:486: error: Null Dereference
  pointer `s->pbctx.buf_ptr` last assigned on line 481 could be null and is dereferenced by call to `write_frame_header()` at line 486, column 9.

libavcodec/alacenc.c:463:1: start of procedure alac_encode_frame()
461. }
462. 
463. static int alac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
     ^
464.                              int buf_size, void *data)
465. {

libavcodec/alacenc.c:466:5: 
464.                              int buf_size, void *data)
465. {
466.     AlacEncodeContext *s = avctx->priv_data;
         ^
467.     PutBitContext *pb = &s->pbctx;
468.     int i, out_bytes, verbatim_flag = 0;

libavcodec/alacenc.c:467:5: 
465. {
466.     AlacEncodeContext *s = avctx->priv_data;
467.     PutBitContext *pb = &s->pbctx;
         ^
468.     int i, out_bytes, verbatim_flag = 0;
469. 

libavcodec/alacenc.c:468:5: 
466.     AlacEncodeContext *s = avctx->priv_data;
467.     PutBitContext *pb = &s->pbctx;
468.     int i, out_bytes, verbatim_flag = 0;
         ^
469. 
470.     if(avctx->frame_size > DEFAULT_FRAME_SIZE) {

libavcodec/alacenc.c:470:8: Taking false branch
468.     int i, out_bytes, verbatim_flag = 0;
469. 
470.     if(avctx->frame_size > DEFAULT_FRAME_SIZE) {
            ^
471.         av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n");
472.         return -1;

libavcodec/alacenc.c:475:8: Taking false branch
473.     }
474. 
475.     if(buf_size < 2*s->max_coded_frame_size) {
            ^
476.         av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n");
477.         return -1;

libavcodec/alacenc.c:508:9: 
506.         }
507.         verbatim_flag = 1;
508.         goto verbatim;
             ^
509.     }
510. 

libavcodec/alacenc.c:481:5: 
479. 
480. verbatim:
481.     init_put_bits(pb, frame, buf_size);
         ^
482. 
483.     if((s->compression_level == 0) || verbatim_flag) {

libavcodec/put_bits.h:60:1: start of procedure init_put_bits()
  58.  * @param buffer_size the size in bytes of buffer
  59.  */
  60. static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
      ^
  61. {
  62.     if(buffer_size < 0) {

libavcodec/put_bits.h:62:8: Taking true branch
  60. static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
  61. {
  62.     if(buffer_size < 0) {
             ^
  63.         buffer_size = 0;
  64.         buffer = NULL;

libavcodec/put_bits.h:63:9: 
  61. {
  62.     if(buffer_size < 0) {
  63.         buffer_size = 0;
              ^
  64.         buffer = NULL;
  65.     }

libavcodec/put_bits.h:64:9: 
  62.     if(buffer_size < 0) {
  63.         buffer_size = 0;
  64.         buffer = NULL;
              ^
  65.     }
  66. 

libavcodec/put_bits.h:67:5: 
  65.     }
  66. 
  67.     s->size_in_bits= 8*buffer_size;
          ^
  68.     s->buf = buffer;
  69.     s->buf_end = s->buf + buffer_size;

libavcodec/put_bits.h:68:5: 
  66. 
  67.     s->size_in_bits= 8*buffer_size;
  68.     s->buf = buffer;
          ^
  69.     s->buf_end = s->buf + buffer_size;
  70. #ifdef ALT_BITSTREAM_WRITER

libavcodec/put_bits.h:69:5: 
  67.     s->size_in_bits= 8*buffer_size;
  68.     s->buf = buffer;
  69.     s->buf_end = s->buf + buffer_size;
          ^
  70. #ifdef ALT_BITSTREAM_WRITER
  71.     s->index=0;

libavcodec/put_bits.h:75:5: 
  73. //    memset(buffer, 0, buffer_size);
  74. #else
  75.     s->buf_ptr = s->buf;
          ^
  76.     s->bit_left=32;
  77.     s->bit_buf=0;

libavcodec/put_bits.h:76:5: 
  74. #else
  75.     s->buf_ptr = s->buf;
  76.     s->bit_left=32;
          ^
  77.     s->bit_buf=0;
  78. #endif

libavcodec/put_bits.h:77:5: 
  75.     s->buf_ptr = s->buf;
  76.     s->bit_left=32;
  77.     s->bit_buf=0;
          ^
  78. #endif
  79. }

libavcodec/put_bits.h:79:1: return from a call to init_put_bits
  77.     s->bit_buf=0;
  78. #endif
  79. }
      ^
  80. 
  81. /**

libavcodec/alacenc.c:483:9: Taking true branch
481.     init_put_bits(pb, frame, buf_size);
482. 
483.     if((s->compression_level == 0) || verbatim_flag) {
             ^
484.         // Verbatim mode
485.         const int16_t *samples = data;

libavcodec/alacenc.c:485:9: 
483.     if((s->compression_level == 0) || verbatim_flag) {
484.         // Verbatim mode
485.         const int16_t *samples = data;
             ^
486.         write_frame_header(s, 1);
487.         for(i=0; i<avctx->frame_size*avctx->channels; i++) {

libavcodec/alacenc.c:486:9: 
484.         // Verbatim mode
485.         const int16_t *samples = data;
486.         write_frame_header(s, 1);
             ^
487.         for(i=0; i<avctx->frame_size*avctx->channels; i++) {
488.             put_sbits(pb, 16, *samples++);

libavcodec/alacenc.c:118:1: start of procedure write_frame_header()
  116. }
  117. 
  118. static void write_frame_header(AlacEncodeContext *s, int is_verbatim)
       ^
  119. {
  120.     put_bits(&s->pbctx, 3,  s->avctx->channels-1);          // No. of channels -1

libavcodec/alacenc.c:120:5: 
  118. static void write_frame_header(AlacEncodeContext *s, int is_verbatim)
  119. {
  120.     put_bits(&s->pbctx, 3,  s->avctx->channels-1);          // No. of channels -1
           ^
  121.     put_bits(&s->pbctx, 16, 0);                             // Seems to be zero
  122.     put_bits(&s->pbctx, 1,  1);                             // Sample count is in the header

libavcodec/put_bits.h:149:1: start of procedure put_bits()
    147.  * Use put_bits32 to write 32 bits.
    148.  */
    149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
         ^
    150. #ifndef ALT_BITSTREAM_WRITER
    151. {

libavcodec/put_bits.h:156:5: 
    154. 
    155.     //    printf("put_bits=%d %x\n", n, value);
    156.     assert(n <= 31 && value < (1U << n));
             ^
    157. 
    158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
    156.     assert(n <= 31 && value < (1U << n));
    157. 
    158.     bit_buf = s->bit_buf;
             ^
    159.     bit_left = s->bit_left;
    160. 

libavcodec/put_bits.h:159:5: 
    157. 
    158.     bit_buf = s->bit_buf;
    159.     bit_left = s->bit_left;
             ^
    160. 
    161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking false branch
    176.     bit_left-=n;
    177. #else
    178.     if (n < bit_left) {
                 ^
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;

libavcodec/put_bits.h:182:9: 
    180.         bit_left-=n;
    181.     } else {
    182.         bit_buf<<=bit_left;
                 ^
    183.         bit_buf |= value >> (n - bit_left);
    184. #if !HAVE_FAST_UNALIGNED

libavcodec/put_bits.h:183:9: 
    181.     } else {
    182.         bit_buf<<=bit_left;
    183.         bit_buf |= value >> (n - bit_left);
                 ^
    184. #if !HAVE_FAST_UNALIGNED
    185.         if (3 & (intptr_t) s->buf_ptr) {

libavcodec/put_bits.h:185:13: Taking false branch
    183.         bit_buf |= value >> (n - bit_left);
    184. #if !HAVE_FAST_UNALIGNED
    185.         if (3 & (intptr_t) s->buf_ptr) {
                     ^
    186.             AV_WB32(s->buf_ptr, bit_buf);
    187.         } else

libavcodec/put_bits.h:189:9: 
    187.         } else
    188. #endif
    189.         *(uint32_t *)s->buf_ptr = av_be2ne32(bit_buf);
                 ^
    190.         //printf("bitbuf = %08x\n", bit_buf);
    191.         s->buf_ptr+=4;

libavutil/bswap.h:66:1: start of procedure av_bswap32()
      64. 
      65. #ifndef av_bswap32
      66. static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
          ^
      67. {
      68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);

libavutil/bswap.h:68:5: 
      66. static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
      67. {
      68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
              ^
      69.     x= (x>>16) | (x<<16);
      70.     return x;

libavutil/bswap.h:69:5: 
      67. {
      68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
      69.     x= (x>>16) | (x<<16);
              ^
      70.     return x;
      71. }

libavutil/bswap.h:70:5: 
      68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
      69.     x= (x>>16) | (x<<16);
      70.     return x;
              ^
      71. }
      72. #endif

libavutil/bswap.h:71:1: return from a call to av_bswap32
      69.     x= (x>>16) | (x<<16);
      70.     return x;
      71. }
          ^
      72. #endif
      73. 

libavcodec/put_bits.h:191:9: 
    189.         *(uint32_t *)s->buf_ptr = av_be2ne32(bit_buf);
    190.         //printf("bitbuf = %08x\n", bit_buf);
    191.         s->buf_ptr+=4;
                 ^
    192.         bit_left+=32 - n;
    193.         bit_buf = value;

libavcodec/put_bits.h:192:9: 
    190.         //printf("bitbuf = %08x\n", bit_buf);
    191.         s->buf_ptr+=4;
    192.         bit_left+=32 - n;
                 ^
    193.         bit_buf = value;
    194.     }

libavcodec/put_bits.h:193:9: 
    191.         s->buf_ptr+=4;
    192.         bit_left+=32 - n;
    193.         bit_buf = value;
                 ^
    194.     }
    195. #endif

libavcodec/put_bits.h:197:5: 
    195. #endif
    196. 
    197.     s->bit_buf = bit_buf;
             ^
    198.     s->bit_left = bit_left;
    199. }

libavcodec/put_bits.h:198:5: 
    196. 
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
             ^
    199. }
    200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
    199. }
         ^
    200. #else  /* ALT_BITSTREAM_WRITER defined */
    201. {

libavcodec/alacenc.c:121:5: 
  119. {
  120.     put_bits(&s->pbctx, 3,  s->avctx->channels-1);          // No. of channels -1
  121.     put_bits(&s->pbctx, 16, 0);                             // Seems to be zero
           ^
  122.     put_bits(&s->pbctx, 1,  1);                             // Sample count is in the header
  123.     put_bits(&s->pbctx, 2,  0);                             // FIXME: Wasted bytes field

libavcodec/put_bits.h:149:1: start of procedure put_bits()
    147.  * Use put_bits32 to write 32 bits.
    148.  */
    149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
         ^
    150. #ifndef ALT_BITSTREAM_WRITER
    151. {

libavcodec/put_bits.h:156:5: 
    154. 
    155.     //    printf("put_bits=%d %x\n", n, value);
    156.     assert(n <= 31 && value < (1U << n));
             ^
    157. 
    158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
    156.     assert(n <= 31 && value < (1U << n));
    157. 
    158.     bit_buf = s->bit_buf;
             ^
    159.     bit_left = s->bit_left;
    160. 

libavcodec/put_bits.h:159:5: 
    157. 
    158.     bit_buf = s->bit_buf;
    159.     bit_left = s->bit_left;
             ^
    160. 
    161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking true branch
    176.     bit_left-=n;
    177. #else
    178.     if (n < bit_left) {
                 ^
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;

libavcodec/put_bits.h:179:9: 
    177. #else
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
                 ^
    180.         bit_left-=n;
    181.     } else {

libavcodec/put_bits.h:180:9: 
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;
                 ^
    181.     } else {
    182.         bit_buf<<=bit_left;

libavcodec/put_bits.h:197:5: 
    195. #endif
    196. 
    197.     s->bit_buf = bit_buf;
             ^
    198.     s->bit_left = bit_left;
    199. }

libavcodec/put_bits.h:198:5: 
    196. 
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
             ^
    199. }
    200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
    199. }
         ^
    200. #else  /* ALT_BITSTREAM_WRITER defined */
    201. {

libavcodec/alacenc.c:122:5: 
  120.     put_bits(&s->pbctx, 3,  s->avctx->channels-1);          // No. of channels -1
  121.     put_bits(&s->pbctx, 16, 0);                             // Seems to be zero
  122.     put_bits(&s->pbctx, 1,  1);                             // Sample count is in the header
           ^
  123.     put_bits(&s->pbctx, 2,  0);                             // FIXME: Wasted bytes field
  124.     put_bits(&s->pbctx, 1,  is_verbatim);                   // Audio block is verbatim

libavcodec/put_bits.h:149:1: start of procedure put_bits()
    147.  * Use put_bits32 to write 32 bits.
    148.  */
    149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
         ^
    150. #ifndef ALT_BITSTREAM_WRITER
    151. {

libavcodec/put_bits.h:156:5: 
    154. 
    155.     //    printf("put_bits=%d %x\n", n, value);
    156.     assert(n <= 31 && value < (1U << n));
             ^
    157. 
    158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
    156.     assert(n <= 31 && value < (1U << n));
    157. 
    158.     bit_buf = s->bit_buf;
             ^
    159.     bit_left = s->bit_left;
    160. 

libavcodec/put_bits.h:159:5: 
    157. 
    158.     bit_buf = s->bit_buf;
    159.     bit_left = s->bit_left;
             ^
    160. 
    161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking true branch
    176.     bit_left-=n;
    177. #else
    178.     if (n < bit_left) {
                 ^
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;

libavcodec/put_bits.h:179:9: 
    177. #else
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
                 ^
    180.         bit_left-=n;
    181.     } else {

libavcodec/put_bits.h:180:9: 
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;
                 ^
    181.     } else {
    182.         bit_buf<<=bit_left;

libavcodec/put_bits.h:197:5: 
    195. #endif
    196. 
    197.     s->bit_buf = bit_buf;
             ^
    198.     s->bit_left = bit_left;
    199. }

libavcodec/put_bits.h:198:5: 
    196. 
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
             ^
    199. }
    200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
    199. }
         ^
    200. #else  /* ALT_BITSTREAM_WRITER defined */
    201. {

libavcodec/alacenc.c:123:5: 
  121.     put_bits(&s->pbctx, 16, 0);                             // Seems to be zero
  122.     put_bits(&s->pbctx, 1,  1);                             // Sample count is in the header
  123.     put_bits(&s->pbctx, 2,  0);                             // FIXME: Wasted bytes field
           ^
  124.     put_bits(&s->pbctx, 1,  is_verbatim);                   // Audio block is verbatim
  125.     put_bits32(&s->pbctx, s->avctx->frame_size);            // No. of samples in the frame

libavcodec/put_bits.h:149:1: start of procedure put_bits()
    147.  * Use put_bits32 to write 32 bits.
    148.  */
    149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
         ^
    150. #ifndef ALT_BITSTREAM_WRITER
    151. {

libavcodec/put_bits.h:156:5: 
    154. 
    155.     //    printf("put_bits=%d %x\n", n, value);
    156.     assert(n <= 31 && value < (1U << n));
             ^
    157. 
    158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
    156.     assert(n <= 31 && value < (1U << n));
    157. 
    158.     bit_buf = s->bit_buf;
             ^
    159.     bit_left = s->bit_left;
    160. 

libavcodec/put_bits.h:159:5: 
    157. 
    158.     bit_buf = s->bit_buf;
    159.     bit_left = s->bit_left;
             ^
    160. 
    161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking true branch
    176.     bit_left-=n;
    177. #else
    178.     if (n < bit_left) {
                 ^
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;

libavcodec/put_bits.h:179:9: 
    177. #else
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
                 ^
    180.         bit_left-=n;
    181.     } else {

libavcodec/put_bits.h:180:9: 
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;
                 ^
    181.     } else {
    182.         bit_buf<<=bit_left;

libavcodec/put_bits.h:197:5: 
    195. #endif
    196. 
    197.     s->bit_buf = bit_buf;
             ^
    198.     s->bit_left = bit_left;
    199. }

libavcodec/put_bits.h:198:5: 
    196. 
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
             ^
    199. }
    200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
    199. }
         ^
    200. #else  /* ALT_BITSTREAM_WRITER defined */
    201. {

libavcodec/alacenc.c:124:5: 
  122.     put_bits(&s->pbctx, 1,  1);                             // Sample count is in the header
  123.     put_bits(&s->pbctx, 2,  0);                             // FIXME: Wasted bytes field
  124.     put_bits(&s->pbctx, 1,  is_verbatim);                   // Audio block is verbatim
           ^
  125.     put_bits32(&s->pbctx, s->avctx->frame_size);            // No. of samples in the frame
  126. }

libavcodec/put_bits.h:149:1: start of procedure put_bits()
    147.  * Use put_bits32 to write 32 bits.
    148.  */
    149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
         ^
    150. #ifndef ALT_BITSTREAM_WRITER
    151. {

libavcodec/put_bits.h:156:5: 
    154. 
    155.     //    printf("put_bits=%d %x\n", n, value);
    156.     assert(n <= 31 && value < (1U << n));
             ^
    157. 
    158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
    156.     assert(n <= 31 && value < (1U << n));
    157. 
    158.     bit_buf = s->bit_buf;
             ^
    159.     bit_left = s->bit_left;
    160. 

libavcodec/put_bits.h:159:5: 
    157. 
    158.     bit_buf = s->bit_buf;
    159.     bit_left = s->bit_left;
             ^
    160. 
    161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking true branch
    176.     bit_left-=n;
    177. #else
    178.     if (n < bit_left) {
                 ^
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;

libavcodec/put_bits.h:179:9: 
    177. #else
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
                 ^
    180.         bit_left-=n;
    181.     } else {

libavcodec/put_bits.h:180:9: 
    178.     if (n < bit_left) {
    179.         bit_buf = (bit_buf<<n) | value;
    180.         bit_left-=n;
                 ^
    181.     } else {
    182.         bit_buf<<=bit_left;

libavcodec/put_bits.h:197:5: 
    195. #endif
    196. 
    197.     s->bit_buf = bit_buf;
             ^
    198.     s->bit_left = bit_left;
    199. }

libavcodec/put_bits.h:198:5: 
    196. 
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
             ^
    199. }
    200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
    197.     s->bit_buf = bit_buf;
    198.     s->bit_left = bit_left;
    199. }
         ^
    200. #else  /* ALT_BITSTREAM_WRITER defined */
    201. {

libavcodec/alacenc.c:125:5: 
  123.     put_bits(&s->pbctx, 2,  0);                             // FIXME: Wasted bytes field
  124.     put_bits(&s->pbctx, 1,  is_verbatim);                   // Audio block is verbatim
  125.     put_bits32(&s->pbctx, s->avctx->frame_size);            // No. of samples in the frame
           ^
  126. }
  127. 

libavcodec/put_bits.h:275:1: start of procedure put_bits32()
    273.  * Write exactly 32 bits into a bitstream.
    274.  */
    275. static void av_unused put_bits32(PutBitContext *s, uint32_t value)
         ^
    276. {
    277.     int lo = value & 0xffff;

libavcodec/put_bits.h:277:5: 
    275. static void av_unused put_bits32(PutBitContext *s, uint32_t value)
    276. {
    277.     int lo = value & 0xffff;
             ^
    278.     int hi = value >> 16;
    279. #ifdef BITSTREAM_WRITER_LE

libavcodec/put_bits.h:278:5: 
    276. {
    277.     int lo = value & 0xffff;
    278.     int hi = value >> 16;
             ^
    279. #ifdef BITSTREAM_WRITER_LE
    280.     put_bits(s, 16, lo);

libavcodec/put_bits.h:280:5: 
    278.     int hi = value >> 16;
    279. #ifdef BITSTREAM_WRITER_LE
    280.     put_bits(s, 16, lo);
             ^
    281.     put_bits(s, 16, hi);
    282. #else

libavcodec/put_bits.h:149:1: start of procedure put_bits()
      147.  * Use put_bits32 to write 32 bits.
      148.  */
      149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
           ^
      150. #ifndef ALT_BITSTREAM_WRITER
      151. {

libavcodec/put_bits.h:156:5: 
      154. 
      155.     //    printf("put_bits=%d %x\n", n, value);
      156.     assert(n <= 31 && value < (1U << n));
               ^
      157. 
      158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
      156.     assert(n <= 31 && value < (1U << n));
      157. 
      158.     bit_buf = s->bit_buf;
               ^
      159.     bit_left = s->bit_left;
      160. 

libavcodec/put_bits.h:159:5: 
      157. 
      158.     bit_buf = s->bit_buf;
      159.     bit_left = s->bit_left;
               ^
      160. 
      161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking true branch
      176.     bit_left-=n;
      177. #else
      178.     if (n < bit_left) {
                   ^
      179.         bit_buf = (bit_buf<<n) | value;
      180.         bit_left-=n;

libavcodec/put_bits.h:179:9: 
      177. #else
      178.     if (n < bit_left) {
      179.         bit_buf = (bit_buf<<n) | value;
                   ^
      180.         bit_left-=n;
      181.     } else {

libavcodec/put_bits.h:180:9: 
      178.     if (n < bit_left) {
      179.         bit_buf = (bit_buf<<n) | value;
      180.         bit_left-=n;
                   ^
      181.     } else {
      182.         bit_buf<<=bit_left;

libavcodec/put_bits.h:197:5: 
      195. #endif
      196. 
      197.     s->bit_buf = bit_buf;
               ^
      198.     s->bit_left = bit_left;
      199. }

libavcodec/put_bits.h:198:5: 
      196. 
      197.     s->bit_buf = bit_buf;
      198.     s->bit_left = bit_left;
               ^
      199. }
      200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
      197.     s->bit_buf = bit_buf;
      198.     s->bit_left = bit_left;
      199. }
           ^
      200. #else  /* ALT_BITSTREAM_WRITER defined */
      201. {

libavcodec/put_bits.h:281:5: 
    279. #ifdef BITSTREAM_WRITER_LE
    280.     put_bits(s, 16, lo);
    281.     put_bits(s, 16, hi);
             ^
    282. #else
    283.     put_bits(s, 16, hi);

libavcodec/put_bits.h:149:1: start of procedure put_bits()
      147.  * Use put_bits32 to write 32 bits.
      148.  */
      149. static inline void put_bits(PutBitContext *s, int n, unsigned int value)
           ^
      150. #ifndef ALT_BITSTREAM_WRITER
      151. {

libavcodec/put_bits.h:156:5: 
      154. 
      155.     //    printf("put_bits=%d %x\n", n, value);
      156.     assert(n <= 31 && value < (1U << n));
               ^
      157. 
      158.     bit_buf = s->bit_buf;

libavcodec/put_bits.h:158:5: 
      156.     assert(n <= 31 && value < (1U << n));
      157. 
      158.     bit_buf = s->bit_buf;
               ^
      159.     bit_left = s->bit_left;
      160. 

libavcodec/put_bits.h:159:5: 
      157. 
      158.     bit_buf = s->bit_buf;
      159.     bit_left = s->bit_left;
               ^
      160. 
      161.     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);

libavcodec/put_bits.h:178:9: Taking false branch
      176.     bit_left-=n;
      177. #else
      178.     if (n < bit_left) {
                   ^
      179.         bit_buf = (bit_buf<<n) | value;
      180.         bit_left-=n;

libavcodec/put_bits.h:182:9: 
      180.         bit_left-=n;
      181.     } else {
      182.         bit_buf<<=bit_left;
                   ^
      183.         bit_buf |= value >> (n - bit_left);
      184. #if !HAVE_FAST_UNALIGNED

libavcodec/put_bits.h:183:9: 
      181.     } else {
      182.         bit_buf<<=bit_left;
      183.         bit_buf |= value >> (n - bit_left);
                   ^
      184. #if !HAVE_FAST_UNALIGNED
      185.         if (3 & (intptr_t) s->buf_ptr) {

libavcodec/put_bits.h:185:13: Taking false branch
      183.         bit_buf |= value >> (n - bit_left);
      184. #if !HAVE_FAST_UNALIGNED
      185.         if (3 & (intptr_t) s->buf_ptr) {
                       ^
      186.             AV_WB32(s->buf_ptr, bit_buf);
      187.         } else

libavcodec/put_bits.h:189:9: 
      187.         } else
      188. #endif
      189.         *(uint32_t *)s->buf_ptr = av_be2ne32(bit_buf);
                   ^
      190.         //printf("bitbuf = %08x\n", bit_buf);
      191.         s->buf_ptr+=4;

libavutil/bswap.h:66:1: start of procedure av_bswap32()
        64. 
        65. #ifndef av_bswap32
        66. static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
            ^
        67. {
        68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);

libavutil/bswap.h:68:5: 
        66. static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
        67. {
        68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
                ^
        69.     x= (x>>16) | (x<<16);
        70.     return x;

libavutil/bswap.h:69:5: 
        67. {
        68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
        69.     x= (x>>16) | (x<<16);
                ^
        70.     return x;
        71. }

libavutil/bswap.h:70:5: 
        68.     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
        69.     x= (x>>16) | (x<<16);
        70.     return x;
                ^
        71. }
        72. #endif

libavutil/bswap.h:71:1: return from a call to av_bswap32
        69.     x= (x>>16) | (x<<16);
        70.     return x;
        71. }
            ^
        72. #endif
        73. 

libavcodec/put_bits.h:191:9: 
      189.         *(uint32_t *)s->buf_ptr = av_be2ne32(bit_buf);
      190.         //printf("bitbuf = %08x\n", bit_buf);
      191.         s->buf_ptr+=4;
                   ^
      192.         bit_left+=32 - n;
      193.         bit_buf = value;

libavcodec/put_bits.h:192:9: 
      190.         //printf("bitbuf = %08x\n", bit_buf);
      191.         s->buf_ptr+=4;
      192.         bit_left+=32 - n;
                   ^
      193.         bit_buf = value;
      194.     }

libavcodec/put_bits.h:193:9: 
      191.         s->buf_ptr+=4;
      192.         bit_left+=32 - n;
      193.         bit_buf = value;
                   ^
      194.     }
      195. #endif

libavcodec/put_bits.h:197:5: 
      195. #endif
      196. 
      197.     s->bit_buf = bit_buf;
               ^
      198.     s->bit_left = bit_left;
      199. }

libavcodec/put_bits.h:198:5: 
      196. 
      197.     s->bit_buf = bit_buf;
      198.     s->bit_left = bit_left;
               ^
      199. }
      200. #else  /* ALT_BITSTREAM_WRITER defined */

libavcodec/put_bits.h:199:1: return from a call to put_bits
      197.     s->bit_buf = bit_buf;
      198.     s->bit_left = bit_left;
      199. }
           ^
      200. #else  /* ALT_BITSTREAM_WRITER defined */
      201. {

libavcodec/put_bits.h:286:1: return from a call to put_bits32
    284.     put_bits(s, 16, lo);
    285. #endif
    286. }
         ^
    287. 
    288. /**

libavcodec/alacenc.c:126:1: return from a call to write_frame_header
  124.     put_bits(&s->pbctx, 1,  is_verbatim);                   // Audio block is verbatim
  125.     put_bits32(&s->pbctx, s->avctx->frame_size);            // No. of samples in the frame
  126. }
       ^
  127. 
  128. static void calc_predictor_params(AlacEncodeContext *s, int ch)
