FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
targaenc.c
Go to the documentation of this file.
1 /*
2  * Targa (.tga) image encoder
3  * Copyright (c) 2007 Bobby Bingham
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 <string.h>
23 
24 #include "libavutil/imgutils.h"
25 #include "libavutil/internal.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "avcodec.h"
30 #include "internal.h"
31 #include "rle.h"
32 #include "targa.h"
33 
34 typedef struct TargaContext {
35  AVClass *class;
36 
37  int rle;
38 } TargaContext;
39 
40 /**
41  * RLE compress the image, with maximum size of out_size
42  * @param outbuf Output buffer
43  * @param out_size Maximum output size
44  * @param pic Image to compress
45  * @param bpp Bytes per pixel
46  * @param w Image width
47  * @param h Image height
48  * @return Size of output in bytes, or -1 if larger than out_size
49  */
50 static int targa_encode_rle(uint8_t *outbuf, int out_size, const AVFrame *pic,
51  int bpp, int w, int h)
52 {
53  int y,ret;
54  uint8_t *out;
55 
56  out = outbuf;
57 
58  for(y = 0; y < h; y ++) {
59  ret = ff_rle_encode(out, out_size, pic->data[0] + pic->linesize[0] * y, bpp, w, 0x7f, 0, -1, 0);
60  if(ret == -1){
61  return -1;
62  }
63  out+= ret;
64  out_size -= ret;
65  }
66 
67  return out - outbuf;
68 }
69 
70 static int targa_encode_normal(uint8_t *outbuf, const AVFrame *pic, int bpp, int w, int h)
71 {
72  int i, n = bpp * w;
73  uint8_t *out = outbuf;
74  uint8_t *ptr = pic->data[0];
75 
76  for(i=0; i < h; i++) {
77  memcpy(out, ptr, n);
78  out += n;
79  ptr += pic->linesize[0];
80  }
81 
82  return out - outbuf;
83 }
84 
86  const AVFrame *p, int *got_packet)
87 {
88  TargaContext *s = avctx->priv_data;
89  int bpp, picsize, datasize = -1, ret, i;
90  uint8_t *out;
91 
92  picsize = av_image_get_buffer_size(avctx->pix_fmt,
93  avctx->width, avctx->height, 1);
94  if ((ret = ff_alloc_packet2(avctx, pkt, picsize + 45, 0)) < 0)
95  return ret;
96 
97  /* zero out the header and only set applicable fields */
98  memset(pkt->data, 0, 12);
99  AV_WL16(pkt->data+12, avctx->width);
100  AV_WL16(pkt->data+14, avctx->height);
101  /* image descriptor byte: origin is always top-left, bits 0-3 specify alpha */
102  pkt->data[17] = 0x20 | (avctx->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0);
103 
104  out = pkt->data + 18; /* skip past the header we write */
105 
107  switch(avctx->pix_fmt) {
108  case AV_PIX_FMT_PAL8: {
109  int pal_bpp = 24; /* Only write 32bit palette if there is transparency information */
110  for (i = 0; i < 256; i++)
111  if (AV_RN32(p->data[1] + 4 * i) >> 24 != 0xFF) {
112  pal_bpp = 32;
113  break;
114  }
115  pkt->data[1] = 1; /* palette present */
116  pkt->data[2] = TGA_PAL; /* uncompressed palettised image */
117  pkt->data[6] = 1; /* palette contains 256 entries */
118  pkt->data[7] = pal_bpp; /* palette contains pal_bpp bit entries */
119  pkt->data[16] = 8; /* bpp */
120  for (i = 0; i < 256; i++)
121  if (pal_bpp == 32) {
122  AV_WL32(pkt->data + 18 + 4 * i, *(uint32_t *)(p->data[1] + i * 4));
123  } else {
124  AV_WL24(pkt->data + 18 + 3 * i, *(uint32_t *)(p->data[1] + i * 4));
125  }
126  out += 32 * pal_bpp; /* skip past the palette we just output */
127  break;
128  }
129  case AV_PIX_FMT_GRAY8:
130  pkt->data[2] = TGA_BW; /* uncompressed grayscale image */
131  avctx->bits_per_coded_sample = 0x28;
132  pkt->data[16] = 8; /* bpp */
133  break;
134  case AV_PIX_FMT_RGB555LE:
135  pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
136  avctx->bits_per_coded_sample =
137  pkt->data[16] = 16; /* bpp */
138  break;
139  case AV_PIX_FMT_BGR24:
140  pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
141  pkt->data[16] = 24; /* bpp */
142  break;
143  case AV_PIX_FMT_BGRA:
144  pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
145  pkt->data[16] = 32; /* bpp */
146  break;
147  default:
148  av_log(avctx, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",
149  av_get_pix_fmt_name(avctx->pix_fmt));
150  return AVERROR(EINVAL);
151  }
152  bpp = pkt->data[16] >> 3;
153 
154 
155 #if FF_API_CODER_TYPE
157  if (avctx->coder_type == FF_CODER_TYPE_RAW)
158  s->rle = 0;
160 #endif
161 
162  /* try RLE compression */
163  if (s->rle)
164  datasize = targa_encode_rle(out, picsize, p, bpp, avctx->width, avctx->height);
165 
166  /* if that worked well, mark the picture as RLE compressed */
167  if(datasize >= 0)
168  pkt->data[2] |= TGA_RLE;
169 
170  /* if RLE didn't make it smaller, go back to no compression */
171  else datasize = targa_encode_normal(out, p, bpp, avctx->width, avctx->height);
172 
173  out += datasize;
174 
175  /* The standard recommends including this section, even if we don't use
176  * any of the features it affords. TODO: take advantage of the pixel
177  * aspect ratio and encoder ID fields available? */
178  memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);
179 
180  pkt->size = out + 26 - pkt->data;
181  pkt->flags |= AV_PKT_FLAG_KEY;
182  *got_packet = 1;
183 
184  return 0;
185 }
186 
188 {
189  if (avctx->width > 0xffff || avctx->height > 0xffff) {
190  av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n");
191  return AVERROR(EINVAL);
192  }
193 
194 #if FF_API_CODED_FRAME
196  avctx->coded_frame->key_frame = 1;
199 #endif
200 
201  return 0;
202 }
203 
204 #define OFFSET(x) offsetof(TargaContext, x)
205 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
206 static const AVOption options[] = {
207  { "rle", "Use run-length compression", OFFSET(rle), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
208 
209  { NULL },
210 };
211 
212 static const AVClass targa_class = {
213  .class_name = "targa",
214  .item_name = av_default_item_name,
215  .option = options,
216  .version = LIBAVUTIL_VERSION_INT,
217 };
218 
220  .name = "targa",
221  .long_name = NULL_IF_CONFIG_SMALL("Truevision Targa image"),
222  .type = AVMEDIA_TYPE_VIDEO,
223  .id = AV_CODEC_ID_TARGA,
224  .priv_data_size = sizeof(TargaContext),
225  .priv_class = &targa_class,
227  .encode2 = targa_encode_frame,
228  .pix_fmts = (const enum AVPixelFormat[]){
231  },
232 };
static const AVOption options[]
Definition: targaenc.c:206
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2419
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
AVOption.
Definition: opt.h:246
Definition: targa.h:37
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:86
Definition: targa.h:38
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2371
Definition: targa.h:35
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:116
int size
Definition: avcodec.h:1680
#define VE
Definition: targaenc.c:205
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1989
int out_size
Definition: movenc.c:55
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3739
Definition: targa.h:36
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
targa file common definitions
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
#define AV_WL24(p, d)
Definition: intreadwrite.h:469
uint8_t
#define av_cold
Definition: attributes.h:82
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
AVOptions.
static int targa_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
Definition: targaenc.c:85
uint8_t * data
Definition: avcodec.h:1679
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:3157
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1711
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters...
Definition: imgutils.c:429
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
#define OFFSET(x)
Definition: targaenc.c:204
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:96
const char * name
Name of the codec implementation.
Definition: avcodec.h:3746
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1685
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
int width
picture width / height.
Definition: avcodec.h:1948
static const AVClass targa_class
Definition: targaenc.c:212
int n
Definition: avisynth_c.h:684
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
attribute_deprecated int coder_type
Definition: avcodec.h:2815
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
main external API structure.
Definition: avcodec.h:1761
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_RN32(p)
Definition: intreadwrite.h:369
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
AVCodec ff_targa_encoder
Definition: targaenc.c:219
static int targa_encode_rle(uint8_t *outbuf, int out_size, const AVFrame *pic, int bpp, int w, int h)
RLE compress the image, with maximum size of out_size.
Definition: targaenc.c:50
static int targa_encode_normal(uint8_t *outbuf, const AVFrame *pic, int bpp, int w, int h)
Definition: targaenc.c:70
Y , 8bpp.
Definition: pixfmt.h:70
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
common internal api header.
#define AV_WL16(p, v)
Definition: intreadwrite.h:417
#define FF_CODER_TYPE_RAW
Definition: avcodec.h:2806
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:3183
void * priv_data
Definition: avcodec.h:1803
static av_cold int targa_encode_init(AVCodecContext *avctx)
Definition: targaenc.c:187
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
FILE * out
Definition: movenc.c:54
int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *ptr, int bpp, int w, int add_rep, int xor_rep, int add_raw, int xor_raw)
RLE compress the row, with maximum size of out_size.
Definition: rle.c:52
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2335
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1656
#define AV_WL32(p, v)
Definition: intreadwrite.h:431