| 1 | /* |
| 2 | * Flash Screen Video encoder |
| 3 | * Copyright (C) 2004 Alex Beregszaszi |
| 4 | * Copyright (C) 2006 Benjamin Larsson |
| 5 | * |
| 6 | * This file is part of FFmpeg. |
| 7 | * |
| 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. |
| 12 | * |
| 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. |
| 17 | * |
| 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 |
| 21 | */ |
| 22 | |
| 23 | /* Encoding development sponsored by http://fh-campuswien.ac.at */ |
| 24 | |
| 25 | /** |
| 26 | * @file |
| 27 | * Flash Screen Video encoder |
| 28 | * @author Alex Beregszaszi |
| 29 | * @author Benjamin Larsson |
| 30 | * |
| 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. |
| 34 | */ |
| 35 | |
| 36 | /* |
| 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. |
| 41 | * |
| 42 | * TODO: |
| 43 | * Don't reencode the frame in brute force mode if the frame is a dupe. |
| 44 | * Speed up. Make the difference check faster. |
| 45 | */ |
| 46 | |
| 47 | #include <stdio.h> |
| 48 | #include <stdlib.h> |
| 49 | #include <zlib.h> |
| 50 | |
| 51 | #include "avcodec.h" |
| 52 | #include "internal.h" |
| 53 | #include "put_bits.h" |
| 54 | #include "bytestream.h" |
| 55 | |
| 56 | |
| 57 | typedef struct FlashSVContext { |
| 58 | AVCodecContext *avctx; |
| 59 | uint8_t *previous_frame; |
| 60 | int image_width, image_height; |
| 61 | int block_width, block_height; |
| 62 | uint8_t *tmpblock; |
| 63 | uint8_t *encbuffer; |
| 64 | int block_size; |
| 65 | z_stream zstream; |
| 66 | int last_key_frame; |
| 67 | } FlashSVContext; |
| 68 | |
| 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) |
| 71 | { |
| 72 | int i, j; |
| 73 | uint8_t *nsptr; |
| 74 | uint8_t *npfptr; |
| 75 | int diff = 0; |
| 76 | |
| 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]; |
| 82 | dptr[j] = nsptr[j]; |
| 83 | } |
| 84 | dptr += w * 3; |
| 85 | } |
| 86 | if (diff) |
| 87 | return 1; |
| 88 | return 0; |
| 89 | } |
| 90 | |
| 91 | static av_cold int flashsv_encode_end(AVCodecContext *avctx) |
| 92 | { |
| 93 | FlashSVContext *s = avctx->priv_data; |
| 94 | |
| 95 | deflateEnd(&s->zstream); |
| 96 | |
| 97 | av_free(s->encbuffer); |
| 98 | av_free(s->previous_frame); |
| 99 | av_free(s->tmpblock); |
| 100 | |
| 101 | av_frame_free(&avctx->coded_frame); |
| 102 | |
| 103 | return 0; |
| 104 | } |
| 105 | |
| 106 | static av_cold int flashsv_encode_init(AVCodecContext *avctx) |
| 107 | { |
| 108 | FlashSVContext *s = avctx->priv_data; |
| 109 | |
| 110 | s->avctx = avctx; |
| 111 | |
| 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; |
| 116 | } |
| 117 | |
| 118 | // Needed if zlib unused or init aborted before deflateInit |
| 119 | memset(&s->zstream, 0, sizeof(z_stream)); |
| 120 | |
| 121 | s->last_key_frame = 0; |
| 122 | |
| 123 | s->image_width = avctx->width; |
| 124 | s->image_height = avctx->height; |
| 125 | |
| 126 | s->tmpblock = av_mallocz(3 * 256 * 256); |
| 127 | s->encbuffer = av_mallocz(s->image_width * s->image_height * 3); |
| 128 | |
| 129 | if (!s->tmpblock || !s->encbuffer) { |
| 130 | av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n"); |
| 131 | return AVERROR(ENOMEM); |
| 132 | } |
| 133 | |
| 134 | avctx->coded_frame = av_frame_alloc(); |
| 135 | if (!avctx->coded_frame) { |
| 136 | flashsv_encode_end(avctx); |
| 137 | return AVERROR(ENOMEM); |
| 138 | } |
| 139 | |
| 140 | return 0; |
| 141 | } |
| 142 | |
| 143 | |
| 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) |
| 147 | { |
| 148 | |
| 149 | PutBitContext pb; |
| 150 | int h_blocks, v_blocks, h_part, v_part, i, j; |
| 151 | int buf_pos, res; |
| 152 | int pred_blocks = 0; |
| 153 | |
| 154 | init_put_bits(&pb, buf, buf_size * 8); |
| 155 | |
| 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); |
| 160 | flush_put_bits(&pb); |
| 161 | buf_pos = 4; |
| 162 | |
| 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; |
| 167 | |
| 168 | /* loop over all block columns */ |
| 169 | for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) { |
| 170 | |
| 171 | int y_pos = j * block_height; // vertical position in frame |
| 172 | int cur_blk_height = (j < v_blocks) ? block_height : v_part; |
| 173 | |
| 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; |
| 178 | int ret = Z_OK; |
| 179 | uint8_t *ptr = buf + buf_pos; |
| 180 | |
| 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); |
| 187 | |
| 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); |
| 192 | |
| 193 | //ret = deflateReset(&s->zstream); |
| 194 | if (ret != Z_OK) |
| 195 | av_log(s->avctx, AV_LOG_ERROR, |
| 196 | "error while compressing block %dx%d\n", i, j); |
| 197 | |
| 198 | bytestream_put_be16(&ptr, zsize); |
| 199 | buf_pos += zsize + 2; |
| 200 | av_dlog(s->avctx, "buf_pos = %d\n", buf_pos); |
| 201 | } else { |
| 202 | pred_blocks++; |
| 203 | bytestream_put_be16(&ptr, 0); |
| 204 | buf_pos += 2; |
| 205 | } |
| 206 | } |
| 207 | } |
| 208 | |
| 209 | if (pred_blocks) |
| 210 | *I_frame = 0; |
| 211 | else |
| 212 | *I_frame = 1; |
| 213 | |
| 214 | return buf_pos; |
| 215 | } |
| 216 | |
| 217 | |
| 218 | static int flashsv_encode_frame(AVCodecContext *avctx, AVPacket *pkt, |
| 219 | const AVFrame *pict, int *got_packet) |
| 220 | { |
| 221 | FlashSVContext * const s = avctx->priv_data; |
| 222 | const AVFrame * const p = pict; |
| 223 | uint8_t *pfptr; |
| 224 | int res; |
| 225 | int I_frame = 0; |
| 226 | int opt_w = 4, opt_h = 4; |
| 227 | |
| 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); |
| 234 | } |
| 235 | I_frame = 1; |
| 236 | } |
| 237 | |
| 238 | if (p->linesize[0] < 0) |
| 239 | pfptr = s->previous_frame - (s->image_height - 1) * p->linesize[0]; |
| 240 | else |
| 241 | pfptr = s->previous_frame; |
| 242 | |
| 243 | /* Check the placement of keyframes */ |
| 244 | if (avctx->gop_size > 0 && |
| 245 | avctx->frame_number >= s->last_key_frame + avctx->gop_size) { |
| 246 | I_frame = 1; |
| 247 | } |
| 248 | |
| 249 | if ((res = ff_alloc_packet2(avctx, pkt, s->image_width * s->image_height * 3)) < 0) |
| 250 | return res; |
| 251 | |
| 252 | pkt->size = encode_bitstream(s, p, pkt->data, pkt->size, opt_w * 16, opt_h * 16, |
| 253 | pfptr, &I_frame); |
| 254 | |
| 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]); |
| 258 | else |
| 259 | memcpy(s->previous_frame, |
| 260 | p->data[0] + p->linesize[0] * (s->image_height - 1), |
| 261 | s->image_height * FFABS(p->linesize[0])); |
| 262 | |
| 263 | //mark the frame type so the muxer can mux it correctly |
| 264 | if (I_frame) { |
| 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); |
| 269 | } else { |
| 270 | avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P; |
| 271 | avctx->coded_frame->key_frame = 0; |
| 272 | } |
| 273 | |
| 274 | if (avctx->coded_frame->key_frame) |
| 275 | pkt->flags |= AV_PKT_FLAG_KEY; |
| 276 | *got_packet = 1; |
| 277 | |
| 278 | return 0; |
| 279 | } |
| 280 | |
| 281 | AVCodec ff_flashsv_encoder = { |
| 282 | .name = "flashsv", |
| 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 }, |
| 291 | }; |