FFmpeg
xfaceenc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 1990 James Ashton - Sydney University
3  * Copyright (c) 2012 Stefano Sabatini
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * X-Face encoder, based on libcompface, by James Ashton.
25  */
26 
27 #include "xface.h"
28 #include "avcodec.h"
29 #include "internal.h"
30 #include "libavutil/avassert.h"
31 
32 typedef struct XFaceContext {
33  AVClass *class;
34  uint8_t bitmap[XFACE_PIXELS]; ///< image used internally for decoding
35  int max_line_len; ///< max line length for compressed data
36  int set_header; ///< set X-Face header in the output
37 } XFaceContext;
38 
39 static int all_same(char *bitmap, int w, int h)
40 {
41  char val, *row;
42  int x;
43 
44  val = *bitmap;
45  while (h--) {
46  row = bitmap;
47  x = w;
48  while (x--)
49  if (*(row++) != val)
50  return 0;
51  bitmap += XFACE_WIDTH;
52  }
53  return 1;
54 }
55 
56 static int all_black(char *bitmap, int w, int h)
57 {
58  if (w > 3) {
59  w /= 2;
60  h /= 2;
61  return (all_black(bitmap, w, h) && all_black(bitmap + w, w, h) &&
62  all_black(bitmap + XFACE_WIDTH * h, w, h) &&
63  all_black(bitmap + XFACE_WIDTH * h + w, w, h));
64  } else {
65  /* at least one pixel in the 2x2 grid is non-zero */
66  return *bitmap || *(bitmap + 1) ||
67  *(bitmap + XFACE_WIDTH) || *(bitmap + XFACE_WIDTH + 1);
68  }
69 }
70 
71 static int all_white(char *bitmap, int w, int h)
72 {
73  return *bitmap == 0 && all_same(bitmap, w, h);
74 }
75 
76 typedef struct {
77  ProbRange prob_ranges[XFACE_PIXELS*2];
80 
81 static inline int pq_push(ProbRangesQueue *pq, const ProbRange *p)
82 {
83  if (pq->prob_ranges_idx >= XFACE_PIXELS * 2 - 1)
84  return -1;
85  pq->prob_ranges[pq->prob_ranges_idx++] = *p;
86  return 0;
87 }
88 
89 static void push_greys(ProbRangesQueue *pq, char *bitmap, int w, int h)
90 {
91  if (w > 3) {
92  w /= 2;
93  h /= 2;
94  push_greys(pq, bitmap, w, h);
95  push_greys(pq, bitmap + w, w, h);
96  push_greys(pq, bitmap + XFACE_WIDTH * h, w, h);
97  push_greys(pq, bitmap + XFACE_WIDTH * h + w, w, h);
98  } else {
100  *bitmap +
101  2 * *(bitmap + 1) +
102  4 * *(bitmap + XFACE_WIDTH) +
103  8 * *(bitmap + XFACE_WIDTH + 1);
104  pq_push(pq, p);
105  }
106 }
107 
108 static void encode_block(char *bitmap, int w, int h, int level, ProbRangesQueue *pq)
109 {
110  if (all_white(bitmap, w, h)) {
112  } else if (all_black(bitmap, w, h)) {
114  push_greys(pq, bitmap, w, h);
115  } else {
117  w /= 2;
118  h /= 2;
119  level++;
120  encode_block(bitmap, w, h, level, pq);
121  encode_block(bitmap + w, w, h, level, pq);
122  encode_block(bitmap + h * XFACE_WIDTH, w, h, level, pq);
123  encode_block(bitmap + w + h * XFACE_WIDTH, w, h, level, pq);
124  }
125 }
126 
127 static void push_integer(BigInt *b, const ProbRange *prange)
128 {
129  uint8_t r;
130 
131  ff_big_div(b, prange->range, &r);
132  ff_big_mul(b, 0);
133  ff_big_add(b, r + prange->offset);
134 }
135 
137  const AVFrame *frame, int *got_packet)
138 {
139  XFaceContext *xface = avctx->priv_data;
140  ProbRangesQueue pq = {{{ 0 }}, 0};
141  uint8_t bitmap_copy[XFACE_PIXELS];
142  BigInt b = {0};
143  int i, j, k, ret = 0;
144  const uint8_t *buf;
145  uint8_t *p;
146  char intbuf[XFACE_MAX_DIGITS];
147 
148  if (avctx->width || avctx->height) {
149  if (avctx->width != XFACE_WIDTH || avctx->height != XFACE_HEIGHT) {
150  av_log(avctx, AV_LOG_ERROR,
151  "Size value %dx%d not supported, only accepts a size of %dx%d\n",
152  avctx->width, avctx->height, XFACE_WIDTH, XFACE_HEIGHT);
153  return AVERROR(EINVAL);
154  }
155  }
156  avctx->width = XFACE_WIDTH;
157  avctx->height = XFACE_HEIGHT;
158 
159  /* convert image from MONOWHITE to 1=black 0=white bitmap */
160  buf = frame->data[0];
161  i = j = 0;
162  do {
163  for (k = 0; k < 8; k++)
164  xface->bitmap[i++] = (buf[j]>>(7-k))&1;
165  if (++j == XFACE_WIDTH/8) {
166  buf += frame->linesize[0];
167  j = 0;
168  }
169  } while (i < XFACE_PIXELS);
170 
171  /* create a copy of bitmap */
172  memcpy(bitmap_copy, xface->bitmap, XFACE_PIXELS);
173  ff_xface_generate_face(xface->bitmap, bitmap_copy);
174 
175  encode_block(xface->bitmap, 16, 16, 0, &pq);
176  encode_block(xface->bitmap + 16, 16, 16, 0, &pq);
177  encode_block(xface->bitmap + 32, 16, 16, 0, &pq);
178  encode_block(xface->bitmap + XFACE_WIDTH * 16, 16, 16, 0, &pq);
179  encode_block(xface->bitmap + XFACE_WIDTH * 16 + 16, 16, 16, 0, &pq);
180  encode_block(xface->bitmap + XFACE_WIDTH * 16 + 32, 16, 16, 0, &pq);
181  encode_block(xface->bitmap + XFACE_WIDTH * 32, 16, 16, 0, &pq);
182  encode_block(xface->bitmap + XFACE_WIDTH * 32 + 16, 16, 16, 0, &pq);
183  encode_block(xface->bitmap + XFACE_WIDTH * 32 + 32, 16, 16, 0, &pq);
184 
185  while (pq.prob_ranges_idx > 0)
187 
188  /* write the inverted big integer in b to intbuf */
189  i = 0;
191  while (b.nb_words) {
192  uint8_t r;
193  ff_big_div(&b, XFACE_PRINTS, &r);
194  av_assert0(i < sizeof(intbuf));
195  intbuf[i++] = r + XFACE_FIRST_PRINT;
196  }
197 
198  if ((ret = ff_alloc_packet2(avctx, pkt, i+2, 0)) < 0)
199  return ret;
200 
201  /* revert the number, and close the buffer */
202  p = pkt->data;
203  while (--i >= 0)
204  *(p++) = intbuf[i];
205  *(p++) = '\n';
206  *(p++) = 0;
207 
208  pkt->flags |= AV_PKT_FLAG_KEY;
209  *got_packet = 1;
210 
211  return 0;
212 }
213 
215  .name = "xface",
216  .long_name = NULL_IF_CONFIG_SMALL("X-face image"),
217  .type = AVMEDIA_TYPE_VIDEO,
218  .id = AV_CODEC_ID_XFACE,
219  .priv_data_size = sizeof(XFaceContext),
220  .encode2 = xface_encode_frame,
222  .capabilities = AV_CODEC_CAP_INTRA_ONLY,
223 };
static int all_white(char *bitmap, int w, int h)
Definition: xfaceenc.c:71
uint8_t offset
Definition: xface.h:92
const char const char void * val
Definition: avisynth_c.h:863
static int all_same(char *bitmap, int w, int h)
Definition: xfaceenc.c:39
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int max_line_len
max line length for compressed data
Definition: xfaceenc.c:35
#define XFACE_WIDTH
Definition: xface.h:33
const ProbRange ff_xface_probranges_per_level[4][3]
Definition: xface.c:129
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3492
X-Face common definitions.
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1070
static void encode_block(char *bitmap, int w, int h, int level, ProbRangesQueue *pq)
Definition: xfaceenc.c:108
void ff_xface_generate_face(uint8_t *dst, uint8_t *const src)
Definition: xface.c:286
int prob_ranges_idx
Definition: xfaceenc.c:78
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:32
uint8_t
static int xface_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: xfaceenc.c:136
AVCodec ff_xface_encoder
Definition: xfaceenc.c:214
Definition: xface.h:61
uint8_t * data
Definition: avcodec.h:1480
void ff_big_mul(BigInt *b, uint8_t a)
Multiply a by b storing the result in b.
Definition: xface.c:93
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
static int all_black(char *bitmap, int w, int h)
Definition: xfaceenc.c:56
uint8_t range
Definition: xface.h:91
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void push_greys(ProbRangesQueue *pq, char *bitmap, int w, int h)
Definition: xfaceenc.c:89
#define XFACE_MAX_WORDS
Definition: xface.h:57
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
void ff_big_add(BigInt *b, uint8_t a)
Add a to b storing the result in b.
Definition: xface.c:31
simple assert() macros that are a bit more flexible than ISO C assert().
const ProbRange ff_xface_probranges_2x2[16]
Definition: xface.c:137
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
static void push_integer(BigInt *b, const ProbRange *prange)
Definition: xfaceenc.c:127
#define b
Definition: input.c:41
int width
picture width / height.
Definition: avcodec.h:1741
uint8_t w
Definition: llviddspenc.c:38
#define XFACE_HEIGHT
Definition: xface.h:34
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
void ff_big_div(BigInt *b, uint8_t a, uint8_t *r)
Divide b by a storing the result in b and the remainder in the word pointed to by r...
Definition: xface.c:54
uint8_t bitmap[XFACE_PIXELS]
image used internally for decoding
Definition: xfacedec.c:90
#define XFACE_FIRST_PRINT
Definition: xface.h:40
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1568
void * buf
Definition: avisynth_c.h:766
#define XFACE_PIXELS
Definition: xface.h:35
Describe the class of an AVClass context structure.
Definition: log.h:67
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
ProbRange prob_ranges[XFACE_PIXELS *2]
Definition: xfaceenc.c:77
#define XFACE_PRINTS
Definition: xface.h:42
common internal api header.
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:75
static int pq_push(ProbRangesQueue *pq, const ProbRange *p)
Definition: xfaceenc.c:81
#define XFACE_MAX_DIGITS
Definition: xface.h:50
void * priv_data
Definition: avcodec.h:1595
int nb_words
Definition: xface.h:62
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
int set_header
set X-Face header in the output
Definition: xfaceenc.c:36
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457