FFmpeg: libavcodec/xsubenc.c Source File

FFmpeg

[フレーム]

libavcodec

xsubenc.c

Go to the documentation of this file.

1 /*

2 * DivX (XSUB) subtitle encoder

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include "avcodec.h"

24 #include "bytestream.h"

25 #include "internal.h"

26 #include "put_bits.h"

28 /**

29 * Number of pixels to pad left and right.

30 *

31 * The official encoder pads the subtitles with two pixels on either side,

32 * but until we find out why, we won't do it (we will pad to have width

33 * divisible by 2 though).

34 */

35 #define PADDING 0

36 #define PADDING_COLOR 0

38 /**

39 * Encode a single color run. At most 16 bits will be used.

40 * @param len length of the run, values > 255 mean "until end of line", may not be < 0.

41 * @param color color to encode, only the lowest two bits are used and all others must be 0.

42 */

43 static void put_xsub_rle(PutBitContext *pb, int len, int color)

44 {

45 if (len <= 255)

46 put_bits(pb, 2 + ((ff_log2_tab[len] >> 1) << 2), len);

47 else

48 put_bits(pb, 14, 0);

49 put_bits(pb, 2, color);

50 }

52 /**

53 * Encode a 4-color bitmap with XSUB rle.

54 *

55 * The encoded bitmap may be wider than the source bitmap due to padding.

56 */

57 static int xsub_encode_rle(PutBitContext *pb, const uint8_t *bitmap,

58 int linesize, int w, int h)

59 {

60 int x0, x1, y, len, color = PADDING_COLOR;

62 for (y = 0; y < h; y++) {

63 x0 = 0;

64 while (x0 < w) {

65 // Make sure we have enough room for at least one run and padding

66 if (put_bytes_left(pb, 1) < 7)

67 return AVERROR_BUFFER_TOO_SMALL;

69 x1 = x0;

70 color = bitmap[x1++] & 3;

71 while (x1 < w && (bitmap[x1] & 3) == color)

72 x1++;

73 len = x1 - x0;

74 if (PADDING && x0 == 0) {

75 if (color == PADDING_COLOR) {

76 len += PADDING;

77 x0 -= PADDING;

78 } else

79 put_xsub_rle(pb, PADDING, PADDING_COLOR);

80 }

82 // Run can't be longer than 255, unless it is the rest of a row

83 if (x1 == w && color == PADDING_COLOR) {

84 len += PADDING + (w&1);

85 } else

86 len = FFMIN(len, 255);

87 put_xsub_rle(pb, len, color);

89 x0 += len;

90 }

91 if (color != PADDING_COLOR && (PADDING + (w&1)))

92 put_xsub_rle(pb, PADDING + (w&1), PADDING_COLOR);

94 align_put_bits(pb);

96 bitmap += linesize;

97 }

99 return 0;

100 }

101

102 static int make_tc(uint64_t ms, int *tc)

103 {

104 static const int tc_divs[3] = { 1000, 60, 60 };

105 int i;

106 for (i=0; i<3; i++) {

107 tc[i] = ms % tc_divs[i];

108 ms /= tc_divs[i];

109 }

110 tc[3] = ms;

111 return ms > 99;

112 }

113

114 static int xsub_encode(AVCodecContext *avctx, unsigned char *buf,

115 int bufsize, const AVSubtitle *h)

