Merge commit '1c88617b9421c9af8ae961c05d2381b19c585026'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 22 Apr 2013 08:50:05 +0000 (10:50 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 22 Apr 2013 08:50:05 +0000 (10:50 +0200)
* commit '1c88617b9421c9af8ae961c05d2381b19c585026':
  riff: K&R formatting cosmetics

Conflicts:
libavformat/riff.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/riff.c

  #include "avio_internal.h"
  #include "riff.h"
  #include "libavcodec/bytestream.h"
 +#include "libavutil/avassert.h"
  
- /* Note: when encoding, the first matching tag is used, so order is
-    important if multiple tags possible for a given codec.
-    Note also that this list is used for more than just riff, other
-    files use it as well.
- */
+ /* Note: When encoding, the first matching tag is used, so order is
 - * important if multiple tags are possible for a given codec. */
++ * important if multiple tags are possible for a given codec.
++ * Note also that this list is used for more than just riff, other
++ * files use it as well.
++ */
  const AVCodecTag ff_codec_bmp_tags[] = {
      { AV_CODEC_ID_H264,         MKTAG('H', '2', '6', '4') },
      { AV_CODEC_ID_H264,         MKTAG('h', '2', '6', '4') },
      { AV_CODEC_ID_H263,         MKTAG('V', 'X', '1', 'K') },
      { AV_CODEC_ID_H263,         MKTAG('Z', 'y', 'G', 'o') },
      { AV_CODEC_ID_H263,         MKTAG('M', '2', '6', '3') },
 +    { AV_CODEC_ID_H263,         MKTAG('l', 's', 'v', 'm') },
      { AV_CODEC_ID_H263P,        MKTAG('H', '2', '6', '3') },
-     { AV_CODEC_ID_H263I,        MKTAG('I', '2', '6', '3') }, /* intel h263 */
+     { AV_CODEC_ID_H263I,        MKTAG('I', '2', '6', '3') }, /* Intel H.263 */
      { AV_CODEC_ID_H261,         MKTAG('H', '2', '6', '1') },
 -    { AV_CODEC_ID_H263P,        MKTAG('U', '2', '6', '3') },
 -    { AV_CODEC_ID_H263P,        MKTAG('v', 'i', 'v', '1') },
 +    { AV_CODEC_ID_H263,         MKTAG('U', '2', '6', '3') },
      { AV_CODEC_ID_MPEG4,        MKTAG('F', 'M', 'P', '4') },
      { AV_CODEC_ID_MPEG4,        MKTAG('D', 'I', 'V', 'X') },
      { AV_CODEC_ID_MPEG4,        MKTAG('D', 'X', '5', '0') },
      { AV_CODEC_ID_MPEG4,        MKTAG('V', 'S', 'P', 'X') },
      { AV_CODEC_ID_MPEG4,        MKTAG('U', 'L', 'D', 'X') },
      { AV_CODEC_ID_MPEG4,        MKTAG('G', 'E', 'O', 'V') },
-     { AV_CODEC_ID_MPEG4,        MKTAG('S', 'I', 'P', 'P') }, /* Samsung SHR-6040 */
+     /* Samsung SHR-6040 */
+     { AV_CODEC_ID_MPEG4,        MKTAG('S', 'I', 'P', 'P') },
 +    { AV_CODEC_ID_MPEG4,        MKTAG('S', 'M', '4', 'V') },
      { AV_CODEC_ID_MPEG4,        MKTAG('X', 'V', 'I', 'X') },
      { AV_CODEC_ID_MPEG4,        MKTAG('D', 'r', 'e', 'X') },
 +    { AV_CODEC_ID_MPEG4,        MKTAG('Q', 'M', 'P', '4') }, /* QNAP Systems */
 +    { AV_CODEC_ID_MPEG4,        MKTAG('P', 'L', 'V', '1') }, /* Pelco DVR MPEG-4 */
      { AV_CODEC_ID_MSMPEG4V3,    MKTAG('M', 'P', '4', '3') },
      { AV_CODEC_ID_MSMPEG4V3,    MKTAG('D', 'I', 'V', '3') },
      { AV_CODEC_ID_MSMPEG4V3,    MKTAG('M', 'P', 'G', '3') },
      { AV_CODEC_ID_MPEG4,        MKTAG( 4 ,  0 ,  0 ,  16) },
      { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('D', 'V', 'R', ' ') },
      { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('M', 'M', 'E', 'S') },
-     { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('L', 'M', 'P', '2') }, /* Lead MPEG2 in avi */
+     /* Lead MPEG-2 in AVI */
+     { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('L', 'M', 'P', '2') },
      { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('s', 'l', 'i', 'f') },
      { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('E', 'M', '2', 'V') },
-     { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('M', '7', '0', '1') }, /* Matrox MPEG2 intra-only */
+     /* Matrox MPEG-2 intra-only */
+     { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('M', '7', '0', '1') },
      { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('m', 'p', 'g', 'v') },
 +    { AV_CODEC_ID_MPEG1VIDEO,   MKTAG('B', 'W', '1', '0') },
 +    { AV_CODEC_ID_MPEG1VIDEO,   MKTAG('X', 'M', 'P', 'G') }, /* Xing MPEG intra only */
      { AV_CODEC_ID_MJPEG,        MKTAG('M', 'J', 'P', 'G') },
      { AV_CODEC_ID_MJPEG,        MKTAG('L', 'J', 'P', 'G') },
      { AV_CODEC_ID_MJPEG,        MKTAG('d', 'm', 'b', '1') },
      { AV_CODEC_ID_MJPEG,        MKTAG('m', 'j', 'p', 'a') },
      { AV_CODEC_ID_LJPEG,        MKTAG('L', 'J', 'P', 'G') },
-     { AV_CODEC_ID_MJPEG,        MKTAG('J', 'P', 'G', 'L') }, /* Pegasus lossless JPEG */
-     { AV_CODEC_ID_JPEGLS,       MKTAG('M', 'J', 'L', 'S') }, /* JPEG-LS custom FOURCC for avi - encoder */
+     /* Pegasus lossless JPEG */
+     { AV_CODEC_ID_MJPEG,        MKTAG('J', 'P', 'G', 'L') },
+     /* JPEG-LS custom FOURCC for AVI - encoder */
+     { AV_CODEC_ID_JPEGLS,       MKTAG('M', 'J', 'L', 'S') },
      { AV_CODEC_ID_JPEGLS,       MKTAG('M', 'J', 'P', 'G') },
-     { AV_CODEC_ID_MJPEG,        MKTAG('M', 'J', 'L', 'S') }, /* JPEG-LS custom FOURCC for avi - decoder */
+     /* JPEG-LS custom FOURCC for AVI - decoder */
+     { AV_CODEC_ID_MJPEG,        MKTAG('M', 'J', 'L', 'S') },
      { AV_CODEC_ID_MJPEG,        MKTAG('j', 'p', 'e', 'g') },
      { AV_CODEC_ID_MJPEG,        MKTAG('I', 'J', 'P', 'G') },
 -    { AV_CODEC_ID_MJPEG,        MKTAG('A', 'V', 'R', 'n') },
 +    { AV_CODEC_ID_AVRN,         MKTAG('A', 'V', 'R', 'n') },
      { AV_CODEC_ID_MJPEG,        MKTAG('A', 'C', 'D', 'V') },
      { AV_CODEC_ID_MJPEG,        MKTAG('Q', 'I', 'V', 'G') },
-     { AV_CODEC_ID_MJPEG,        MKTAG('S', 'L', 'M', 'J') }, /* SL M-JPEG */
-     { AV_CODEC_ID_MJPEG,        MKTAG('C', 'J', 'P', 'G') }, /* Creative Webcam JPEG */
-     { AV_CODEC_ID_MJPEG,        MKTAG('I', 'J', 'L', 'V') }, /* Intel JPEG Library Video Codec */
-     { AV_CODEC_ID_MJPEG,        MKTAG('M', 'V', 'J', 'P') }, /* Midvid JPEG Video Codec */
+     /* SL M-JPEG */
+     { AV_CODEC_ID_MJPEG,        MKTAG('S', 'L', 'M', 'J') },
+     /* Creative Webcam JPEG */
+     { AV_CODEC_ID_MJPEG,        MKTAG('C', 'J', 'P', 'G') },
+     /* Intel JPEG Library Video Codec */
+     { AV_CODEC_ID_MJPEG,        MKTAG('I', 'J', 'L', 'V') },
+     /* Midvid JPEG Video Codec */
+     { AV_CODEC_ID_MJPEG,        MKTAG('M', 'V', 'J', 'P') },
      { AV_CODEC_ID_MJPEG,        MKTAG('A', 'V', 'I', '1') },
      { AV_CODEC_ID_MJPEG,        MKTAG('A', 'V', 'I', '2') },
      { AV_CODEC_ID_MJPEG,        MKTAG('M', 'T', 'S', 'J') },
@@@ -342,10 -328,9 +365,11 @@@ const AVCodecTag ff_codec_wav_tags[] = 
      { AV_CODEC_ID_PCM_ALAW,        0x0006 },
      { AV_CODEC_ID_PCM_MULAW,       0x0007 },
      { AV_CODEC_ID_WMAVOICE,        0x000A },
 +    { AV_CODEC_ID_ADPCM_IMA_OKI,   0x0010 },
      { AV_CODEC_ID_ADPCM_IMA_WAV,   0x0011 },
-     { AV_CODEC_ID_PCM_ZORK,        0x0011 }, /* must come after adpcm_ima_wav in this list */
+     /* must come after adpcm_ima_wav in this list */
+     { AV_CODEC_ID_PCM_ZORK,        0x0011 },
 +    { AV_CODEC_ID_ADPCM_IMA_OKI,   0x0017 },
      { AV_CODEC_ID_ADPCM_YAMAHA,    0x0020 },
      { AV_CODEC_ID_TRUESPEECH,      0x0022 },
      { AV_CODEC_ID_GSM_MS,          0x0031 },
      { AV_CODEC_ID_PCM_MULAW,       0x6c75 },
      { AV_CODEC_ID_AAC,             0x706d },
      { AV_CODEC_ID_AAC,             0x4143 },
 +    { AV_CODEC_ID_G723_1,          0xA100 },
 +    { AV_CODEC_ID_AAC,             0xA106 },
      { AV_CODEC_ID_SPEEX,           0xA109 },
      { AV_CODEC_ID_FLAC,            0xF1AC },
-     { AV_CODEC_ID_ADPCM_SWF,       ('S'<<8)+'F' },
-     { AV_CODEC_ID_VORBIS,          ('V'<<8)+'o' }, //HACK/FIXME, does vorbis in WAV/AVI have an (in)official id?
+     { AV_CODEC_ID_ADPCM_SWF,       ('S' << 8) + 'F' },
+     /* HACK/FIXME: Does Vorbis in WAV/AVI have an (in)official ID? */
+     { AV_CODEC_ID_VORBIS,          ('V' << 8) + 'o' },
      { AV_CODEC_ID_NONE,      0 },
  };
  
 +const AVCodecGuid ff_codec_wav_guids[] = {
 +    {AV_CODEC_ID_AC3,        {0x2C,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
 +    {AV_CODEC_ID_ATRAC3P,    {0xBF,0xAA,0x23,0xE9,0x58,0xCB,0x71,0x44,0xA1,0x19,0xFF,0xFA,0x01,0xE4,0xCE,0x62}},
 +    {AV_CODEC_ID_EAC3,       {0xAF,0x87,0xFB,0xA7,0x02,0x2D,0xFB,0x42,0xA4,0xD4,0x05,0xCD,0x93,0x84,0x3B,0xDD}},
 +    {AV_CODEC_ID_MP2,        {0x2B,0x80,0x6D,0xE0,0x46,0xDB,0xCF,0x11,0xB4,0xD1,0x00,0x80,0x5F,0x6C,0xBB,0xEA}},
 +    {AV_CODEC_ID_NONE}
 +};
 +
  const AVMetadataConv ff_riff_info_conv[] = {
-     { "IART", "artist"    },
-     { "ICMT", "comment"   },
-     { "ICOP", "copyright" },
-     { "ICRD", "date"      },
-     { "IGNR", "genre"     },
-     { "ILNG", "language"  },
-     { "INAM", "title"     },
-     { "IPRD", "album"     },
-     { "IPRT", "track"     },
-     { "ISFT", "encoder"   },
-     { "ISMP", "timecode"  },
-     { "ITCH", "encoded_by"},
+     { "IART", "artist"     },
+     { "ICMT", "comment"    },
+     { "ICOP", "copyright"  },
+     { "ICRD", "date"       },
+     { "IGNR", "genre"      },
+     { "ILNG", "language"   },
+     { "INAM", "title"      },
+     { "IPRD", "album"      },
+     { "IPRT", "track"      },
+     { "ISFT", "encoder"    },
++    { "ISMP", "timecode"   },
+     { "ITCH", "encoded_by" },
      { 0 },
  };
  
@@@ -458,46 -428,44 +486,50 @@@ int ff_put_wav_header(AVIOContext *pb, 
      if (!frame_size)
          frame_size = enc->frame_size;
  
-     waveformatextensible =   (enc->channels > 2 && enc->channel_layout)
-                           || enc->sample_rate > 48000
-                           || av_get_bits_per_sample(enc->codec_id) > 16;
+     waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
+                            enc->sample_rate > 48000 ||
+                            av_get_bits_per_sample(enc->codec_id) > 16;
  
-     if (waveformatextensible) {
+     if (waveformatextensible)
          avio_wl16(pb, 0xfffe);
-     } else {
+     else
          avio_wl16(pb, enc->codec_tag);
-     }
      avio_wl16(pb, enc->channels);
      avio_wl32(pb, enc->sample_rate);
 -    if (enc->codec_id == AV_CODEC_ID_MP2 ||
 -        enc->codec_id == AV_CODEC_ID_MP3 ||
 +    if (enc->codec_id == AV_CODEC_ID_ATRAC3 ||
 +        enc->codec_id == AV_CODEC_ID_G723_1 ||
-         enc->codec_id == AV_CODEC_ID_GSM_MS ||
 +        enc->codec_id == AV_CODEC_ID_MP2    ||
-         enc->codec_id == AV_CODEC_ID_MP3) {
++        enc->codec_id == AV_CODEC_ID_MP3    ||
+         enc->codec_id == AV_CODEC_ID_GSM_MS) {
          bps = 0;
      } else {
          if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
              if (enc->bits_per_coded_sample)
                  bps = enc->bits_per_coded_sample;
              else
-                 bps = 16; // default to 16
+                 bps = 16;  // default to 16
          }
      }
-     if(bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample){
-         av_log(enc, AV_LOG_WARNING, "requested bits_per_coded_sample (%d) and actually stored (%d) differ\n", enc->bits_per_coded_sample, bps);
+     if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
+         av_log(enc, AV_LOG_WARNING,
+                "requested bits_per_coded_sample (%d) "
+                "and actually stored (%d) differ\n",
+                enc->bits_per_coded_sample, bps);
      }
  
-     if (enc->codec_id == AV_CODEC_ID_MP2 || enc->codec_id == AV_CODEC_ID_MP3) {
-         /* this is wrong, but it seems many demuxers do not work if this is set
-            correctly */
+     if (enc->codec_id == AV_CODEC_ID_MP2 ||
+         enc->codec_id == AV_CODEC_ID_MP3) {
+         /* This is wrong, but it seems many demuxers do not work if this
+          * is set correctly. */
          blkalign = frame_size;
-         //blkalign = 144 * enc->bit_rate/enc->sample_rate;
+         // blkalign = 144 * enc->bit_rate/enc->sample_rate;
      } else if (enc->codec_id == AV_CODEC_ID_AC3) {
-             blkalign = 3840; //maximum bytes per frame
+         blkalign = 3840;                /* maximum bytes per frame */
 +    } else if (enc->codec_id == AV_CODEC_ID_AAC) {
-             blkalign = 768 * enc->channels; //maximum bytes per frame
++        blkalign = 768 * enc->channels; /* maximum bytes per frame */
 +    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
-             blkalign = 24;
++        blkalign = 24;
      } else if (enc->block_align != 0) { /* specified by the codec */
          blkalign = enc->block_align;
      } else
          bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
      } else if (enc->codec_id == AV_CODEC_ID_MP2) {
          hdrsize += 22;
-         bytestream_put_le16(&riff_extradata, 2);                          /* fwHeadLayer */
-         bytestream_put_le32(&riff_extradata, enc->bit_rate);              /* dwHeadBitrate */
-         bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8); /* fwHeadMode */
-         bytestream_put_le16(&riff_extradata, 0);                          /* fwHeadModeExt */
-         bytestream_put_le16(&riff_extradata, 1);                          /* wHeadEmphasis */
-         bytestream_put_le16(&riff_extradata, 16);                         /* fwHeadFlags */
-         bytestream_put_le32(&riff_extradata, 0);                          /* dwPTSLow */
-         bytestream_put_le32(&riff_extradata, 0);                          /* dwPTSHigh */
+         /* fwHeadLayer */
+         bytestream_put_le16(&riff_extradata, 2);
+         /* dwHeadBitrate */
+         bytestream_put_le32(&riff_extradata, enc->bit_rate);
+         /* fwHeadMode */
+         bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
+         /* fwHeadModeExt */
+         bytestream_put_le16(&riff_extradata, 0);
+         /* wHeadEmphasis */
+         bytestream_put_le16(&riff_extradata, 1);
+         /* fwHeadFlags */
+         bytestream_put_le16(&riff_extradata, 16);
+         /* dwPTSLow */
+         bytestream_put_le32(&riff_extradata, 0);
+         /* dwPTSHigh */
+         bytestream_put_le32(&riff_extradata, 0);
 +    } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
 +        hdrsize += 20;
 +        bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
 +        bytestream_put_le32(&riff_extradata, 0xaea2f732);
 +        bytestream_put_le16(&riff_extradata, 0xacde);
-     } else if (enc->codec_id == AV_CODEC_ID_GSM_MS || enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
+     } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
+                enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
          hdrsize += 2;
-         bytestream_put_le16(&riff_extradata, frame_size); /* wSamplesPerBlock */
-     } else if(enc->extradata_size){
-         riff_extradata_start= enc->extradata;
-         riff_extradata= enc->extradata + enc->extradata_size;
-         hdrsize += enc->extradata_size;
+         /* wSamplesPerBlock */
+         bytestream_put_le16(&riff_extradata, frame_size);
+     } else if (enc->extradata_size) {
+         riff_extradata_start = enc->extradata;
+         riff_extradata       = enc->extradata + enc->extradata_size;
+         hdrsize             += enc->extradata_size;
      }
-     if(waveformatextensible) {                                    /* write WAVEFORMATEXTENSIBLE extensions */
+     /* write WAVEFORMATEXTENSIBLE extensions */
+     if (waveformatextensible) {
          hdrsize += 22;
-         avio_wl16(pb, riff_extradata - riff_extradata_start + 22); /* 22 is WAVEFORMATEXTENSIBLE size */
-         avio_wl16(pb, bps);                                        /* ValidBitsPerSample || SamplesPerBlock || Reserved */
-         avio_wl32(pb, enc->channel_layout);                        /* dwChannelMask */
-         avio_wl32(pb, enc->codec_tag);                             /* GUID + next 3 */
+         /* 22 is WAVEFORMATEXTENSIBLE size */
+         avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
+         /* ValidBitsPerSample || SamplesPerBlock || Reserved */
+         avio_wl16(pb, bps);
+         /* dwChannelMask */
+         avio_wl32(pb, enc->channel_layout);
+         /* GUID + next 3 */
+         avio_wl32(pb, enc->codec_tag);
          avio_wl32(pb, 0x00100000);
          avio_wl32(pb, 0xAA000080);
          avio_wl32(pb, 0x719B3800);
@@@ -575,12 -553,13 +624,13 @@@ void ff_put_bmp_header(AVIOContext *pb
      avio_wl32(pb, enc->width);
      //We always store RGB TopDown
      avio_wl32(pb, enc->codec_tag ? enc->height : -enc->height);
-     avio_wl16(pb, 1); /* planes */
-     avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24); /* depth */
+     /* planes */
+     avio_wl16(pb, 1);
+     /* depth */
+     avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
      /* compression type */
      avio_wl32(pb, enc->codec_tag);
 -    avio_wl32(pb, enc->width * enc->height * 3);
 +    avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
      avio_wl32(pb, 0);
      avio_wl32(pb, 0);
      avio_wl32(pb, 0);
@@@ -638,8 -619,8 +690,8 @@@ void ff_riff_write_info_tag(AVIOContex
  static const char riff_tags[][5] = {
      "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
      "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
 -    "IPRT", "ISBJ", "ISFT", "ISHP", "ISRC", "ISRF", "ITCH",
 +    "IPRT", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
-     {0}
+     { 0 }
  };
  
  static int riff_has_valid_tags(AVFormatContext *s)
@@@ -689,43 -669,28 +740,43 @@@ int ff_get_wav_header(AVIOContext *pb, 
  {
      int id;
  
-     id = avio_rl16(pb);
-     codec->codec_type = AVMEDIA_TYPE_AUDIO;
-     codec->channels = avio_rl16(pb);
+     id                 = avio_rl16(pb);
+     codec->codec_type  = AVMEDIA_TYPE_AUDIO;
 -    codec->codec_tag   = id;
+     codec->channels    = avio_rl16(pb);
      codec->sample_rate = avio_rl32(pb);
-     codec->bit_rate = avio_rl32(pb) * 8;
+     codec->bit_rate    = avio_rl32(pb) * 8;
      codec->block_align = avio_rl16(pb);
      if (size == 14) {  /* We're dealing with plain vanilla WAVEFORMAT */
          codec->bits_per_coded_sample = 8;
-     }else
+     } else
          codec->bits_per_coded_sample = avio_rl16(pb);
 +    if (id == 0xFFFE) {
 +        codec->codec_tag = 0;
 +    } else {
 +        codec->codec_tag = id;
 +        codec->codec_id = ff_wav_codec_get_id(id, codec->bits_per_coded_sample);
 +    }
      if (size >= 18) {  /* We're obviously dealing with WAVEFORMATEX */
          int cbSize = avio_rl16(pb); /* cbSize */
-         size -= 18;
+         size  -= 18;
          cbSize = FFMIN(size, cbSize);
          if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */
 -            codec->bits_per_coded_sample = avio_rl16(pb);
 +            ff_asf_guid subformat;
 +            int bps = avio_rl16(pb);
 +            if (bps)
 +                codec->bits_per_coded_sample = bps;
-             codec->channel_layout = avio_rl32(pb); /* dwChannelMask */
+             codec->channel_layout        = avio_rl32(pb); /* dwChannelMask */
 -            id                           = avio_rl32(pb); /* 4 first bytes of GUID */
 -            avio_skip(pb, 12); /* skip end of GUID */
 +            ff_get_guid(pb, &subformat);
 +            if (!memcmp(subformat + 4, (const uint8_t[]){FF_MEDIASUBTYPE_BASE_GUID}, 12)) {
 +                codec->codec_tag = AV_RL32(subformat);
 +                codec->codec_id = ff_wav_codec_get_id(codec->codec_tag, codec->bits_per_coded_sample);
 +            } else {
 +                codec->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);
 +                if (!codec->codec_id)
 +                    av_log(codec, AV_LOG_WARNING, "unknown subformat:"FF_PRI_GUID"\n", FF_ARG_GUID(subformat));
 +            }
              cbSize -= 22;
-             size -= 22;
+             size   -= 22;
          }
          codec->extradata_size = cbSize;
          if (cbSize > 0) {
          if (size > 0)
              avio_skip(pb, size);
      }
 -    codec->codec_id = ff_wav_codec_get_id(id, codec->bits_per_coded_sample);
      if (codec->codec_id == AV_CODEC_ID_AAC_LATM) {
-         /* channels and sample_rate values are those prior to applying SBR and/or PS */
+         /* Channels and sample_rate values are those prior to applying SBR
+          * and/or PS. */
          codec->channels    = 0;
          codec->sample_rate = 0;
      }
@@@ -771,16 -738,15 +823,16 @@@ enum AVCodecID ff_wav_codec_get_id(unsi
      return id;
  }
  
 -int ff_get_bmp_header(AVIOContext *pb, AVStream *st)
 +int ff_get_bmp_header(AVIOContext *pb, AVStream *st, unsigned *esize)
  {
      int tag1;
-     if(esize) *esize = avio_rl32(pb);
-     else               avio_rl32(pb);
-     st->codec->width = avio_rl32(pb);
 -    avio_rl32(pb); /* size */
++    if(esize) *esize  = avio_rl32(pb);
++    else                avio_rl32(pb);
+     st->codec->width  = avio_rl32(pb);
      st->codec->height = (int32_t)avio_rl32(pb);
      avio_rl16(pb); /* planes */
-     st->codec->bits_per_coded_sample= avio_rl16(pb); /* depth */
-     tag1 = avio_rl32(pb);
+     st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */
+     tag1                             = avio_rl32(pb);
      avio_rl32(pb); /* ImageSize */
      avio_rl32(pb); /* XPelsPerMeter */
      avio_rl32(pb); /* YPelsPerMeter */
@@@ -822,21 -772,12 +875,23 @@@ int ff_read_riff_info(AVFormatContext *
  
          chunk_code = avio_rl32(pb);
          chunk_size = avio_rl32(pb);
 -
 +        if (url_feof(pb)) {
 +            if (chunk_code || chunk_size) {
 +                av_log(s, AV_LOG_WARNING, "INFO subchunk truncated\n");
 +                return AVERROR_INVALIDDATA;
 +            }
 +            break;
 +        }
-         if (chunk_size > end || end - chunk_size < cur || chunk_size == UINT_MAX) {
+         if (chunk_size > end ||
+             end - chunk_size < cur ||
+             chunk_size == UINT_MAX) {
 -            av_log(s, AV_LOG_WARNING, "too big INFO subchunk\n");
 -            break;
 +            avio_seek(pb, -9, SEEK_CUR);
 +            chunk_code = avio_rl32(pb);
 +            chunk_size = avio_rl32(pb);
 +            if (chunk_size > end || end - chunk_size < cur || chunk_size == UINT_MAX) {
 +                av_log(s, AV_LOG_WARNING, "too big INFO subchunk\n");
 +                return AVERROR_INVALIDDATA;
 +            }
          }
  
          chunk_size += (chunk_size & 1);
              continue;
          }
  
 -        value = av_malloc(chunk_size + 1);
 +        value = av_mallocz(chunk_size + 1);
          if (!value) {
-             av_log(s, AV_LOG_ERROR, "out of memory, unable to read INFO tag\n");
+             av_log(s, AV_LOG_ERROR,
+                    "out of memory, unable to read INFO tag\n");
              return AVERROR(ENOMEM);
          }
  
          AV_WL32(key, chunk_code);
  
          if (avio_read(pb, value, chunk_size) != chunk_size) {
-             av_log(s, AV_LOG_WARNING, "premature end of file while reading INFO tag\n");
 -            av_free(value);
+             av_log(s, AV_LOG_WARNING,
+                    "premature end of file while reading INFO tag\n");
 -            break;
          }
  
 -        value[chunk_size] = 0;
 -
          av_dict_set(&s->metadata, key, value, AV_DICT_DONT_STRDUP_VAL);
      }