Merge remote-tracking branch 'qatar/master'

* qatar/master: (22 commits)
  arm: remove disabled function dct_unquantize_h263_inter_iwmmxt()
  Remove commented-out call to non-existing function print_pow1().
  Do not decode RV30 files if the extradata is too small
  flashsv: split flashsv_decode_block() off from flashsv_decode_frame().
  ppc: remove disabled code
  libspeexdec: Drop const qualifier to silence compiler warning.
  libopenjpeg: Drop const qualifier to silence compiler warning.
  alac: Remove unused dummy code.
  Remove unused structs and tables.
  vaapi: do not assert on value read from input bitstream
  flashsvenc: replace bitstream description by a link to the specification
  flashsvenc: drop unnecessary cast
  flashsvenc: improve some variable names and fix corresponding comments
  flashsvenc: merge two consecutive if-conditions
  flashsvenc: merge variable declarations and initializations
  flashsvenc: convert some debug av_log() to av_dlog()
  flashsvenc: whitespace cosmetics
  flashsvenc: drop some unnecessary parentheses
  flashsvenc: fix some comment typos
  aacps: skip some memcpy() if src and dst would be equal
  ...

Conflicts:
	libavcodec/vaapi_mpeg2.c
	libavformat/aviobuf.c

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

1 files changed, 49 insertions, 61 deletions

diff --git a/libavcodec/flashsvenc.c b/libavcodec/flashsvenc.c
index c0327a911b..7e21e7d534 100644
--- a/libavcodec/flashsvenc.c
+++ b/libavcodec/flashsvenc.c
@@ -27,31 +27,21 @@
  * Flash Screen Video encoder
  * @author Alex Beregszaszi
  * @author Benjamin Larsson
+ *
+ * A description of the bitstream format for Flash Screen Video version 1/2
+ * is part of the SWF File Format Specification (version 10), which can be
+ * downloaded from http://www.adobe.com/devnet/swf.html.
  */
 
-/* Bitstream description
- * The picture is divided into blocks that are zlib-compressed.
- *
- * The decoder is fed complete frames, the frameheader contains:
- * 4bits of block width
- * 12bits of frame width
- * 4bits of block height
- * 12bits of frame height
- *
- * Directly after the header are the compressed blocks. The blocks
- * have their compressed size represented with 16bits in the beginig.
- * If the size = 0 then the block is unchanged from the previous frame.
- * All blocks are decompressed until the buffer is consumed.
- *
- * Encoding ideas, a basic encoder would just use a fixed block size.
- * Block sizes can be multipels of 16, from 16 to 256. The blocks don't
+/*
+ * Encoding ideas: A basic encoder would just use a fixed block size.
+ * Block sizes can be multiples of 16, from 16 to 256. The blocks don't
  * have to be quadratic. A brute force search with a set of different
  * block sizes should give a better result than to just use a fixed size.
- */
-
-/* TODO:
- * Don't reencode the frame in brute force mode if the frame is a dupe. Speed up.
- * Make the difference check faster.
+ *
+ * TODO:
+ * Don't reencode the frame in brute force mode if the frame is a dupe.
+ * Speed up. Make the difference check faster.
  */
 
 #include <stdio.h>
