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  if(avctx->width > 0xffff || avctx->height > 0xffff) {
93  av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n");
94  return AVERROR(EINVAL);
95  }
96  picsize = av_image_get_buffer_size(avctx->pix_fmt,
97  avctx->width, avctx->height, 1);
98  if ((ret = ff_alloc_packet2(avctx, pkt, picsize + 45, 0)) < 0)
99  return ret;
100 
101  /* zero out the header and only set applicable fields */
102  memset(pkt->data, 0, 12);
103  AV_WL16(pkt->data+12, avctx->width);
104  AV_WL16(pkt->data+14, avctx->height);
105  /* image descriptor byte: origin is always top-left, bits 0-3 specify alpha */
106  pkt->data[17] = 0x20 | (avctx->pix_fmt == AV_PIX_FMT_BGRA ? 8 : 0);
107 
108  out = pkt->data + 18; /* skip past the header we write */
109 
111  switch(avctx->pix_fmt) {
112  case AV_PIX_FMT_PAL8: {
113  int pal_bpp = 24; /* Only write 32bit palette if there is transparency information */
114  for (i = 0; i < 256; i++)
115  if (AV_RN32(p->data[1] + 4 * i) >> 24 != 0xFF) {
116  pal_bpp = 32;
117  break;
118  }
119  pkt->data[1] = 1; /* palette present */
120  pkt->data[2] = TGA_PAL; /* uncompressed palettised image */
121  pkt->data[6] = 1; /* palette contains 256 entries */
122  pkt->data[7] = pal_bpp; /* palette contains pal_bpp bit entries */
123  pkt->data[16] = 8; /* bpp */
124  for (i = 0; i < 256; i++)
125  if (pal_bpp == 32) {
126  AV_WL32(pkt->data + 18 + 4 * i, *(uint32_t *)(p->data[1] + i * 4));
127  } else {
128  AV_WL24(pkt->data + 18 + 3 * i, *(uint32_t *)(p->data[1] + i * 4));
129  }
130  out += 32 * pal_bpp; /* skip past the palette we just output */
131  break;
132  }
133  case AV_PIX_FMT_GRAY8:
134  pkt->data[2] = TGA_BW; /* uncompressed grayscale image */
135  avctx->bits_per_coded_sample = 0x28;
136  pkt->data[16] = 8; /* bpp */
137  break;
138  case AV_PIX_FMT_RGB555LE:
139  pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
140  avctx->bits_per_coded_sample =
141  pkt->data[16] = 16; /* bpp */
142  break;
143  case AV_PIX_FMT_BGR24:
144  pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
145  pkt->data[16] = 24; /* bpp */
146  break;
147  case AV_PIX_FMT_BGRA:
148  pkt->data[2] = TGA_RGB; /* uncompressed true-color image */
149  pkt->data[16] = 32; /* bpp */
150  break;
151  default:
152  av_log(avctx, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",
153  av_get_pix_fmt_name(avctx->pix_fmt));
154  return AVERROR(EINVAL);
155  }
156  bpp = pkt->data[16] >> 3;
157 
158 
159 #if FF_API_CODER_TYPE
161  if (avctx->coder_type == FF_CODER_TYPE_RAW)
162  s->rle = 0;
164 #endif
165 
166  /* try RLE compression */
167  if (s->rle)
168  datasize = targa_encode_rle(out, picsize, p, bpp, avctx->width, avctx->height);
169 
170  /* if that worked well, mark the picture as RLE compressed */
171  if(datasize >= 0)
172  pkt->data[2] |= TGA_RLE;
173 
174  /* if RLE didn't make it smaller, go back to no compression */
175  else datasize = targa_encode_normal(out, p, bpp, avctx->width, avctx->height);
176 
177  out += datasize;
178 
179  /* The standard recommends including this section, even if we don't use
180  * any of the features it affords. TODO: take advantage of the pixel
181  * aspect ratio and encoder ID fields available? */
182  memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);
183 
184  pkt->size = out + 26 - pkt->data;
185  pkt->flags |= AV_PKT_FLAG_KEY;
186  *got_packet = 1;
187 
188  return 0;
189 }
190 
192 {
193 #if FF_API_CODED_FRAME
195  avctx->coded_frame->key_frame = 1;
198 #endif
199 
200  return 0;
201 }
202 
203 #define OFFSET(x) offsetof(TargaContext, x)
204 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
205 static const AVOption options[] = {
206  { "rle", "Use run-length compression", OFFSET(rle), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
207 
208  { NULL },
209 };
210 
211 static const AVClass targa_class = {
212  .class_name = "targa",
213  .item_name = av_default_item_name,
214  .option = options,
215  .version = LIBAVUTIL_VERSION_INT,
216 };
217 
219  .name = "targa",
220  .long_name = NULL_IF_CONFIG_SMALL("Truevision Targa image"),
221  .type = AVMEDIA_TYPE_VIDEO,
222  .id = AV_CODEC_ID_TARGA,
223  .priv_data_size = sizeof(TargaContext),
224  .priv_class = &targa_class,
226  .encode2 = targa_encode_frame,
227  .pix_fmts = (const enum AVPixelFormat[]){
230  },
231 };
static const AVOption options[]
Definition: targaenc.c:205
#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:2263
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVOption.
Definition: opt.h:245
Definition: targa.h:37
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
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:2215
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:1591
#define VE
Definition: targaenc.c:204
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1887
int out_size
Definition: movenc.c:55
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3573
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
#define AV_WL24(p, d)
Definition: intreadwrite.h:464
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:1590
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:3053
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1622
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:361
#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:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:96
const char * name
Name of the codec implementation.
Definition: avcodec.h:3580
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1596
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:258
int width
picture width / height.
Definition: avcodec.h:1846
static const AVClass targa_class
Definition: targaenc.c:211
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:2712
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
main external API structure.
Definition: avcodec.h:1659
Describe the class of an AVClass context structure.
Definition: log.h:67
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1689
#define AV_RN32(p)
Definition: intreadwrite.h:364
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
AVCodec ff_targa_encoder
Definition: targaenc.c:218
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:80
common internal api header.
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
#define FF_CODER_TYPE_RAW
Definition: avcodec.h:2703
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:3081
void * priv_data
Definition: avcodec.h:1701
static av_cold int targa_encode_init(AVCodecContext *avctx)
Definition: targaenc.c:191
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
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:49
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:2179
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1567
#define AV_WL32(p, v)
Definition: intreadwrite.h:426