FFmpeg: libavcodec/qtrleenc.c Source File

FFmpeg

[フレーム]

libavcodec

qtrleenc.c

Go to the documentation of this file.

1 /*

2 * Quicktime Animation (RLE) Video Encoder

5 *

6 * This file is based on flashsvenc.c.

7 *

8 * This file is part of FFmpeg.

9 *

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

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

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

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

14 *

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

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

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

18 * Lesser General Public License for more details.

19 *

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

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

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

23 */

25 #include "libavutil/imgutils.h"

26 #include "avcodec.h"

27 #include "bytestream.h"

28 #include "internal.h"

30 /** Maximum RLE code for bulk copy */

31 #define MAX_RLE_BULK 127

32 /** Maximum RLE code for repeat */

33 #define MAX_RLE_REPEAT 128

34 /** Maximum RLE code for skip */

35 #define MAX_RLE_SKIP 254

37 typedef struct QtrleEncContext {

38 AVCodecContext *avctx;

39 int pixel_size;

40 AVPicture previous_frame;

41 unsigned int max_buf_size;

42 int logical_width;

43 /**

44 * This array will contain at ith position the value of the best RLE code

45 * if the line started at pixel i

46 * There can be 3 values :

47 * skip (0) : skip as much as possible pixels because they are equal to the

48 * previous frame ones

49 * repeat (<-1) : repeat that pixel -rle_code times, still as much as

50 * possible

51 * copy (>0) : copy the raw next rle_code pixels */

52 signed char *rlecode_table;

53 /**

54 * This array will contain the length of the best rle encoding of the line

55 * starting at ith pixel */

56 int *length_table;

57 /**

58 * Will contain at ith position the number of consecutive pixels equal to the previous

59 * frame starting from pixel i */

60 uint8_t* skip_table;

61 } QtrleEncContext;

63 static av_cold int qtrle_encode_end(AVCodecContext *avctx)

64 {

65 QtrleEncContext *s = avctx->priv_data;

67 av_frame_free(&avctx->coded_frame);

69 avpicture_free(&s->previous_frame);

70 av_free(s->rlecode_table);

71 av_free(s->length_table);

72 av_free(s->skip_table);

73 return 0;

74 }

76 static av_cold int qtrle_encode_init(AVCodecContext *avctx)

77 {

78 QtrleEncContext *s = avctx->priv_data;

79 int ret;

81 if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {

82 return AVERROR(EINVAL);

83 }

84 s->avctx=avctx;

85 s->logical_width=avctx->width;

87 switch (avctx->pix_fmt) {

88 case AV_PIX_FMT_GRAY8:

89 s->logical_width = avctx->width / 4;

90 s->pixel_size = 4;

91 break;

92 case AV_PIX_FMT_RGB555BE:

93 s->pixel_size = 2;

94 break;

95 case AV_PIX_FMT_RGB24:

96 s->pixel_size = 3;

97 break;

98 case AV_PIX_FMT_ARGB:

99 s->pixel_size = 4;

100 break;

101 default:

102 av_log(avctx, AV_LOG_ERROR, "Unsupported colorspace.\n");

103 break;

104 }

105 avctx->bits_per_coded_sample = avctx->pix_fmt == AV_PIX_FMT_GRAY8 ? 40 : s->pixel_size*8;

106

107 s->rlecode_table = av_mallocz(s->logical_width);

108 s->skip_table = av_mallocz(s->logical_width);

109 s->length_table = av_mallocz((s->logical_width + 1)*sizeof(int));

110 if (!s->skip_table || !s->length_table || !s->rlecode_table) {

111 av_log(avctx, AV_LOG_ERROR, "Error allocating memory.\n");

112 return AVERROR(ENOMEM);

113 }

114 if ((ret = avpicture_alloc(&s->previous_frame, avctx->pix_fmt, avctx->width, avctx->height)) < 0) {

115 av_log(avctx, AV_LOG_ERROR, "Error allocating picture\n");

116 return ret;

117 }

118

119 s->max_buf_size = s->logical_width*s->avctx->height*s->pixel_size*2 /* image base material */

120 + 15 /* header + footer */

121 + s->avctx->height*2 /* skip code+rle end */

122 + s->logical_width/MAX_RLE_BULK + 1 /* rle codes */;

123

124 avctx->coded_frame = av_frame_alloc();

125 if (!avctx->coded_frame) {

126 qtrle_encode_end(avctx);

127 return AVERROR(ENOMEM);

128 }

129

130 return 0;

131 }