116 {

117 uint64_t startTime = h->pts / 1000; // FIXME: need better solution...

118 uint64_t endTime = startTime + h->end_display_time - h->start_display_time;

119 int start_tc[4], end_tc[4];

120 uint8_t *hdr = buf + 27; // Point behind the timestamp

121 uint8_t *rlelenptr;

122 uint16_t width, height;

123 int i;

124 PutBitContext pb;

125

126 if (bufsize < 27 + 7*2 + 4*3) {

127 av_log(avctx, AV_LOG_ERROR, "Buffer too small for XSUB header.\n");

128 return AVERROR_BUFFER_TOO_SMALL;

129 }

130

131 // TODO: support multiple rects

132 if (h->num_rects != 1)

133 av_log(avctx, AV_LOG_WARNING, "Only single rects supported (%d in subtitle.)\n", h->num_rects);

134

135 // TODO: render text-based subtitles into bitmaps

136 if (!h->rects[0]->data[0] || !h->rects[0]->data[1]) {

137 av_log(avctx, AV_LOG_WARNING, "No subtitle bitmap available.\n");

138 return AVERROR(EINVAL);

139 }

140

141 // TODO: color reduction, similar to dvdsub encoder

142 if (h->rects[0]->nb_colors > 4)

143 av_log(avctx, AV_LOG_WARNING, "No more than 4 subtitle colors supported (%d found.)\n", h->rects[0]->nb_colors);

144

145 // TODO: Palette swapping if color zero is not transparent

146 if (((uint32_t *)h->rects[0]->data[1])[0] & 0xff000000)

147 av_log(avctx, AV_LOG_WARNING, "Color index 0 is not transparent. Transparency will be messed up.\n");

148

149 if (make_tc(startTime, start_tc) || make_tc(endTime, end_tc)) {

150 av_log(avctx, AV_LOG_WARNING, "Time code >= 100 hours.\n");

151 return AVERROR(EINVAL);

152 }

153

154 snprintf(buf, 28,

155 "[%02d:%02d:%02d.%03d-%02d:%02d:%02d.%03d]",

156 start_tc[3], start_tc[2], start_tc[1], start_tc[0],

157 end_tc[3], end_tc[2], end_tc[1], end_tc[0]);

158

159 // Width and height must probably be multiples of 2.

160 // 2 pixels required on either side of subtitle.

161 // Possibly due to limitations of hardware renderers.

162 // TODO: check if the bitmap is already padded

163 width = FFALIGN(h->rects[0]->w, 2) + PADDING * 2;

164 height = FFALIGN(h->rects[0]->h, 2);

165

166 bytestream_put_le16(&hdr, width);

167 bytestream_put_le16(&hdr, height);

168 bytestream_put_le16(&hdr, h->rects[0]->x);

169 bytestream_put_le16(&hdr, h->rects[0]->y);

170 bytestream_put_le16(&hdr, h->rects[0]->x + width -1);

171 bytestream_put_le16(&hdr, h->rects[0]->y + height -1);

172

173 rlelenptr = hdr; // Will store length of first field here later.

174 hdr+=2;

175

176 // Palette

177 for (i=0; i<4; i++)

178 bytestream_put_be24(&hdr, ((uint32_t *)h->rects[0]->data[1])[i]);

179

180 // Bitmap

181 // RLE buffer. Reserve 2 bytes for possible padding after the last row.

182 init_put_bits(&pb, hdr, bufsize - (hdr - buf) - 2);

183 if (xsub_encode_rle(&pb, h->rects[0]->data[0],

184 h->rects[0]->linesize[0] * 2,

185 h->rects[0]->w, (h->rects[0]->h + 1) >> 1))

186 return AVERROR_BUFFER_TOO_SMALL;

187 bytestream_put_le16(&rlelenptr, put_bytes_count(&pb, 0)); // Length of first field

188

189 if (xsub_encode_rle(&pb, h->rects[0]->data[0] + h->rects[0]->linesize[0],

190 h->rects[0]->linesize[0] * 2,

191 h->rects[0]->w, h->rects[0]->h >> 1))

192 return AVERROR_BUFFER_TOO_SMALL;

193

194 // Enforce total height to be a multiple of 2

195 if (h->rects[0]->h & 1) {

196 put_xsub_rle(&pb, h->rects[0]->w, PADDING_COLOR);

197 }

198

199 flush_put_bits(&pb);

200

201 return hdr - buf + put_bytes_output(&pb);

202 }

203

204 static av_cold int xsub_encoder_init(AVCodecContext *avctx)

205 {

206 if (!avctx->codec_tag)

207 avctx->codec_tag = MKTAG('D','X','S','B');

208

209 avctx->bits_per_coded_sample = 4;

210

211 return 0;

212 }

213

214 const AVCodec ff_xsub_encoder = {

215 .name = "xsub",

216 .long_name = NULL_IF_CONFIG_SMALL("DivX subtitles (XSUB)"),

217 .type = AVMEDIA_TYPE_SUBTITLE,

218 .id = AV_CODEC_ID_XSUB,

219 .init = xsub_encoder_init,

220 .encode_sub = xsub_encode,

221 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

222 };

AVSubtitle

Definition: avcodec.h:2289

AVCodec

AVCodec.

Definition: codec.h:202

AVMEDIA_TYPE_SUBTITLE

@ AVMEDIA_TYPE_SUBTITLE

Definition: avutil.h:204

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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

ff_xsub_encoder

const AVCodec ff_xsub_encoder

Definition: xsubenc.c:214

AVERROR

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

align_put_bits

static void align_put_bits(PutBitContext *s)

Pad the bitstream with zeros up to the next byte boundary.

Definition: put_bits.h:412

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:88

color

Definition: vf_paletteuse.c:599

PADDING

#define PADDING

Number of pixels to pad left and right.