apps/ffmpeg-rockchip
1
0
Fork 0
mirror of https://github.com/nyanmisaka/ffmpeg-rockchip.git synced 2025-11-02 13:24:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* 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>
This commit is contained in:
Michael Niedermayer
2011-07-16 19:40:35 +02:00
parent c31a5b23b4 8342a82680
commit 15285d8fc5
20 changed files with 144 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
libavcodec/flashsvenc.c
View File

@@ -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);