132

133 /**

134 * Compute the best RLE sequence for a line

135 */

136 static void qtrle_encode_line(QtrleEncContext *s, const AVFrame *p, int line, uint8_t **buf)

137 {

138 int width=s->logical_width;

139 int i;

140 signed char rlecode;

141

142 /* This will be the number of pixels equal to the preivous frame one's

143 * starting from the ith pixel */

144 unsigned int skipcount;

145 /* This will be the number of consecutive equal pixels in the current

146 * frame, starting from the ith one also */

147 unsigned int av_uninit(repeatcount);

148

149 /* The cost of the three different possibilities */

150 int total_skip_cost;

151 int total_repeat_cost;

152

153 int base_bulk_cost;

154 int lowest_bulk_cost;

155 int lowest_bulk_cost_index;

156 int sec_lowest_bulk_cost;

157 int sec_lowest_bulk_cost_index;

158

159 uint8_t *this_line = p-> data[0] + line*p-> linesize[0] +

160 (width - 1)*s->pixel_size;

161 uint8_t *prev_line = s->previous_frame.data[0] + line*s->previous_frame.linesize[0] +

162 (width - 1)*s->pixel_size;

163

164 s->length_table[width] = 0;

165 skipcount = 0;

166

167 /* Initial values */

168 lowest_bulk_cost = INT_MAX / 2;

169 lowest_bulk_cost_index = width;

170 sec_lowest_bulk_cost = INT_MAX / 2;

171 sec_lowest_bulk_cost_index = width;

172

173 base_bulk_cost = 1 + s->pixel_size;

174

175 for (i = width - 1; i >= 0; i--) {

176

177 int prev_bulk_cost;

178

179 /* If our lowest bulk cost index is too far away, replace it

180 * with the next lowest bulk cost */

181 if (FFMIN(width, i + MAX_RLE_BULK) < lowest_bulk_cost_index) {

182 lowest_bulk_cost = sec_lowest_bulk_cost;

183 lowest_bulk_cost_index = sec_lowest_bulk_cost_index;

184

185 sec_lowest_bulk_cost = INT_MAX / 2;

186 sec_lowest_bulk_cost_index = width;

187 }

188

189 /* Deal with the first pixel's bulk cost */

190 if (!i) {

191 base_bulk_cost++;

192 lowest_bulk_cost++;

193 sec_lowest_bulk_cost++;

194 }

195

196 /* Look at the bulk cost of the previous loop and see if it is

197 * a new lower bulk cost */

198 prev_bulk_cost = s->length_table[i + 1] + base_bulk_cost;

199 if (prev_bulk_cost <= sec_lowest_bulk_cost) {

200 /* If it's lower than the 2nd lowest, then it may be lower

201 * than the lowest */

202 if (prev_bulk_cost <= lowest_bulk_cost) {

203

204 /* If we have found a new lowest bulk cost,

205 * then the 2nd lowest bulk cost is now farther than the

206 * lowest bulk cost, and will never be used */

207 sec_lowest_bulk_cost = INT_MAX / 2;

208

209 lowest_bulk_cost = prev_bulk_cost;

210 lowest_bulk_cost_index = i + 1;

211 } else {

212 /* Then it must be the 2nd lowest bulk cost */

213 sec_lowest_bulk_cost = prev_bulk_cost;

214 sec_lowest_bulk_cost_index = i + 1;

215 }

216 }

217

218 if (!s->avctx->coded_frame->key_frame && !memcmp(this_line, prev_line, s->pixel_size))

219 skipcount = FFMIN(skipcount + 1, MAX_RLE_SKIP);

220 else

221 skipcount = 0;

222

223 total_skip_cost = s->length_table[i + skipcount] + 2;

224 s->skip_table[i] = skipcount;

225

226

227 if (i < width - 1 && !memcmp(this_line, this_line + s->pixel_size, s->pixel_size))

228 repeatcount = FFMIN(repeatcount + 1, MAX_RLE_REPEAT);

229 else

230 repeatcount = 1;

231

232 total_repeat_cost = s->length_table[i + repeatcount] + 1 + s->pixel_size;

233

234 /* skip code is free for the first pixel, it costs one byte for repeat and bulk copy

235 * so let's make it aware */

236 if (i == 0) {

237 total_skip_cost--;

238 total_repeat_cost++;

239 }

240

241 if (repeatcount > 1 && (skipcount == 0 || total_repeat_cost < total_skip_cost)) {

242 /* repeat is the best */

243 s->length_table[i] = total_repeat_cost;

244 s->rlecode_table[i] = -repeatcount;

245 }

246 else if (skipcount > 0) {

247 /* skip is the best choice here */

248 s->length_table[i] = total_skip_cost;

249 s->rlecode_table[i] = 0;

250 }

251 else {

252 /* We cannot do neither skip nor repeat

253 * thus we use the best bulk copy */

254

255 s->length_table[i] = lowest_bulk_cost;

256 s->rlecode_table[i] = lowest_bulk_cost_index - i;

257

258 }

259

260 /* These bulk costs increase every iteration */

261 lowest_bulk_cost += s->pixel_size;

262 sec_lowest_bulk_cost += s->pixel_size;

263

264 this_line -= s->pixel_size;

265 prev_line -= s->pixel_size;

266 }

267

268 /* Good ! Now we have the best sequence for this line, let's output it */

269

270 /* We do a special case for the first pixel so that we avoid testing it in

271 * the whole loop */

272

273 i=0;

274 this_line = p-> data[0] + line*p->linesize[0];

275

276 if (s->rlecode_table[0] == 0) {

277 bytestream_put_byte(buf, s->skip_table[0] + 1);

278 i += s->skip_table[0];

279 }

280 else bytestream_put_byte(buf, 1);

281

282

283 while (i < width) {

284 rlecode = s->rlecode_table[i];

285 bytestream_put_byte(buf, rlecode);

286 if (rlecode == 0) {

287 /* Write a skip sequence */

288 bytestream_put_byte(buf, s->skip_table[i] + 1);

289 i += s->skip_table[i];

290 }

291 else if (rlecode > 0) {

292 /* bulk copy */

293 if (s->avctx->pix_fmt == AV_PIX_FMT_GRAY8) {

294 int j;

295 // QT grayscale colorspace has 0=white and 255=black, we will

296 // ignore the palette that is included in the AVFrame because

297 // AV_PIX_FMT_GRAY8 has defined color mapping

298 for (j = 0; j < rlecode*s->pixel_size; ++j)

299 bytestream_put_byte(buf, *(this_line + i*s->pixel_size + j) ^ 0xff);

300 } else {

301 bytestream_put_buffer(buf, this_line + i*s->pixel_size, rlecode*s->pixel_size);

302 }

303 i += rlecode;

304 }

305 else {

306 /* repeat the bits */

307 if (s->avctx->pix_fmt == AV_PIX_FMT_GRAY8) {

308 int j;

309 // QT grayscale colorspace has 0=white and 255=black, ...

310 for (j = 0; j < s->pixel_size; ++j)

311 bytestream_put_byte(buf, *(this_line + i*s->pixel_size + j) ^ 0xff);

312 } else {

313 bytestream_put_buffer(buf, this_line + i*s->pixel_size, s->pixel_size);

314 }

315 i -= rlecode;

316 }

317 }

318 bytestream_put_byte(buf, -1); // end RLE line

319 }

