FFmpeg: libavcodec/pcxenc.c Source File

FFmpeg

[フレーム]

libavcodec

pcxenc.c

Go to the documentation of this file.

1 /*

2 * PC Paintbrush PCX (.pcx) image encoder

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 */

22 /**

23 * @file

24 * PCX image encoder

25 * @author Daniel Verkamp

26 * @see http://www.qzx.com/pc-gpe/pcx.txt

27 */

29 #include "avcodec.h"

30 #include "bytestream.h"

31 #include "libavutil/imgutils.h"

32 #include "internal.h"

34 typedef struct PCXContext {

35 AVFrame picture;

36 } PCXContext;

38 static const uint32_t monoblack_pal[16] = { 0x000000, 0xFFFFFF };

40 static av_cold int pcx_encode_init(AVCodecContext *avctx)

41 {

42 PCXContext *s = avctx->priv_data;

44 avcodec_get_frame_defaults(&s->picture);

45 avctx->coded_frame = &s->picture;

47 return 0;

48 }

50 /**

51 * PCX run-length encoder

52 * @param dst output buffer

53 * @param dst_size size of output buffer

54 * @param src input buffer

55 * @param src_plane_size size of one plane of input buffer in bytes

56 * @param nplanes number of planes in input buffer

57 * @return number of bytes written to dst or -1 on error

58 * @bug will not work for nplanes != 1 && bpp != 8

59 */

60 static int pcx_rle_encode( uint8_t *dst, int dst_size,

61 const uint8_t *src, int src_plane_size, int nplanes)

62 {

63 int p;

64 const uint8_t *dst_start = dst;

66 // check worst-case upper bound on dst_size

67 if (dst_size < 2LL * src_plane_size * nplanes || src_plane_size <= 0)

68 return -1;

70 for (p = 0; p < nplanes; p++) {

71 int count = 1;

72 const uint8_t *src_plane = src + p;

73 const uint8_t *src_plane_end = src_plane + src_plane_size * nplanes;

74 uint8_t prev = *src_plane;

75 src_plane += nplanes;

77 for (; ; src_plane += nplanes) {

78 if (src_plane < src_plane_end && *src_plane == prev && count < 0x3F) {

79 // current byte is same as prev

80 ++count;

81 } else {

82 // output prev * count

83 if (count != 1 || prev >= 0xC0)

84 *dst++ = 0xC0 | count;

85 *dst++ = prev;

87 if (src_plane == src_plane_end)

88 break;

90 // start new run

91 count = 1;

92 prev = *src_plane;

93 }

94 }

95 }

97 return dst - dst_start;

98 }

100 static int pcx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

101 const AVFrame *frame, int *got_packet)

