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 {
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);
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)
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) {
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 #if FF_API_CODED_FRAME
251  avctx->coded_frame->key_frame = 1;
253 #endif
254  s->last_key_frame = avctx->frame_number;
255  ff_dlog(avctx, "Inserting keyframe at frame %d\n", avctx->frame_number);
256  } else {
257 #if FF_API_CODED_FRAME
260  avctx->coded_frame->key_frame = 0;
262 #endif
263  }
264 
265  if (I_frame)
266  pkt->flags |= AV_PKT_FLAG_KEY;
267  *got_packet = 1;
268 
269  return 0;
270 }
271 
273  .name = "flashsv",
274  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video"),
275  .type = AVMEDIA_TYPE_VIDEO,
276  .id = AV_CODEC_ID_FLASHSV,
277  .priv_data_size = sizeof(FlashSVContext),
279  .encode2 = flashsv_encode_frame,
280  .close = flashsv_encode_end,
282 };
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
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: packet.h:364
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static AVPacket pkt
AVCodec.
Definition: codec.h:190
uint8_t * encbuffer
Definition: flashsvenc.c:62
AVCodecContext * avctx
Definition: flashsv.c:52
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
uint8_t
#define av_cold
Definition: attributes.h:88
uint8_t * data
Definition: packet.h:363
#define ff_dlog(a,...)
int image_width
Definition: flashsv.c:54
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
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static int flashsv_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: flashsvenc.c:201
int block_width
Definition: flashsv.c:55
uint8_t * tmpblock
Definition: flashsv.c:56
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
const char * name
Name of the codec implementation.
Definition: codec.h:197
AVCodec ff_flashsv_encoder
Definition: flashsvenc.c:272
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int last_key_frame
Definition: flashsvenc.c:64
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
static av_cold int flashsv_encode_end(AVCodecContext *avctx)
Definition: flashsvenc.c:90
int width
picture width / height.
Definition: avcodec.h:699
uint8_t w
Definition: llviddspenc.c:38
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
if(ret)
int block_size
Definition: flashsv.c:57
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
main external API structure.
Definition: avcodec.h:526
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
uint8_t * previous_frame
Definition: flashsvenc.c:59
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:115
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1776
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
void * priv_data
Definition: avcodec.h:553
static av_cold int flashsv_encode_init(AVCodecContext *avctx)
Definition: flashsvenc.c:100
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
#define av_freep(p)
int block_height
Definition: flashsv.c:55
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
int image_height
Definition: flashsv.c:54
bitstream writer API