Merge remote-tracking branch 'qatar/master'

* qatar/master: (34 commits)
  dpcm: return error if packet is too small
  dpcm: use smaller data types for static tables
  dpcm: use sol_table_16 directly instead of through the DPCMContext.
  dpcm: replace short with int16_t
  dpcm: check to make sure channels is 1 or 2.
  dpcm: misc pretty-printing
  dpcm: remove unnecessary variable by using bytestream functions.
  dpcm: move codec-specific variable declarations to their corresponding decoding blocks.
  dpcm: consistently use the variable name 'n' for the next input byte.
  dpcm: output AV_SAMPLE_FMT_U8 for Sol DPCM subcodecs 1 and 2.
  dpcm: calculate and check actual output data size prior to decoding.
  dpcm: factor out the stereo flag calculation
  dpcm: cosmetics: rename channel_number to ch
  avserver: Fix a bug where the socket is IPv4, but IPv6 is autoselected for the loopback address.
  lavf: Avoid using av_malloc(0) in av_dump_format
  dxva2_h264: pass the correct 8x8 scaling lists
  dca: NEON optimised high freq VQ decoding
  avcodec: reject audio packets with NULL data and non-zero size
  dxva: Add ability to enable workaround for older ATI cards
  latmenc: Set latmBufferFullness to largest value to indicate it is not used
  ...

Conflicts:
	libavcodec/dxva2_h264.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

ffserver.c

@@ -522,6 +522,7 @@ static int socket_open_listen(struct sockaddr_in *my_addr)
     tmp = 1;
     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));
 
+    my_addr->sin_family = AF_INET;
     if (bind (server_fd, (struct sockaddr *) my_addr, sizeof (*my_addr)) < 0) {
         char bindmsg[32];
         snprintf(bindmsg, sizeof(bindmsg), "bind(port %d)", ntohs(my_addr->sin_port));

libavcodec/adpcm.c

@@ -42,31 +42,35 @@
  * Features and limitations:
  *
  * Reference documents:
- * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
- * http://www.geocities.com/SiliconValley/8682/aud3.txt
- * http://openquicktime.sourceforge.net/plugins.htm
- * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
- * http://www.cs.ucla.edu/~leec/mediabench/applications.html
- * SoX source code http://home.sprynet.com/~cbagwell/sox.html
+ * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs
+ * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]
+ * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]
+ * http://openquicktime.sourceforge.net/
+ * XAnim sources (xa_codec.c) http://xanim.polter.net/
+ * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]
+ * SoX source code http://sox.sourceforge.net/
  *
  * CD-ROM XA:
- * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html
- * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html
+ * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]
+ * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]
  * readstr http://www.geocities.co.jp/Playtown/2004/
  */
 
 /* These are for CD-ROM XA ADPCM */
 static const int xa_adpcm_table[5][2] = {
-   {   0,   0 },
-   {  60,   0 },
-   { 115, -52 },
-   {  98, -55 },
-   { 122, -60 }
+    {   0,   0 },
+    {  60,   0 },
+    { 115, -52 },
+    {  98, -55 },
+    { 122, -60 }
 };
 
 static const int ea_adpcm_table[] = {
-    0, 240, 460, 392, 0, 0, -208, -220, 0, 1,
-    3, 4, 7, 8, 10, 11, 0, -1, -3, -4
+    0,  240,  460,  392,
+    0,    0, -208, -220,
+    0,    1,    3,    4,
+    7,    8,   10,   11,
+    0,   -1,   -3,   -4
 };
 
 // padded to zero where table size is less then 16
@@ -336,27 +340,12 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
     ADPCMDecodeContext *c = avctx->priv_data;
     ADPCMChannelStatus *cs;
     int n, m, channel, i;
-    int block_predictor[2];
     short *samples;
     short *samples_end;
     const uint8_t *src;
     int st; /* stereo */
-
-    /* DK3 ADPCM accounting variables */
-    unsigned char last_byte = 0;
-    unsigned char nibble;
-    int decode_top_nibble_next = 0;
-    int diff_channel;
-
-    /* EA ADPCM state variables */
     uint32_t samples_in_chunk;
-    int32_t previous_left_sample, previous_right_sample;
-    int32_t current_left_sample, current_right_sample;
-    int32_t next_left_sample, next_right_sample;
-    int32_t coeff1l, coeff2l, coeff1r, coeff2r;
-    uint8_t shift_left, shift_right;
     int count1, count2;
-    int coeff[2][2], shift[2];//used in EA MAXIS ADPCM
 
     if (!buf_size)
         return 0;
