FFmpeg
flashsvenc.c
Go to the documentation of this file.
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 {
59  uint8_t *previous_frame;
62  uint8_t *encbuffer;
63  int block_size;
65  uint8_t tmpblock[3 * 256 * 256];
67 
68 static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, int dx, int dy,
69  int h, int w, int stride, uint8_t *pfptr)
70 {
71  int i, j;
72  uint8_t *nsptr;
73  uint8_t *npfptr;
74  int diff = 0;
75 
76  for (i = dx + h; i > dx; i--) {
77  nsptr = sptr + i * stride + dy * 3;
78  npfptr = pfptr + i * stride + dy * 3;
79  for (j = 0; j < w * 3; j++) {
80  diff |= npfptr[j] ^ nsptr[j];
81  dptr[j] = nsptr[j];
82  }
83  dptr += w * 3;
84  }
85  if (diff)
86  return 1;
87  return 0;
88 }
89 
91 {
92  FlashSVContext *s = avctx->priv_data;
93 
94  av_freep(&s->encbuffer);
95  av_freep(&s->previous_frame);
96 
97  return 0;
98 }
99 
101 {
102  FlashSVContext *s = avctx->priv_data;
103 
104  s->avctx = avctx;
105 
106  if (avctx->width > 4095 || avctx->height > 4095) {
107  av_log(avctx, AV_LOG_ERROR,
108  "Input dimensions too large, input must be max 4095x4095 !\n");
109  return AVERROR_INVALIDDATA;
110  }
111 
112  s->last_key_frame = 0;
113 
114  s->image_width = avctx->width;
115  s->image_height = avctx->height;
116 
117  s->encbuffer = av_mallocz(s->image_width * s->image_height * 3);
118 
119  if (!s->encbuffer) {
120  av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
121  return AVERROR(ENOMEM);
122  }
123 
124  return 0;
125 }
126 
127 
128 static int encode_bitstream(FlashSVContext *s, const AVFrame *p, uint8_t *buf,
129  int buf_size, int block_width, int block_height,
130  uint8_t *previous_frame, int *I_frame)
131 {
132 
133  PutBitContext pb;
134  int h_blocks, v_blocks, h_part, v_part, i, j;
135  int buf_pos, res;
136  int pred_blocks = 0;
137 
138  init_put_bits(&pb, buf, buf_size);
139 
140  put_bits(&pb, 4, block_width / 16 - 1);
141  put_bits(&pb, 12, s->image_width);
142  put_bits(&pb, 4, block_height / 16 - 1);
143  put_bits(&pb, 12, s->image_height);
144  flush_put_bits(&pb);
145  buf_pos = 4;
146 
147  h_blocks = s->image_width / block_width;
148  h_part = s->image_width % block_width;
149  v_blocks = s->image_height / block_height;
150  v_part = s->image_height % block_height;
151 
152  /* loop over all block columns */
153  for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
154 
155  int y_pos = j * block_height; // vertical position in frame
156  int cur_blk_height = (j < v_blocks) ? block_height : v_part;
157 
158  /* loop over all block rows */
159  for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
160  int x_pos = i * block_width; // horizontal position in frame
161  int cur_blk_width = (i < h_blocks) ? block_width : h_part;
162  int ret = Z_OK;
163  uint8_t *ptr = buf + buf_pos;
164 
165  /* copy the block to the temp buffer before compression
166  * (if it differs from the previous frame's block) */
167  res = copy_region_enc(p->data[0], s->tmpblock,
168  s->image_height - (y_pos + cur_blk_height + 1),
169  x_pos, cur_blk_height, cur_blk_width,
170  p->linesize[0], previous_frame);
171 
172  if (res || *I_frame) {
173  unsigned long zsize = 3 * block_width * block_height;
174  ret = compress2(ptr + 2, &zsize, s->tmpblock,
175  3 * cur_blk_width * cur_blk_height, 9);
176 
177  if (ret != Z_OK)
178  av_log(s->avctx, AV_LOG_ERROR,
179  "error while compressing block %dx%d\n", i, j);
180 
181  bytestream_put_be16(&ptr, zsize);
182  buf_pos += zsize + 2;
183  ff_dlog(s->avctx, "buf_pos = %d\n", buf_pos);
184  } else {
185  pred_blocks++;
186  bytestream_put_be16(&ptr, 0);
187  buf_pos += 2;
188  }
189  }
190  }
191 
192  if (pred_blocks)
193  *I_frame = 0;
194  else
195  *I_frame = 1;
196 
197  return buf_pos;
198 }
199 
200 
202  const AVFrame *pict, int *got_packet)
203 {
204  FlashSVContext * const s = avctx->priv_data;
205  const AVFrame * const p = pict;
206  uint8_t *pfptr;
207  int res;
208  int I_frame = 0;
209  int opt_w = 4, opt_h = 4;
210 
211  /* First frame needs to be a keyframe */
212  if (avctx->frame_number == 0) {
213  s->previous_frame = av_mallocz(FFABS(p->linesize[0]) * s->image_height);
214  if (!s->previous_frame) {
215  av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
216  return AVERROR(ENOMEM);
217  }
218  I_frame = 1;
219  }
220 
221  if (p->linesize[0] < 0)
222  pfptr = s->previous_frame - (s->image_height - 1) * p->linesize[0];
223  else
224  pfptr = s->previous_frame;
225 
226  /* Check the placement of keyframes */
227  if (avctx->gop_size > 0 &&
228  avctx->frame_number >= s->last_key_frame + avctx->gop_size) {
229  I_frame = 1;
230  }
231 
232  if ((res = ff_alloc_packet2(avctx, pkt, s->image_width * s->image_height * 3, 0)) < 0)
233  return res;
234 
235  pkt->size = encode_bitstream(s, p, pkt->data, pkt->size, opt_w * 16, opt_h * 16,
236  pfptr, &I_frame);
237 
238  //save the current frame
239  if (p->linesize[0] > 0)
240  memcpy(s->previous_frame, p->data[0], s->image_height * p->linesize[0]);
241  else
242  memcpy(s->previous_frame,
243  p->data[0] + p->linesize[0] * (s->image_height - 1),
244  s->image_height * FFABS(p->linesize[0]));
245 
246  //mark the frame type so the muxer can mux it correctly
247  if (I_frame) {
248  s->last_key_frame = avctx->frame_number;
249  ff_dlog(avctx, "Inserting keyframe at frame %d\n", avctx->frame_number);
250  }
251 
252  if (I_frame)
254  *got_packet = 1;
255 
256  return 0;
257 }
258 
260  .name = "flashsv",
261  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
262  .type = AVMEDIA_TYPE_VIDEO,
263  .id = AV_CODEC_ID_FLASHSV,
264  .priv_data_size = sizeof(FlashSVContext),
266  .encode2 = flashsv_encode_frame,
267  .close = flashsv_encode_end,
269  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
270 };
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
FlashSVContext::image_width
int image_width
Definition: flashsv.c:54
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:219
w
uint8_t w
Definition: llviddspenc.c:39
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:396
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
FlashSVContext::encbuffer
uint8_t * encbuffer
Definition: flashsvenc.c:62
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
FlashSVContext::tmpblock
uint8_t * tmpblock
Definition: flashsv.c:56
s
#define s(width, name)
Definition: cbs_vp9.c:257
flashsv_encode_frame
static int flashsv_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: flashsvenc.c:201
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:289
PutBitContext
Definition: put_bits.h:49
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
FlashSVContext
Definition: flashsv.c:51
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:135
copy_region_enc
static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, int dx, int dy, int h, int w, int stride, uint8_t *pfptr)
Definition: flashsvenc.c:68
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:696
flashsv_encode_init
static av_cold int flashsv_encode_init(AVCodecContext *avctx)
Definition: flashsvenc.c:100
FlashSVContext::block_height
int block_height
Definition: flashsv.c:55
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:371
FlashSVContext::block_width
int block_width
Definition: flashsv.c:55
i
int i
Definition: input.c:407
FlashSVContext::block_size
int block_size
Definition: flashsv.c:57
FlashSVContext::image_height
int image_height
Definition: flashsv.c:54
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:243
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:674
avcodec.h
flashsv_encode_end
static av_cold int flashsv_encode_end(AVCodecContext *avctx)
Definition: flashsvenc.c:90
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:501
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
FlashSVContext::previous_frame
uint8_t * previous_frame
Definition: flashsvenc.c:59
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1129
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:674
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
FlashSVContext::avctx
AVCodecContext * avctx
Definition: flashsv.c:52
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
put_bits.h
FlashSVContext::last_key_frame
int last_key_frame
Definition: flashsvenc.c:64
ff_flashsv_encoder
const AVCodec ff_flashsv_encoder
Definition: flashsvenc.c:259
encode_bitstream
static int encode_bitstream(FlashSVContext *s, const AVFrame *p, uint8_t *buf, int buf_size, int block_width, int block_height, uint8_t *previous_frame, int *I_frame)
Definition: flashsvenc.c:128