FFmpeg
sgidec.c
Go to the documentation of this file.
1 /*
2  * SGI image decoder
3  * Todd Kirby <doubleshot@pacbell.net>
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 #include "libavutil/imgutils.h"
23 #include "avcodec.h"
24 #include "bytestream.h"
25 #include "internal.h"
26 #include "sgi.h"
27 
28 typedef struct SgiState {
30  unsigned int width;
31  unsigned int height;
32  unsigned int depth;
33  unsigned int bytes_per_channel;
34  int linesize;
36 } SgiState;
37 
38 /**
39  * Expand an RLE row into a channel.
40  * @param s the current image state
41  * @param out_buf Points to one line after the output buffer.
42  * @param len length of out_buf in bytes
43  * @param pixelstride pixel stride of input buffer
44  * @return size of output in bytes, else return error code.
45  */
46 static int expand_rle_row8(SgiState *s, uint8_t *out_buf,
47  int len, int pixelstride)
48 {
49  unsigned char pixel, count;
50  unsigned char *orig = out_buf;
51  uint8_t *out_end = out_buf + len;
52 
53  while (out_buf < out_end) {
54  if (bytestream2_get_bytes_left(&s->g) < 1)
55  return AVERROR_INVALIDDATA;
56  pixel = bytestream2_get_byteu(&s->g);
57  if (!(count = (pixel & 0x7f))) {
58  break;
59  }
60 
61  /* Check for buffer overflow. */
62  if (out_end - out_buf <= pixelstride * (count - 1)) {
63  av_log(s->avctx, AV_LOG_ERROR, "Invalid pixel count.\n");
64  return AVERROR_INVALIDDATA;
65  }
66 
67  if (pixel & 0x80) {
68  while (count--) {
69  *out_buf = bytestream2_get_byte(&s->g);
70  out_buf += pixelstride;
71  }
72  } else {
73  pixel = bytestream2_get_byte(&s->g);
74 
75  while (count--) {
76  *out_buf = pixel;
77  out_buf += pixelstride;
78  }
79  }
80  }
81  return (out_buf - orig) / pixelstride;
82 }
83 
84 static int expand_rle_row16(SgiState *s, uint16_t *out_buf,
85  int len, int pixelstride)
86 {
87  unsigned short pixel;
88  unsigned char count;
89  unsigned short *orig = out_buf;
90  uint16_t *out_end = out_buf + len;
91 
92  while (out_buf < out_end) {
93  if (bytestream2_get_bytes_left(&s->g) < 2)
94  return AVERROR_INVALIDDATA;
95  pixel = bytestream2_get_be16u(&s->g);
96  if (!(count = (pixel & 0x7f)))
97  break;
98 
99  /* Check for buffer overflow. */
100  if (out_end - out_buf <= pixelstride * (count - 1)) {
101  av_log(s->avctx, AV_LOG_ERROR, "Invalid pixel count.\n");
102  return AVERROR_INVALIDDATA;
103  }
104 
105  if (pixel & 0x80) {
106  while (count--) {
108  AV_WN16A(out_buf, pixel);
109  out_buf += pixelstride;
110  }
111  } else {
113 
114  while (count--) {
115  AV_WN16A(out_buf, pixel);
116  out_buf += pixelstride;
117  }
118  }
119  }
120  return (out_buf - orig) / pixelstride;
121 }
122 
123 
124 /**
125  * Read a run length encoded SGI image.
126  * @param out_buf output buffer
127  * @param s the current image state
128  * @return 0 if no error, else return error code.
129  */
130 static int read_rle_sgi(uint8_t *out_buf, SgiState *s)
131 {
132  uint8_t *dest_row;
133  unsigned int len = s->height * s->depth * 4;
134  GetByteContext g_table = s->g;
135  unsigned int y, z;
136  unsigned int start_offset;
137  int linesize, ret;
138 
139  /* size of RLE offset and length tables */
140  if (len * 2 > bytestream2_get_bytes_left(&s->g)) {
141  return AVERROR_INVALIDDATA;
142  }
143 
144  for (z = 0; z < s->depth; z++) {
145  dest_row = out_buf;
146  for (y = 0; y < s->height; y++) {
147  linesize = s->width * s->depth;
148  dest_row -= s->linesize;
149  start_offset = bytestream2_get_be32(&g_table);
150  bytestream2_seek(&s->g, start_offset, SEEK_SET);
151  if (s->bytes_per_channel == 1)
152  ret = expand_rle_row8(s, dest_row + z, linesize, s->depth);
153  else
154  ret = expand_rle_row16(s, (uint16_t *)dest_row + z, linesize, s->depth);
155  if (ret != s->width)
156  return AVERROR_INVALIDDATA;
157  }
158  }
159  return 0;
160 }
161 
162 /**
163  * Read an uncompressed SGI image.
164  * @param out_buf output buffer
165  * @param s the current image state
166  * @return 0 if read success, else return error code.
167  */
168 static int read_uncompressed_sgi(unsigned char *out_buf, SgiState *s)
169 {
170  int x, y, z;
171  unsigned int offset = s->height * s->width * s->bytes_per_channel;
172  GetByteContext gp[4];
173  uint8_t *out_end;
174 
175  /* Test buffer size. */
176  if (offset * s->depth > bytestream2_get_bytes_left(&s->g))
177  return AVERROR_INVALIDDATA;
178 
179  /* Create a reader for each plane */
180  for (z = 0; z < s->depth; z++) {
181  gp[z] = s->g;
182  bytestream2_skip(&gp[z], z * offset);
183  }
184 
185  for (y = s->height - 1; y >= 0; y--) {
186  out_end = out_buf + (y * s->linesize);
187  if (s->bytes_per_channel == 1) {
188  for (x = s->width; x > 0; x--)
189  for (z = 0; z < s->depth; z++)
190  *out_end++ = bytestream2_get_byteu(&gp[z]);
191  } else {
192  uint16_t *out16 = (uint16_t *)out_end;
193  for (x = s->width; x > 0; x--)
194  for (z = 0; z < s->depth; z++)
195  *out16++ = bytestream2_get_ne16u(&gp[z]);
196  }
197  }
198  return 0;
199 }
200 
201 static int decode_frame(AVCodecContext *avctx,
202  void *data, int *got_frame,
203  AVPacket *avpkt)
204 {
205  SgiState *s = avctx->priv_data;
206  AVFrame *p = data;
207  unsigned int dimension, rle;
208  int ret = 0;
209  uint8_t *out_buf, *out_end;
210 
211  bytestream2_init(&s->g, avpkt->data, avpkt->size);
213  av_log(avctx, AV_LOG_ERROR, "buf_size too small (%d)\n", avpkt->size);
214  return AVERROR_INVALIDDATA;
215  }
216 
217  /* Test for SGI magic. */
218  if (bytestream2_get_be16u(&s->g) != SGI_MAGIC) {
219  av_log(avctx, AV_LOG_ERROR, "bad magic number\n");
220  return AVERROR_INVALIDDATA;
221  }
222 
223  rle = bytestream2_get_byteu(&s->g);
224  s->bytes_per_channel = bytestream2_get_byteu(&s->g);
225  dimension = bytestream2_get_be16u(&s->g);
226  s->width = bytestream2_get_be16u(&s->g);
227  s->height = bytestream2_get_be16u(&s->g);
228  s->depth = bytestream2_get_be16u(&s->g);
229 
230  if (s->bytes_per_channel != 1 && s->bytes_per_channel != 2) {
231  av_log(avctx, AV_LOG_ERROR, "wrong channel number\n");
232  return AVERROR_INVALIDDATA;
233  }
234 
235  /* Check for supported image dimensions. */
236  if (dimension != 2 && dimension != 3) {
237  av_log(avctx, AV_LOG_ERROR, "wrong dimension number\n");
238  return AVERROR_INVALIDDATA;
239  }
240 
241  if (s->depth == SGI_GRAYSCALE) {
242  avctx->pix_fmt = s->bytes_per_channel == 2 ? AV_PIX_FMT_GRAY16BE : AV_PIX_FMT_GRAY8;
243  } else if (s->depth == SGI_RGB) {
244  avctx->pix_fmt = s->bytes_per_channel == 2 ? AV_PIX_FMT_RGB48BE : AV_PIX_FMT_RGB24;
245  } else if (s->depth == SGI_RGBA) {
246  avctx->pix_fmt = s->bytes_per_channel == 2 ? AV_PIX_FMT_RGBA64BE : AV_PIX_FMT_RGBA;
247  } else {
248  av_log(avctx, AV_LOG_ERROR, "wrong picture format\n");
249  return AVERROR_INVALIDDATA;
250  }
251 
252  ret = ff_set_dimensions(avctx, s->width, s->height);
253  if (ret < 0)
254  return ret;
255 
256  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
257  return ret;
258 
260  p->key_frame = 1;
261  out_buf = p->data[0];
262 
263  out_end = out_buf + p->linesize[0] * s->height;
264 
265  s->linesize = p->linesize[0];
266 
267  /* Skip header. */
268  bytestream2_seek(&s->g, SGI_HEADER_SIZE, SEEK_SET);
269  if (rle) {
270  ret = read_rle_sgi(out_end, s);
271  } else {
272  ret = read_uncompressed_sgi(out_buf, s);
273  }
274  if (ret)
275  return ret;
276 
277  *got_frame = 1;
278  return avpkt->size;
279 }
280 
282 {
283  SgiState *s = avctx->priv_data;
284 
285  s->avctx = avctx;
286 
287  return 0;
288 }
289 
291  .name = "sgi",
292  .long_name = NULL_IF_CONFIG_SMALL("SGI image"),
293  .type = AVMEDIA_TYPE_VIDEO,
294  .id = AV_CODEC_ID_SGI,
295  .priv_data_size = sizeof(SgiState),
296  .decode = decode_frame,
298  .capabilities = AV_CODEC_CAP_DR1,
299  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
300 };
AVCodec
AVCodec.
Definition: codec.h:197
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:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
SgiState::bytes_per_channel
unsigned int bytes_per_channel
Definition: sgidec.c:33
GetByteContext
Definition: bytestream.h:33
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:195
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: sgidec.c:201
expand_rle_row16
static int expand_rle_row16(SgiState *s, uint16_t *out_buf, int len, int pixelstride)
Definition: sgidec.c:84
rle
static int rle(uint8_t *dst, const uint8_t *src, int compressed_size, int uncompressed_size)
Definition: exr.c:215
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
SgiState
Definition: sgidec.c:28
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
SgiState::g
GetByteContext g
Definition: sgidec.c:35
av_cold
#define av_cold
Definition: attributes.h:90
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
SGI_MAGIC
#define SGI_MAGIC
SGI image file signature.
Definition: sgi.h:28
SgiState::linesize
int linesize
Definition: sgidec.c:34
AV_WN16A
#define AV_WN16A(p, v)
Definition: intreadwrite.h:534
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
SGI_RGBA
#define SGI_RGBA
Definition: sgi.h:34
pixel
uint8_t pixel
Definition: tiny_ssim.c:42
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ff_sgi_decoder
const AVCodec ff_sgi_decoder
Definition: sgidec.c:290
SgiState::height
unsigned int height
Definition: sgidec.c:31
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1648
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
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:116
gp
#define gp
Definition: regdef.h:62
bytestream2_get_ne16
#define bytestream2_get_ne16
Definition: bytestream.h:119
read_rle_sgi
static int read_rle_sgi(uint8_t *out_buf, SgiState *s)
Read a run length encoded SGI image.
Definition: sgidec.c:130
read_uncompressed_sgi
static int read_uncompressed_sgi(unsigned char *out_buf, SgiState *s)
Read an uncompressed SGI image.
Definition: sgidec.c:168
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
sgi.h
SGI_RGB
#define SGI_RGB
Definition: sgi.h:33
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
SgiState::width
unsigned int width
Definition: sgidec.c:30
SgiState::depth
unsigned int depth
Definition: sgidec.c:32
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
avcodec.h
ret
ret
Definition: filter_design.txt:187
expand_rle_row8
static int expand_rle_row8(SgiState *s, uint8_t *out_buf, int len, int pixelstride)
Expand an RLE row into a channel.
Definition: sgidec.c:46
AVCodecContext
main external API structure.
Definition: avcodec.h:379
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:86
SGI_HEADER_SIZE
#define SGI_HEADER_SIZE
Definition: sgi.h:30
SgiState::avctx
AVCodecContext * avctx
Definition: sgidec.c:29
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
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:61
AV_CODEC_ID_SGI
@ AV_CODEC_ID_SGI
Definition: codec_id.h:151
dimension
The official guide to swscale for confused that consecutive non overlapping rectangles of dimension(0, slice_top) -(picture_width
SGI_GRAYSCALE
#define SGI_GRAYSCALE
Definition: sgi.h:32
bytestream2_get_ne16u
#define bytestream2_get_ne16u
Definition: bytestream.h:123
sgi_decode_init
static av_cold int sgi_decode_init(AVCodecContext *avctx)
Definition: sgidec.c:281