@@ -376,7 +365,12 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
 
     switch(avctx->codec->id) {
     case CODEC_ID_ADPCM_IMA_QT:
-        n = buf_size - 2*avctx->channels;
+        /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).
+           Channel data is interleaved per-chunk. */
+        if (buf_size / 34 < avctx->channels) {
+            av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
+            return AVERROR(EINVAL);
+        }
         for (channel = 0; channel < avctx->channels; channel++) {
             int16_t predictor;
             int step_index;
@@ -409,7 +403,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
 
             samples = (short*)data + channel;
 
-            for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */
+            for (m = 0; m < 32; m++) {
                 *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);
                 samples += avctx->channels;
                 *samples = adpcm_ima_qt_expand_nibble(cs, src[0] >> 4  , 3);
@@ -439,60 +433,66 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
         }
 
         while(src < buf + buf_size){
-            for(m=0; m<4; m++){
-                for(i=0; i<=st; i++)
-                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3);
-                for(i=0; i<=st; i++)
-                    *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4  , 3);
-                src++;
+            for (i = 0; i < avctx->channels; i++) {
+                cs = &c->status[i];
+                for (m = 0; m < 4; m++) {
+                    uint8_t v = *src++;
+                    *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);
+                    samples += avctx->channels;
+                    *samples = adpcm_ima_expand_nibble(cs, v >> 4  , 3);
+                    samples += avctx->channels;
+                }
+                samples -= 8 * avctx->channels - 1;
             }
-            src += 4*st;
+            samples += 7 * avctx->channels;
         }
         break;
     case CODEC_ID_ADPCM_4XM:
-        cs = &(c->status[0]);
-        c->status[0].predictor= (int16_t)bytestream_get_le16(&src);
-        if(st){
-            c->status[1].predictor= (int16_t)bytestream_get_le16(&src);
-        }
-        c->status[0].step_index= (int16_t)bytestream_get_le16(&src);
-        if(st){
-            c->status[1].step_index= (int16_t)bytestream_get_le16(&src);
-        }
-        if (cs->step_index < 0) cs->step_index = 0;
-        if (cs->step_index > 88) cs->step_index = 88;
+        for (i = 0; i < avctx->channels; i++)
+            c->status[i].predictor= (int16_t)bytestream_get_le16(&src);
 
-        m= (buf_size - (src - buf))>>st;
-        for(i=0; i<m; i++) {
-            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4);
-            if (st)
-                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4);
-            *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4);
-            if (st)
-                *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4);
+        for (i = 0; i < avctx->channels; i++) {
+            c->status[i].step_index= (int16_t)bytestream_get_le16(&src);
+            c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);
         }
 
-        src += m<<st;
+        m= (buf_size - (src - buf))>>st;
 
+        for (i = 0; i < avctx->channels; i++) {
+            samples = (short*)data + i;
+            cs = &c->status[i];
+            for (n = 0; n < m; n++) {
+                uint8_t v = *src++;
+                *samples = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);
+                samples += avctx->channels;
+                *samples = adpcm_ima_expand_nibble(cs, v >> 4  , 4);
+                samples += avctx->channels;
+            }
+        }
+        samples -= (avctx->channels - 1);
         break;
     case CODEC_ID_ADPCM_MS:
+    {
+        int block_predictor;
+
         if (avctx->block_align != 0 && buf_size > avctx->block_align)
             buf_size = avctx->block_align;
         n = buf_size - 7 * avctx->channels;
         if (n < 0)
             return -1;
-        block_predictor[0] = av_clip(*src++, 0, 6);
-        block_predictor[1] = 0;
-        if (st)
-            block_predictor[1] = av_clip(*src++, 0, 6);
+
+        block_predictor = av_clip(*src++, 0, 6);
+        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
+        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
+        if (st) {
+            block_predictor = av_clip(*src++, 0, 6);
+            c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
+            c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
+        }
         c->status[0].idelta = (int16_t)bytestream_get_le16(&src);
         if (st){
             c->status[1].idelta = (int16_t)bytestream_get_le16(&src);
         }
-        c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor[0]];
-        c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor[0]];
-        c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor[1]];
-        c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor[1]];
 
         c->status[0].sample1 = bytestream_get_le16(&src);
         if (st) c->status[1].sample1 = bytestream_get_le16(&src);
@@ -509,39 +509,37 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
             src ++;
         }
         break;
+    }
     case CODEC_ID_ADPCM_IMA_DK4:
         if (avctx->block_align != 0 && buf_size > avctx->block_align)
             buf_size = avctx->block_align;
 