320

321 /** Encode frame including header */

322 static int encode_frame(QtrleEncContext *s, const AVFrame *p, uint8_t *buf)

323 {

324 int i;

325 int start_line = 0;

326 int end_line = s->avctx->height;

327 uint8_t *orig_buf = buf;

328

329 if (!s->avctx->coded_frame->key_frame) {

330 unsigned line_size = s->logical_width * s->pixel_size;

331 for (start_line = 0; start_line < s->avctx->height; start_line++)

332 if (memcmp(p->data[0] + start_line*p->linesize[0],

333 s->previous_frame.data[0] + start_line*s->previous_frame.linesize[0],

334 line_size))

335 break;

336

337 for (end_line=s->avctx->height; end_line > start_line; end_line--)

338 if (memcmp(p->data[0] + (end_line - 1)*p->linesize[0],

339 s->previous_frame.data[0] + (end_line - 1)*s->previous_frame.linesize[0],

340 line_size))

341 break;

342 }

343

344 bytestream_put_be32(&buf, 0); // CHUNK SIZE, patched later

345

346 if ((start_line == 0 && end_line == s->avctx->height) || start_line == s->avctx->height)

347 bytestream_put_be16(&buf, 0); // header

348 else {

349 bytestream_put_be16(&buf, 8); // header

350 bytestream_put_be16(&buf, start_line); // starting line

351 bytestream_put_be16(&buf, 0); // unknown

352 bytestream_put_be16(&buf, end_line - start_line); // lines to update

353 bytestream_put_be16(&buf, 0); // unknown

354 }

355 for (i = start_line; i < end_line; i++)

356 qtrle_encode_line(s, p, i, &buf);

357

358 bytestream_put_byte(&buf, 0); // zero skip code = frame finished

359 AV_WB32(orig_buf, buf - orig_buf); // patch the chunk size

360 return buf - orig_buf;

361 }