102 {

103 PCXContext *s = avctx->priv_data;

104 AVFrame *const pict = &s->picture;

105 const uint8_t *buf_end;

106 uint8_t *buf;

107

108 int bpp, nplanes, i, y, line_bytes, written, ret, max_pkt_size, sw, sh;

109 const uint32_t *pal = NULL;

110 uint32_t palette256[256];

111 const uint8_t *src;

112

113 *pict = *frame;

114 pict->pict_type = AV_PICTURE_TYPE_I;

115 pict->key_frame = 1;

116

117 if (avctx->width > 65535 || avctx->height > 65535) {

118 av_log(avctx, AV_LOG_ERROR, "image dimensions do not fit in 16 bits\n");

119 return -1;

120 }

121

122 switch (avctx->pix_fmt) {

123 case AV_PIX_FMT_RGB24:

124 bpp = 8;

125 nplanes = 3;

126 break;

127 case AV_PIX_FMT_RGB8:

128 case AV_PIX_FMT_BGR8:

129 case AV_PIX_FMT_RGB4_BYTE:

130 case AV_PIX_FMT_BGR4_BYTE:

131 case AV_PIX_FMT_GRAY8:

132 bpp = 8;

133 nplanes = 1;

134 avpriv_set_systematic_pal2(palette256, avctx->pix_fmt);

135 pal = palette256;

136 break;

137 case AV_PIX_FMT_PAL8:

138 bpp = 8;

139 nplanes = 1;

140 pal = (uint32_t *)pict->data[1];

141 break;

142 case AV_PIX_FMT_MONOBLACK:

143 bpp = 1;

144 nplanes = 1;

145 pal = monoblack_pal;

146 break;

147 default:

148 av_log(avctx, AV_LOG_ERROR, "unsupported pixfmt\n");

149 return -1;

150 }

151

152 line_bytes = (avctx->width * bpp + 7) >> 3;

153 line_bytes = (line_bytes + 1) & ~1;

154

155 max_pkt_size = 128 + avctx->height * 2 * line_bytes * nplanes + (pal ? 256*3 + 1 : 0);

156 if ((ret = ff_alloc_packet2(avctx, pkt, max_pkt_size)) < 0)

157 return ret;

158 buf = pkt->data;

159 buf_end = pkt->data + pkt->size;

160

161 sw = avctx->sample_aspect_ratio.num;

162 sh = avctx->sample_aspect_ratio.den;

163 if (sw > 0xFFFFu || sh > 0xFFFFu)

164 av_reduce(&sw, &sh, sw, sh, 0xFFFFu);

165

166 bytestream_put_byte(&buf, 10); // manufacturer

167 bytestream_put_byte(&buf, 5); // version

168 bytestream_put_byte(&buf, 1); // encoding

169 bytestream_put_byte(&buf, bpp); // bits per pixel per plane

170 bytestream_put_le16(&buf, 0); // x min

171 bytestream_put_le16(&buf, 0); // y min

172 bytestream_put_le16(&buf, avctx->width - 1); // x max

173 bytestream_put_le16(&buf, avctx->height - 1); // y max

174 bytestream_put_le16(&buf, sw); // horizontal DPI

175 bytestream_put_le16(&buf, sh); // vertical DPI

176 for (i = 0; i < 16; i++)

177 bytestream_put_be24(&buf, pal ? pal[i] : 0);// palette (<= 16 color only)

178 bytestream_put_byte(&buf, 0); // reserved

179 bytestream_put_byte(&buf, nplanes); // number of planes

180 bytestream_put_le16(&buf, line_bytes); // scanline plane size in bytes

181

182 while (buf - pkt->data < 128)

183 *buf++= 0;

184

185 src = pict->data[0];

186

187 for (y = 0; y < avctx->height; y++) {

188 if ((written = pcx_rle_encode(buf, buf_end - buf,

189 src, line_bytes, nplanes)) < 0) {

190 av_log(avctx, AV_LOG_ERROR, "buffer too small\n");

191 return -1;

192 }

193 buf += written;

194 src += pict->linesize[0];

195 }

196

197 if (nplanes == 1 && bpp == 8) {

198 if (buf_end - buf < 257) {

199 av_log(avctx, AV_LOG_ERROR, "buffer too small\n");

200 return -1;

201 }

202 bytestream_put_byte(&buf, 12);

203 for (i = 0; i < 256; i++) {

204 bytestream_put_be24(&buf, pal[i]);

205 }

206 }

207

208 pkt->size = buf - pkt->data;

209 pkt->flags |= AV_PKT_FLAG_KEY;

210 *got_packet = 1;

211

212 return 0;

213 }

214

215 AVCodec ff_pcx_encoder = {

216 .name = "pcx",

217 .type = AVMEDIA_TYPE_VIDEO,

218 .id = AV_CODEC_ID_PCX,

219 .priv_data_size = sizeof(PCXContext),

220 .init = pcx_encode_init,

221 .encode2 = pcx_encode_frame,

222 .pix_fmts = (const enum AVPixelFormat[]){

223 AV_PIX_FMT_RGB24,

224 AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE,

225 AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,

226 AV_PIX_FMT_MONOBLACK,

227 AV_PIX_FMT_NONE

228 },

229 .long_name = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),

230 };

Generated on Wed Jul 10 2013 23:48:03 for FFmpeg by doxygen 1.8.2