-        c->status[0].predictor  = (int16_t)bytestream_get_le16(&src);
-        c->status[0].step_index = *src++;
-        src++;
-        *samples++ = c->status[0].predictor;
-        if (st) {
-            c->status[1].predictor  = (int16_t)bytestream_get_le16(&src);
-            c->status[1].step_index = *src++;
-            src++;
-            *samples++ = c->status[1].predictor;
+        n = buf_size - 4 * avctx->channels;
+        if (n < 0) {
+            av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
+            return AVERROR(EINVAL);
         }
-        while (src < buf + buf_size) {
-
-            /* take care of the top nibble (always left or mono channel) */
-            *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                src[0] >> 4, 3);
-
-            /* take care of the bottom nibble, which is right sample for
-             * stereo, or another mono sample */
-            if (st)
-                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
-                    src[0] & 0x0F, 3);
-            else
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] & 0x0F, 3);
 
+        for (channel = 0; channel < avctx->channels; channel++) {
+            cs = &c->status[channel];
+            cs->predictor  = (int16_t)bytestream_get_le16(&src);
+            cs->step_index = *src++;
             src++;
+            *samples++ = cs->predictor;
+        }
+        while (n-- > 0) {
+            uint8_t v = *src++;
+            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4  , 3);
+            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
         }
         break;
     case CODEC_ID_ADPCM_IMA_DK3:
+    {
+        unsigned char last_byte = 0;
+        unsigned char nibble;
+        int decode_top_nibble_next = 0;
+        int diff_channel;
+
         if (avctx->block_align != 0 && buf_size > avctx->block_align)
             buf_size = avctx->block_align;
 
@@ -586,50 +584,41 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
             *samples++ = c->status[0].predictor - c->status[1].predictor;
         }
         break;
+    }
     case CODEC_ID_ADPCM_IMA_ISS:
-        c->status[0].predictor  = (int16_t)AV_RL16(src + 0);
-        c->status[0].step_index = src[2];
-        src += 4;
-        if(st) {
-            c->status[1].predictor  = (int16_t)AV_RL16(src + 0);
-            c->status[1].step_index = src[2];
-            src += 4;
+        n = buf_size - 4 * avctx->channels;
+        if (n < 0) {
+            av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
+            return AVERROR(EINVAL);
         }
 
-        while (src < buf + buf_size) {
+        for (channel = 0; channel < avctx->channels; channel++) {
+            cs = &c->status[channel];
+            cs->predictor  = (int16_t)bytestream_get_le16(&src);
+            cs->step_index = *src++;
+            src++;
+        }
 
+        while (n-- > 0) {
+            uint8_t v1, v2;
+            uint8_t v = *src++;
+            /* nibbles are swapped for mono */
             if (st) {
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] >> 4  , 3);
-                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
-                    src[0] & 0x0F, 3);
+                v1 = v >> 4;
+                v2 = v & 0x0F;
             } else {
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] & 0x0F, 3);
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] >> 4  , 3);
+                v2 = v >> 4;
+                v1 = v & 0x0F;
             }
-
-            src++;
+            *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
+            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
         }
         break;
     case CODEC_ID_ADPCM_IMA_WS:
-        /* no per-block initialization; just start decoding the data */
         while (src < buf + buf_size) {
-
-            if (st) {
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] >> 4  , 3);
-                *samples++ = adpcm_ima_expand_nibble(&c->status[1],
-                    src[0] & 0x0F, 3);
-            } else {
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] >> 4  , 3);
-                *samples++ = adpcm_ima_expand_nibble(&c->status[0],
-                    src[0] & 0x0F, 3);
-            }
-
-            src++;
+            uint8_t v = *src++;
+            *samples++ = adpcm_ima_expand_nibble(&c->status[0],  v >> 4  , 3);
+            *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);
         }
         break;
     case CODEC_ID_ADPCM_XA:
@@ -668,6 +657,13 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
         }
         break;
     case CODEC_ID_ADPCM_EA:
+    {
+        int32_t previous_left_sample, previous_right_sample;
+        int32_t current_left_sample, current_right_sample;
+        int32_t next_left_sample, next_right_sample;
+        int32_t coeff1l, coeff2l, coeff1r, coeff2r;
+        uint8_t shift_left, shift_right;
+
         /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,
            each coding 28 stereo samples. */
         if (buf_size < 12) {
@@ -721,7 +717,11 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
             src += 2; // Skip terminating 0x0000
 
         break;
+    }
     case CODEC_ID_ADPCM_EA_MAXIS_XA:
+    {
+        int coeff[2][2], shift[2];
+
         for(channel = 0; channel < avctx->channels; channel++) {
             for (i=0; i<2; i++)
                 coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];
@@ -743,6 +743,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
             src+=avctx->channels;
         }
         break;
+    }
     case CODEC_ID_ADPCM_EA_R1:
     case CODEC_ID_ADPCM_EA_R2:
     case CODEC_ID_ADPCM_EA_R3: {
@@ -885,18 +886,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
         break;
     case CODEC_ID_ADPCM_CT:
         while (src < buf + buf_size) {
-            if (st) {
-                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
-                    src[0] >> 4);
-                *samples++ = adpcm_ct_expand_nibble(&c->status[1],
-                    src[0] & 0x0F);
-            } else {
-                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
-                    src[0] >> 4);
-                *samples++ = adpcm_ct_expand_nibble(&c->status[0],
-                    src[0] & 0x0F);
-            }
-            src++;
+            uint8_t v = *src++;
+            *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4  );
+            *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);
         }
         break;
     case CODEC_ID_ADPCM_SBPRO_4:
