2 * Flash Screen Video encoder
3 * Copyright (C) 2004 Alex Beregszaszi
4 * Copyright (C) 2006 Benjamin Larsson
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 /* Encoding development sponsored by http://fh-campuswien.ac.at */
27 * Flash Screen Video encoder
28 * @author Alex Beregszaszi
29 * @author Benjamin Larsson
31 * A description of the bitstream format for Flash Screen Video version 1/2
32 * is part of the SWF File Format Specification (version 10), which can be
33 * downloaded from http://www.adobe.com/devnet/swf.html.
37 * Encoding ideas: A basic encoder would just use a fixed block size.
38 * Block sizes can be multiples of 16, from 16 to 256. The blocks don't
39 * have to be quadratic. A brute force search with a set of different
40 * block sizes should give a better result than to just use a fixed size.
43 * Don't reencode the frame in brute force mode if the frame is a dupe.
44 * Speed up. Make the difference check faster.
54 #include "bytestream.h"
57 typedef struct FlashSVContext
{
58 AVCodecContext
*avctx
;
59 uint8_t *previous_frame
;
60 int image_width
, image_height
;
61 int block_width
, block_height
;
69 static int copy_region_enc(uint8_t *sptr
, uint8_t *dptr
, int dx
, int dy
,
70 int h
, int w
, int stride
, uint8_t *pfptr
)
77 for (i
= dx
+ h
; i
> dx
; i
--) {
78 nsptr
= sptr
+ i
* stride
+ dy
* 3;
79 npfptr
= pfptr
+ i
* stride
+ dy
* 3;
80 for (j
= 0; j
< w
* 3; j
++) {
81 diff
|= npfptr
[j
] ^ nsptr
[j
];
91 static av_cold
int flashsv_encode_end(AVCodecContext
*avctx
)
93 FlashSVContext
*s
= avctx
->priv_data
;
95 deflateEnd(&s
->zstream
);
97 av_freep(&s
->encbuffer
);
98 av_freep(&s
->previous_frame
);
99 av_freep(&s
->tmpblock
);
101 av_frame_free(&avctx
->coded_frame
);
106 static av_cold
int flashsv_encode_init(AVCodecContext
*avctx
)
108 FlashSVContext
*s
= avctx
->priv_data
;
112 if (avctx
->width
> 4095 || avctx
->height
> 4095) {
113 av_log(avctx
, AV_LOG_ERROR
,
114 "Input dimensions too large, input must be max 4096x4096 !\n");
115 return AVERROR_INVALIDDATA
;
118 // Needed if zlib unused or init aborted before deflateInit
119 memset(&s
->zstream
, 0, sizeof(z_stream
));
121 s
->last_key_frame
= 0;
123 s
->image_width
= avctx
->width
;
124 s
->image_height
= avctx
->height
;
126 s
->tmpblock
= av_mallocz(3 * 256 * 256);
127 s
->encbuffer
= av_mallocz(s
->image_width
* s
->image_height
* 3);
129 if (!s
->tmpblock
|| !s
->encbuffer
) {
130 av_log(avctx
, AV_LOG_ERROR
, "Memory allocation failed.\n");
131 return AVERROR(ENOMEM
);
134 avctx
->coded_frame
= av_frame_alloc();
135 if (!avctx
->coded_frame
) {
136 flashsv_encode_end(avctx
);
137 return AVERROR(ENOMEM
);
144 static int encode_bitstream(FlashSVContext
*s
, const AVFrame
*p
, uint8_t *buf
,
145 int buf_size
, int block_width
, int block_height
,
146 uint8_t *previous_frame
, int *I_frame
)
150 int h_blocks
, v_blocks
, h_part
, v_part
, i
, j
;
154 init_put_bits(&pb
, buf
, buf_size
* 8);
156 put_bits(&pb
, 4, block_width
/ 16 - 1);
157 put_bits(&pb
, 12, s
->image_width
);
158 put_bits(&pb
, 4, block_height
/ 16 - 1);
159 put_bits(&pb
, 12, s
->image_height
);
163 h_blocks
= s
->image_width
/ block_width
;
164 h_part
= s
->image_width
% block_width
;
165 v_blocks
= s
->image_height
/ block_height
;
166 v_part
= s
->image_height
% block_height
;
168 /* loop over all block columns */
169 for (j
= 0; j
< v_blocks
+ (v_part
? 1 : 0); j
++) {
171 int y_pos
= j
* block_height
; // vertical position in frame
172 int cur_blk_height
= (j
< v_blocks
) ? block_height
: v_part
;
174 /* loop over all block rows */
175 for (i
= 0; i
< h_blocks
+ (h_part
? 1 : 0); i
++) {
176 int x_pos
= i
* block_width
; // horizontal position in frame
177 int cur_blk_width
= (i
< h_blocks
) ? block_width
: h_part
;
179 uint8_t *ptr
= buf
+ buf_pos
;
181 /* copy the block to the temp buffer before compression
182 * (if it differs from the previous frame's block) */
183 res
= copy_region_enc(p
->data
[0], s
->tmpblock
,
184 s
->image_height
- (y_pos
+ cur_blk_height
+ 1),
185 x_pos
, cur_blk_height
, cur_blk_width
,
186 p
->linesize
[0], previous_frame
);
188 if (res
|| *I_frame
) {
189 unsigned long zsize
= 3 * block_width
* block_height
;
190 ret
= compress2(ptr
+ 2, &zsize
, s
->tmpblock
,
191 3 * cur_blk_width
* cur_blk_height
, 9);
193 //ret = deflateReset(&s->zstream);
195 av_log(s
->avctx
, AV_LOG_ERROR
,
196 "error while compressing block %dx%d\n", i
, j
);
198 bytestream_put_be16(&ptr
, zsize
);
199 buf_pos
+= zsize
+ 2;
200 av_dlog(s
->avctx
, "buf_pos = %d\n", buf_pos
);
203 bytestream_put_be16(&ptr
, 0);
218 static int flashsv_encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
219 const AVFrame
*pict
, int *got_packet
)
221 FlashSVContext
* const s
= avctx
->priv_data
;
222 const AVFrame
* const p
= pict
;
226 int opt_w
= 4, opt_h
= 4;
228 /* First frame needs to be a keyframe */
229 if (avctx
->frame_number
== 0) {
230 s
->previous_frame
= av_mallocz(FFABS(p
->linesize
[0]) * s
->image_height
);
231 if (!s
->previous_frame
) {
232 av_log(avctx
, AV_LOG_ERROR
, "Memory allocation failed.\n");
233 return AVERROR(ENOMEM
);
238 if (p
->linesize
[0] < 0)
239 pfptr
= s
->previous_frame
- (s
->image_height
- 1) * p
->linesize
[0];
241 pfptr
= s
->previous_frame
;
243 /* Check the placement of keyframes */
244 if (avctx
->gop_size
> 0 &&
245 avctx
->frame_number
>= s
->last_key_frame
+ avctx
->gop_size
) {
249 if ((res
= ff_alloc_packet2(avctx
, pkt
, s
->image_width
* s
->image_height
* 3)) < 0)
252 pkt
->size
= encode_bitstream(s
, p
, pkt
->data
, pkt
->size
, opt_w
* 16, opt_h
* 16,
255 //save the current frame
256 if (p
->linesize
[0] > 0)
257 memcpy(s
->previous_frame
, p
->data
[0], s
->image_height
* p
->linesize
[0]);
259 memcpy(s
->previous_frame
,
260 p
->data
[0] + p
->linesize
[0] * (s
->image_height
- 1),
261 s
->image_height
* FFABS(p
->linesize
[0]));
263 //mark the frame type so the muxer can mux it correctly
265 avctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
266 avctx
->coded_frame
->key_frame
= 1;
267 s
->last_key_frame
= avctx
->frame_number
;
268 av_dlog(avctx
, "Inserting keyframe at frame %d\n", avctx
->frame_number
);
270 avctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_P
;
271 avctx
->coded_frame
->key_frame
= 0;
274 if (avctx
->coded_frame
->key_frame
)
275 pkt
->flags
|= AV_PKT_FLAG_KEY
;
281 AVCodec ff_flashsv_encoder
= {
283 .long_name
= NULL_IF_CONFIG_SMALL("Flash Screen Video"),
284 .type
= AVMEDIA_TYPE_VIDEO
,
285 .id
= AV_CODEC_ID_FLASHSV
,
286 .priv_data_size
= sizeof(FlashSVContext
),
287 .init
= flashsv_encode_init
,
288 .encode2
= flashsv_encode_frame
,
289 .close
= flashsv_encode_end
,
290 .pix_fmts
= (const enum AVPixelFormat
[]){ AV_PIX_FMT_BGR24
, AV_PIX_FMT_NONE
},