@@ -85,8 +75,8 @@ static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, int dx, int dy,
     int diff = 0;
 
     for (i = dx + h; i > dx; i--) {
-        nsptr  = sptr  + (i * stride) + dy * 3;
-        npfptr = pfptr + (i * stride) + dy * 3;
+        nsptr  = sptr  + i * stride + dy * 3;
+        npfptr = pfptr + i * stride + dy * 3;
         for (j = 0; j < w * 3; j++) {
             diff    |= npfptr[j] ^ nsptr[j];
             dptr[j]  = nsptr[j];
@@ -104,13 +94,14 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
 
     s->avctx = avctx;
 
-    if ((avctx->width > 4095) || (avctx->height > 4095)) {
-        av_log(avctx, AV_LOG_ERROR, "Input dimensions too large, input must be max 4096x4096 !\n");
+    if (avctx->width > 4095 || avctx->height > 4095) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Input dimensions too large, input must be max 4096x4096 !\n");
         return AVERROR_INVALIDDATA;
     }
 
     // Needed if zlib unused or init aborted before deflateInit
-    memset(&(s->zstream), 0, sizeof(z_stream));
+    memset(&s->zstream, 0, sizeof(z_stream));
 
     s->last_key_frame = 0;
 
@@ -141,9 +132,9 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf,
 
     init_put_bits(&pb, buf, buf_size * 8);
 
-    put_bits(&pb,  4, (block_width / 16) - 1);
+    put_bits(&pb,  4, block_width / 16 - 1);
     put_bits(&pb, 12, s->image_width);
-    put_bits(&pb,  4, (block_height / 16) - 1);
+    put_bits(&pb,  4, block_height / 16 - 1);
     put_bits(&pb, 12, s->image_height);
     flush_put_bits(&pb);
     buf_pos = 4;
@@ -156,37 +147,36 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf,
     /* loop over all block columns */
     for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 
-        int hp = j * block_height; // horiz position in frame
-        int hs = (j < v_blocks) ? block_height : v_part; // size of block
+        int y_pos = j * block_height; // vertical position in frame
+        int cur_blk_height = (j < v_blocks) ? block_height : v_part;
 
         /* loop over all block rows */
         for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
-            int wp  = i * block_width; // vert position in frame
-            int ws  = (i < h_blocks) ? block_width : h_part; // size of block
+            int x_pos = i * block_width; // horizontal position in frame
+            int cur_blk_width = (i < h_blocks) ? block_width : h_part;
             int ret = Z_OK;
-            uint8_t *ptr;
-
-            ptr = buf + buf_pos;
+            uint8_t *ptr = buf + buf_pos;
 
             /* copy the block to the temp buffer before compression
              * (if it differs from the previous frame's block) */
             res = copy_region_enc(p->data[0], s->tmpblock,
-                                  s->image_height - (hp + hs + 1),
-                                  wp, hs, ws, p->linesize[0], previous_frame);
+                                  s->image_height - (y_pos + cur_blk_height + 1),
+                                  x_pos, cur_blk_height, cur_blk_width,
+                                  p->linesize[0], previous_frame);
 
             if (res || *I_frame) {
-                unsigned long zsize;
-                zsize = 3 * block_width * block_height;
-                ret   = compress2(ptr + 2, &zsize, s->tmpblock, 3 * ws * hs, 9);
-
+                unsigned long zsize = 3 * block_width * block_height;
+                ret = compress2(ptr + 2, &zsize, s->tmpblock,
+                                3 * cur_blk_width * cur_blk_height, 9);
 
-                //ret = deflateReset(&(s->zstream));
+                //ret = deflateReset(&s->zstream);
                 if (ret != Z_OK)
-                    av_log(s->avctx, AV_LOG_ERROR, "error while compressing block %dx%d\n", i, j);
+                    av_log(s->avctx, AV_LOG_ERROR,
+                           "error while compressing block %dx%d\n", i, j);
 
-                bytestream_put_be16(&ptr, (unsigned int) zsize);
+                bytestream_put_be16(&ptr, zsize);
                 buf_pos += zsize + 2;
-                //av_log(avctx, AV_LOG_ERROR, "buf_pos = %d\n", buf_pos);
+                av_dlog(s->avctx, "buf_pos = %d\n", buf_pos);
             } else {
                 pred_blocks++;
                 bytestream_put_be16(&ptr, 0);
@@ -213,7 +203,7 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,
     uint8_t *pfptr;
     int res;
     int I_frame = 0;
-    int opt_w, opt_h;
+    int opt_w = 4, opt_h = 4;
 
     *p = *pict;
 
@@ -228,42 +218,40 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,
     }
 
     if (p->linesize[0] < 0)
-        pfptr = s->previous_frame - ((s->image_height - 1) * p->linesize[0]);
+        pfptr = s->previous_frame - (s->image_height - 1) * p->linesize[0];
     else
         pfptr = s->previous_frame;
 
     /* Check the placement of keyframes */
-    if (avctx->gop_size > 0) {
-        if (avctx->frame_number >= s->last_key_frame + avctx->gop_size) {
-            I_frame = 1;
-        }
+    if (avctx->gop_size > 0 &&
+        avctx->frame_number >= s->last_key_frame + avctx->gop_size) {
+        I_frame = 1;
     }
 
-    opt_w = 4;
-    opt_h = 4;
-
-    if (buf_size < s->image_width*s->image_height*3) {
+    if (buf_size < s->image_width * s->image_height * 3) {
         //Conservative upper bound check for compressed data
         av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n",
                buf_size, s->image_width * s->image_height * 3);
         return -1;
     }
 
-    res = encode_bitstream(s, p, buf, buf_size, opt_w * 16, opt_h * 16, pfptr, &I_frame);
+    res = encode_bitstream(s, p, buf, buf_size, opt_w * 16, opt_h * 16,
+                           pfptr, &I_frame);
 
     //save the current frame
     if (p->linesize[0] > 0)
         memcpy(s->previous_frame, p->data[0], s->image_height * p->linesize[0]);
     else
-        memcpy(s->previous_frame, p->data[0] + p->linesize[0] * (s->image_height - 1),
+        memcpy(s->previous_frame,
+               p->data[0] + p->linesize[0] * (s->image_height - 1),
                s->image_height * FFABS(p->linesize[0]));
 
     //mark the frame type so the muxer can mux it correctly
     if (I_frame) {
-        p->pict_type = AV_PICTURE_TYPE_I;
-        p->key_frame = 1;
+        p->pict_type      = AV_PICTURE_TYPE_I;
+        p->key_frame      = 1;
         s->last_key_frame = avctx->frame_number;
-        av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
+        av_dlog(avctx, "Inserting keyframe at frame %d\n", avctx->frame_number);
     } else {
         p->pict_type = AV_PICTURE_TYPE_P;
         p->key_frame = 0;
@@ -278,7 +266,7 @@ static av_cold int flashsv_encode_end(AVCodecContext *avctx)
 {
     FlashSVContext *s = avctx->priv_data;
 
-    deflateEnd(&(s->zstream));
+    deflateEnd(&s->zstream);
 
     av_free(s->encbuffer);
     av_free(s->previous_frame);