@@ -1004,18 +996,9 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
     }
     case CODEC_ID_ADPCM_YAMAHA:
         while (src < buf + buf_size) {
-            if (st) {
-                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
-                        src[0] & 0x0F);
-                *samples++ = adpcm_yamaha_expand_nibble(&c->status[1],
-                        src[0] >> 4  );
-            } else {
-                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
-                        src[0] & 0x0F);
-                *samples++ = adpcm_yamaha_expand_nibble(&c->status[0],
-                        src[0] >> 4  );
-            }
-            src++;
+            uint8_t v = *src++;
+            *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);
+            *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4  );
         }
         break;
     case CODEC_ID_ADPCM_THP:

libavcodec/adpcm_data.c

@@ -38,14 +38,14 @@ const int8_t ff_adpcm_index_table[16] = {
  * this table, but such deviations are negligible:
  */
 const int16_t ff_adpcm_step_table[89] = {
-    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
-    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
-    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
-    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
-    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
-    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
-    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
-    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+        7,     8,     9,    10,    11,    12,    13,    14,    16,    17,
+       19,    21,    23,    25,    28,    31,    34,    37,    41,    45,
+       50,    55,    60,    66,    73,    80,    88,    97,   107,   118,
+      130,   143,   157,   173,   190,   209,   230,   253,   279,   307,
+      337,   371,   408,   449,   494,   544,   598,   658,   724,   796,
+      876,   963,  1060,  1166,  1282,  1411,  1552,  1707,  1878,  2066,
+     2272,  2499,  2749,  3024,  3327,  3660,  4026,  4428,  4871,  5358,
+     5894,  6484,  7132,  7845,  8630,  9493, 10442, 11487, 12635, 13899,
     15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
 };
 
@@ -53,18 +53,18 @@ const int16_t ff_adpcm_step_table[89] = {
 /* ff_adpcm_AdaptationTable[], ff_adpcm_AdaptCoeff1[], and
    ff_adpcm_AdaptCoeff2[] are from libsndfile */
 const int16_t ff_adpcm_AdaptationTable[] = {
-        230, 230, 230, 230, 307, 409, 512, 614,
-        768, 614, 512, 409, 307, 230, 230, 230
+    230, 230, 230, 230, 307, 409, 512, 614,
+    768, 614, 512, 409, 307, 230, 230, 230
 };
 
 /** Divided by 4 to fit in 8-bit integers */
 const uint8_t ff_adpcm_AdaptCoeff1[] = {
-        64, 128, 0, 48, 60, 115, 98
+    64, 128, 0, 48, 60, 115, 98
 };
 
 /** Divided by 4 to fit in 8-bit integers */
 const int8_t ff_adpcm_AdaptCoeff2[] = {
-        0, -64, 0, 16, 0, -52, -58
+    0, -64, 0, 16, 0, -52, -58
 };
 
 const int16_t ff_adpcm_yamaha_indexscale[] = {
@@ -73,6 +73,6 @@ const int16_t ff_adpcm_yamaha_indexscale[] = {
 };
 
 const int8_t ff_adpcm_yamaha_difflookup[] = {
-    1, 3, 5, 7, 9, 11, 13, 15,
+     1,  3,  5,  7,  9,  11,  13,  15,
     -1, -3, -5, -7, -9, -11, -13, -15
 };

libavcodec/adpcmenc.c

@@ -32,13 +32,7 @@
  * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood)
  *   by Mike Melanson (melanson@pcisys.net)
  *
- * Reference documents:
- * http://www.pcisys.net/~melanson/codecs/simpleaudio.html
- * http://www.geocities.com/SiliconValley/8682/aud3.txt
- * http://openquicktime.sourceforge.net/plugins.htm
- * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html
- * http://www.cs.ucla.edu/~leec/mediabench/applications.html
- * SoX source code http://home.sprynet.com/~cbagwell/sox.html
+ * See ADPCM decoder reference documents for codec information.
  */
 
 typedef struct TrellisPath {

libavcodec/arm/dca.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_ARM_DCA_H
+#define AVCODEC_ARM_DCA_H
+
+#include <stdint.h>
+#include "config.h"
+
+#if HAVE_NEON && HAVE_INLINE_ASM
+
+#define int8x8_fmul_int32 int8x8_fmul_int32
+static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
+{
+    __asm__ ("vcvt.f32.s32 %2,  %2,  #4         \n"
+             "vld1.8       {d0},     [%1,:64]   \n"
+             "vmovl.s8     q0,  d0              \n"
+             "vmovl.s16    q1,  d1              \n"
+             "vmovl.s16    q0,  d0              \n"
+             "vcvt.f32.s32 q0,  q0              \n"
+             "vcvt.f32.s32 q1,  q1              \n"
+             "vmul.f32     q0,  q0,  %y2        \n"
+             "vmul.f32     q1,  q1,  %y2        \n"
+             "vst1.32      {q0-q1},  [%m0,:128] \n"
+             : "=Um"(*(float (*)[8])dst)
+             : "r"(src), "x"(scale)
+             : "d0", "d1", "d2", "d3");
+}
+
+#endif
+
+#endif /* AVCODEC_ARM_DCA_H */

libavcodec/dca.c

@@ -42,6 +42,10 @@
 #include "dcadsp.h"
 #include "fmtconvert.h"
 
+#if ARCH_ARM
+#   include "arm/dca.h"
+#endif
+
 //#define TRACE
 
 #define DCA_PRIM_CHANNELS_MAX (7)
@@ -320,7 +324,7 @@ typedef struct {
     int lfe_scale_factor;
 
     /* Subband samples history (for ADPCM) */
-    float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
+    DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
     int hist_index[DCA_PRIM_CHANNELS_MAX];
@@ -1057,6 +1061,16 @@ static int decode_blockcode(int code, int levels, int *values)
 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
 
+#ifndef int8x8_fmul_int32
+static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
+{
+    float fscale = scale / 16.0;
+    int i;
+    for (i = 0; i < 8; i++)
+        dst[i] = src[i] * fscale;
+}
+#endif
+
 static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
 {
     int k, l;
@@ -1161,19 +1175,16 @@ static int dca_subsubframe(DCAContext * s, int base_channel, int block_index)
         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
             /* 1 vector -> 32 samples but we only need the 8 samples
              * for this subsubframe. */
-            int m;
+            int hfvq = s->high_freq_vq[k][l];
 
             if (!s->debug_flag & 0x01) {
                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
                 s->debug_flag |= 0x01;
             }
 
-            for (m = 0; m < 8; m++) {
-                subband_samples[k][l][m] =
-                    high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
-                                                        m]
-                    * (float) s->scale_factor[k][l][0] / 16.0;
-            }
+            int8x8_fmul_int32(subband_samples[k][l],
+                              &high_freq_vq[hfvq][subsubframe * 8],
+                              s->scale_factor[k][l][0]);
         }
     }
 

libavcodec/dcadata.h

@@ -4224,7 +4224,7 @@ static const float lossless_quant_d[32] = {
 
 /* Vector quantization tables */
 
-static const int8_t high_freq_vq[1024][32] =
+DECLARE_ALIGNED(8, static const int8_t, high_freq_vq)[1024][32] =
 {
   {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 },

libavcodec/dpcm.c

@@ -39,17 +39,16 @@
 
 #include "libavutil/intreadwrite.h"
 #include "avcodec.h"
+#include "bytestream.h"
 
 typedef struct DPCMContext {
     int channels;
-    short roq_square_array[256];
-    long sample[2];//for SOL_DPCM
-    const int *sol_table;//for SOL_DPCM
+    int16_t roq_square_array[256];
+    int sample[2];                  ///< previous sample (for SOL_DPCM)
+    const int8_t *sol_table;        ///< delta table for SOL_DPCM
 } DPCMContext;
 
-#define SE_16BIT(x)  if (x & 0x8000) x -= 0x10000;
-
-static const int interplay_delta_table[] = {
+static const int16_t interplay_delta_table[] = {
          0,      1,      2,      3,      4,      5,      6,      7,
          8,      9,     10,     11,     12,     13,     14,     15,
         16,     17,     18,     19,     20,     21,     22,     23,
@@ -85,15 +84,17 @@ static const int interplay_delta_table[] = {
 
 };
 
-static const int sol_table_old[16] =
-    { 0x0,  0x1,  0x2 , 0x3,  0x6,  0xA,  0xF, 0x15,
-    -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1, 0x0};
+static const int8_t sol_table_old[16] = {
+      0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF, 0x15,
+    -0x15, -0xF, -0xA, -0x6, -0x3, -0x2, -0x1,  0x0
+};
 
-static const int sol_table_new[16] =
-    { 0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF,  0x15,
-      0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15};
+static const int8_t sol_table_new[16] = {
+    0x0,  0x1,  0x2,  0x3,  0x6,  0xA,  0xF,  0x15,
+    0x0, -0x1, -0x2, -0x3, -0x6, -0xA, -0xF, -0x15
+};
 
-static const int sol_table_16[128] = {
+static const int16_t sol_table_16[128] = {
     0x000, 0x008, 0x010, 0x020, 0x030, 0x040, 0x050, 0x060, 0x070, 0x080,
     0x090, 0x0A0, 0x0B0, 0x0C0, 0x0D0, 0x0E0, 0x0F0, 0x100, 0x110, 0x120,
     0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1A0, 0x1B0, 0x1C0,
@@ -110,12 +111,15 @@ static const int sol_table_16[128] = {
 };
 
 
-
 static av_cold int dpcm_decode_init(AVCodecContext *avctx)
 {
     DPCMContext *s = avctx->priv_data;
     int i;
-    short square;
+
+    if (avctx->channels < 1 || avctx->channels > 2) {
+        av_log(avctx, AV_LOG_INFO, "invalid number of channels\n");
+        return AVERROR(EINVAL);
+    }
 
     s->channels = avctx->channels;
     s->sample[0] = s->sample[1] = 0;
@@ -125,25 +129,23 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
     case CODEC_ID_ROQ_DPCM:
         /* initialize square table */
         for (i = 0; i < 128; i++) {
-            square = i * i;
-            s->roq_square_array[i] = square;
+            int16_t square = i * i;
+            s->roq_square_array[i      ] =  square;
             s->roq_square_array[i + 128] = -square;
         }
         break;
 
-
     case CODEC_ID_SOL_DPCM:
         switch(avctx->codec_tag){
         case 1:
-            s->sol_table=sol_table_old;
+            s->sol_table = sol_table_old;
             s->sample[0] = s->sample[1] = 0x80;
             break;
         case 2:
-            s->sol_table=sol_table_new;
+            s->sol_table = sol_table_new;
             s->sample[0] = s->sample[1] = 0x80;
             break;
         case 3:
-            s->sol_table=sol_table_16;
             break;
         default:
             av_log(avctx, AV_LOG_ERROR, "Unknown SOL subcodec\n");
@@ -155,146 +157,160 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
         break;
     }
 
-    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+    if (avctx->codec->id == CODEC_ID_SOL_DPCM && avctx->codec_tag != 3)
+        avctx->sample_fmt = AV_SAMPLE_FMT_U8;
+    else
+        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+
     return 0;
 }
 
-static int dpcm_decode_frame(AVCodecContext *avctx,
-                             void *data, int *data_size,
+
+static int dpcm_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                              AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
+    const uint8_t *buf_end = buf + buf_size;
     DPCMContext *s = avctx->priv_data;
-    int in, out = 0;
+    int out = 0;
     int predictor[2];
-    int channel_number = 0;
-    short *output_samples = data;
-    int shift[2];
-    unsigned char byte;
-    short diff;
+    int ch = 0;
+    int stereo = s->channels - 1;
+    int16_t *output_samples = data;
 
     if (!buf_size)
         return 0;
 
-    // almost every DPCM variant expands one byte of data into two
-    if(*data_size/2 < buf_size)
-        return -1;
+    /* calculate output size */
+    switch(avctx->codec->id) {
+    case CODEC_ID_ROQ_DPCM:
+        out = buf_size - 8;
+        break;
+    case CODEC_ID_INTERPLAY_DPCM:
+        out = buf_size - 6 - s->channels;
+        break;
+    case CODEC_ID_XAN_DPCM:
+        out = buf_size - 2 * s->channels;
+        break;
+    case CODEC_ID_SOL_DPCM:
+        if (avctx->codec_tag != 3)
+            out = buf_size * 2;
+        else
+            out = buf_size;
+        break;
+    }
+    out *= av_get_bytes_per_sample(avctx->sample_fmt);
+    if (out < 0) {
+        av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
+        return AVERROR(EINVAL);
+    }
+    if (*data_size < out) {
+        av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
+        return AVERROR(EINVAL);
+    }
 
     switch(avctx->codec->id) {
 
     case CODEC_ID_ROQ_DPCM:
-        if (s->channels == 1)
-            predictor[0] = AV_RL16(&buf[6]);
-        else {
-            predictor[0] = buf[7] << 8;
-            predictor[1] = buf[6] << 8;
+        buf += 6;
+
+        if (stereo) {
+            predictor[1] = (int16_t)(bytestream_get_byte(&buf) << 8);
+            predictor[0] = (int16_t)(bytestream_get_byte(&buf) << 8);
+        } else {
+            predictor[0] = (int16_t)bytestream_get_le16(&buf);
         }
-        SE_16BIT(predictor[0]);
-        SE_16BIT(predictor[1]);
 
         /* decode the samples */
-        for (in = 8, out = 0; in < buf_size; in++, out++) {
-            predictor[channel_number] += s->roq_square_array[buf[in]];
-            predictor[channel_number] = av_clip_int16(predictor[channel_number]);
-            output_samples[out] = predictor[channel_number];
+        while (buf < buf_end) {
+            predictor[ch] += s->roq_square_array[*buf++];
+            predictor[ch]  = av_clip_int16(predictor[ch]);
+            *output_samples++ = predictor[ch];
 
             /* toggle channel */
-            channel_number ^= s->channels - 1;
+            ch ^= stereo;
         }
         break;
 
     case CODEC_ID_INTERPLAY_DPCM:
-        in = 6;  /* skip over the stream mask and stream length */
-        predictor[0] = AV_RL16(&buf[in]);
-        in += 2;
-        SE_16BIT(predictor[0])
-        output_samples[out++] = predictor[0];
-        if (s->channels == 2) {
-            predictor[1] = AV_RL16(&buf[in]);
-            in += 2;
-            SE_16BIT(predictor[1])
-            output_samples[out++] = predictor[1];
+        buf += 6;  /* skip over the stream mask and stream length */
+
+        for (ch = 0; ch < s->channels; ch++) {
+            predictor[ch] = (int16_t)bytestream_get_le16(&buf);
+            *output_samples++ = predictor[ch];
         }
 
-        while (in < buf_size) {
-            predictor[channel_number] += interplay_delta_table[buf[in++]];
-            predictor[channel_number] = av_clip_int16(predictor[channel_number]);
-            output_samples[out++] = predictor[channel_number];
+        ch = 0;
+        while (buf < buf_end) {
+            predictor[ch] += interplay_delta_table[*buf++];
+            predictor[ch]  = av_clip_int16(predictor[ch]);
+            *output_samples++ = predictor[ch];
 
             /* toggle channel */
-            channel_number ^= s->channels - 1;
+            ch ^= stereo;
         }
-
         break;
 
     case CODEC_ID_XAN_DPCM:
-        in = 0;
-        shift[0] = shift[1] = 4;
-        predictor[0] = AV_RL16(&buf[in]);
-        in += 2;
-        SE_16BIT(predictor[0]);
-        if (s->channels == 2) {
-            predictor[1] = AV_RL16(&buf[in]);
-            in += 2;
-            SE_16BIT(predictor[1]);
-        }
-
-        while (in < buf_size) {
-            byte = buf[in++];
-            diff = (byte & 0xFC) << 8;
-            if ((byte & 0x03) == 3)
-                shift[channel_number]++;
+    {
+        int shift[2] = { 4, 4 };
+
+        for (ch = 0; ch < s->channels; ch++)
+            predictor[ch] = (int16_t)bytestream_get_le16(&buf);
+
+        ch = 0;
+        while (buf < buf_end) {
+            uint8_t n = *buf++;
+            int16_t diff = (n & 0xFC) << 8;
+            if ((n & 0x03) == 3)
+                shift[ch]++;
             else
-                shift[channel_number] -= (2 * (byte & 3));
+                shift[ch] -= (2 * (n & 3));
             /* saturate the shifter to a lower limit of 0 */
-            if (shift[channel_number] < 0)
-                shift[channel_number] = 0;
+            if (shift[ch] < 0)
+                shift[ch] = 0;
 
-            diff >>= shift[channel_number];
-            predictor[channel_number] += diff;
+            diff >>= shift[ch];
+            predictor[ch] += diff;
 
-            predictor[channel_number] = av_clip_int16(predictor[channel_number]);
-            output_samples[out++] = predictor[channel_number];
+            predictor[ch] = av_clip_int16(predictor[ch]);
+            *output_samples++ = predictor[ch];
 
             /* toggle channel */
-            channel_number ^= s->channels - 1;
+            ch ^= stereo;
         }
         break;
+    }
     case CODEC_ID_SOL_DPCM:
-        in = 0;
         if (avctx->codec_tag != 3) {
-            if(*data_size/4 < buf_size)
-                return -1;
-            while (in < buf_size) {
-                int n1, n2;
-                n1 = (buf[in] >> 4) & 0xF;
-                n2 = buf[in++] & 0xF;
-                s->sample[0] += s->sol_table[n1];
-                if (s->sample[0] < 0) s->sample[0] = 0;
-                if (s->sample[0] > 255) s->sample[0] = 255;
-                output_samples[out++] = (s->sample[0] - 128) << 8;
-                s->sample[s->channels - 1] += s->sol_table[n2];
-                if (s->sample[s->channels - 1] < 0) s->sample[s->channels - 1] = 0;
-                if (s->sample[s->channels - 1] > 255) s->sample[s->channels - 1] = 255;
-                output_samples[out++] = (s->sample[s->channels - 1] - 128) << 8;
+            uint8_t *output_samples_u8 = data;
+            while (buf < buf_end) {
+                uint8_t n = *buf++;
+
+                s->sample[0] += s->sol_table[n >> 4];
+                s->sample[0]  = av_clip_uint8(s->sample[0]);
+                *output_samples_u8++ = s->sample[0];
+
+                s->sample[stereo] += s->sol_table[n & 0x0F];
+                s->sample[stereo]  = av_clip_uint8(s->sample[stereo]);
+                *output_samples_u8++ = s->sample[stereo];
             }
         } else {
-            while (in < buf_size) {
-                int n;
-                n = buf[in++];
-                if (n & 0x80) s->sample[channel_number] -= s->sol_table[n & 0x7F];
-                else s->sample[channel_number] += s->sol_table[n & 0x7F];
-                s->sample[channel_number] = av_clip_int16(s->sample[channel_number]);
-                output_samples[out++] = s->sample[channel_number];
+            while (buf < buf_end) {
+                uint8_t n = *buf++;
+                if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
+                else          s->sample[ch] += sol_table_16[n & 0x7F];
+                s->sample[ch] = av_clip_int16(s->sample[ch]);
+                *output_samples++ = s->sample[ch];
                 /* toggle channel */
-                channel_number ^= s->channels - 1;
+                ch ^= stereo;
             }
         }
         break;
     }
 
-    *data_size = out * sizeof(short);
+    *data_size = out;
     return buf_size;
 }
 
@@ -310,6 +326,6 @@ AVCodec ff_ ## name_ ## _decoder = {                        \
 }
 
 DPCM_DECODER(CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
-DPCM_DECODER(CODEC_ID_ROQ_DPCM, roq_dpcm, "DPCM id RoQ");
-DPCM_DECODER(CODEC_ID_SOL_DPCM, sol_dpcm, "DPCM Sol");
-DPCM_DECODER(CODEC_ID_XAN_DPCM, xan_dpcm, "DPCM Xan");
+DPCM_DECODER(CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
+DPCM_DECODER(CODEC_ID_SOL_DPCM,       sol_dpcm,       "DPCM Sol");
+DPCM_DECODER(CODEC_ID_XAN_DPCM,       xan_dpcm,       "DPCM Xan");

libavcodec/dxva2_h264.c

@@ -162,18 +162,18 @@ static void fill_scaling_lists(struct dxva_context *ctx, const H264Context *h, D
             for (j = 0; j < 16; j++)
                 qm->bScalingLists4x4[i][j] = h->pps.scaling_matrix4[i][j];
 
-        for (j = 0; j < 64; j++) {
-            qm->bScalingLists8x8[0][j] = h->pps.scaling_matrix8[0][j];
-            qm->bScalingLists8x8[1][j] = h->pps.scaling_matrix8[3][j];
+        for (i = 0; i < 64; i++) {
+            qm->bScalingLists8x8[0][i] = h->pps.scaling_matrix8[0][i];
+            qm->bScalingLists8x8[1][i] = h->pps.scaling_matrix8[3][i];
         }
     } else {
         for (i = 0; i < 6; i++)
             for (j = 0; j < 16; j++)
                 qm->bScalingLists4x4[i][j] = h->pps.scaling_matrix4[i][zigzag_scan[j]];
 
-        for (j = 0; j < 64; j++) {
-            qm->bScalingLists8x8[0][j] = h->pps.scaling_matrix8[0][ff_zigzag_direct[j]];
-            qm->bScalingLists8x8[1][j] = h->pps.scaling_matrix8[3][ff_zigzag_direct[j]];
+        for (i = 0; i < 64; i++) {
+            qm->bScalingLists8x8[0][i] = h->pps.scaling_matrix8[0][ff_zigzag_direct[i]];
+            qm->bScalingLists8x8[1][i] = h->pps.scaling_matrix8[3][ff_zigzag_direct[i]];
         }
     }
 }

libavcodec/proresdec_lgpl.c

@@ -427,13 +427,13 @@ static inline void decode_ac_coeffs(GetBitContext *gb, DCTELEM *out,
         lev_cb_index = lev_to_cb_index[FFMIN(level, 9)];
 
         bits_left = get_bits_left(gb);
-        if (bits_left <= 8 && !show_bits(gb, bits_left))
+        if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))
             return;
 
         run = decode_vlc_codeword(gb, ac_codebook[run_cb_index]);
 
         bits_left = get_bits_left(gb);
-        if (bits_left <= 8 && !show_bits(gb, bits_left))
+        if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))
             return;
 
         level = decode_vlc_codeword(gb, ac_codebook[lev_cb_index]) + 1;