362

363 static int qtrle_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

364 const AVFrame *pict, int *got_packet)

365 {

366 QtrleEncContext * const s = avctx->priv_data;

367 AVFrame * const p = avctx->coded_frame;

368 int ret;

369

370 if ((ret = ff_alloc_packet2(avctx, pkt, s->max_buf_size)) < 0)

371 return ret;

372

373 if (avctx->gop_size == 0 || (s->avctx->frame_number % avctx->gop_size) == 0) {

374 /* I-Frame */

375 p->pict_type = AV_PICTURE_TYPE_I;

376 p->key_frame = 1;

377 } else {

378 /* P-Frame */

379 p->pict_type = AV_PICTURE_TYPE_P;

380 p->key_frame = 0;

381 }

382

383 pkt->size = encode_frame(s, pict, pkt->data);

384

385 /* save the current frame */

386 av_picture_copy(&s->previous_frame, (const AVPicture *)pict,

387 avctx->pix_fmt, avctx->width, avctx->height);

388

389 if (p->key_frame)

390 pkt->flags |= AV_PKT_FLAG_KEY;

391 *got_packet = 1;

392

393 return 0;

394 }

395

396 AVCodec ff_qtrle_encoder = {

397 .name = "qtrle",

398 .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),

399 .type = AVMEDIA_TYPE_VIDEO,

400 .id = AV_CODEC_ID_QTRLE,

401 .priv_data_size = sizeof(QtrleEncContext),

402 .init = qtrle_encode_init,

403 .encode2 = qtrle_encode_frame,

404 .close = qtrle_encode_end,

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

406 AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_ARGB, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE

407 },

408 };

Generated on Sat Jan 25 2014 19:51:53 for FFmpeg by doxygen 1.8.2