1/* 2 * Quicktime Animation (RLE) Video Encoder 3 * Copyright (C) 2007 Clemens Fruhwirth 4 * Copyright (C) 2007 Alexis Ballier 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 */ 24 25#include "libavutil/imgutils.h" 26#include "avcodec.h" 27#include "bytestream.h" 28#include "internal.h" 29 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 36 37typedef 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; 62 63static av_cold int qtrle_encode_end(AVCodecContext *avctx) 64{ 65 QtrleEncContext *s = avctx->priv_data; 66 67 av_frame_free(&avctx->coded_frame); 68 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} 75 76static av_cold int qtrle_encode_init(AVCodecContext *avctx) 77{ 78 QtrleEncContext *s = avctx->priv_data; 79 int ret; 80 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; 86 87 switch (avctx->pix_fmt) { 88 case AV_PIX_FMT_GRAY8: 89 if (avctx->width % 4) { 90 av_log(avctx, AV_LOG_ERROR, "Width not being a multiple of 4 is not supported\n"); 91 return AVERROR(EINVAL); 92 } 93 s->logical_width = avctx->width / 4; 94 s->pixel_size = 4; 95 break; 96 case AV_PIX_FMT_RGB555BE: 97 s->pixel_size = 2; 98 break; 99 case AV_PIX_FMT_RGB24: 100 s->pixel_size = 3; 101 break; 102 case AV_PIX_FMT_ARGB: 103 s->pixel_size = 4; 104 break; 105 default: 106 av_log(avctx, AV_LOG_ERROR, "Unsupported colorspace.\n"); 107 break; 108 } 109 avctx->bits_per_coded_sample = avctx->pix_fmt == AV_PIX_FMT_GRAY8 ? 40 : s->pixel_size*8; 110 111 s->rlecode_table = av_mallocz(s->logical_width); 112 s->skip_table = av_mallocz(s->logical_width); 113 s->length_table = av_mallocz_array(s->logical_width + 1, sizeof(int)); 114 if (!s->skip_table || !s->length_table || !s->rlecode_table) { 115 av_log(avctx, AV_LOG_ERROR, "Error allocating memory.\n"); 116 return AVERROR(ENOMEM); 117 } 118 if ((ret = avpicture_alloc(&s->previous_frame, avctx->pix_fmt, avctx->width, avctx->height)) < 0) { 119 av_log(avctx, AV_LOG_ERROR, "Error allocating picture\n"); 120 return ret; 121 } 122 123 s->max_buf_size = s->logical_width*s->avctx->height*s->pixel_size*2 /* image base material */ 124 + 15 /* header + footer */ 125 + s->avctx->height*2 /* skip code+rle end */ 126 + s->logical_width/MAX_RLE_BULK + 1 /* rle codes */; 127 128 avctx->coded_frame = av_frame_alloc(); 129 if (!avctx->coded_frame) { 130 qtrle_encode_end(avctx); 131 return AVERROR(ENOMEM); 132 } 133 134 return 0; 135} 136 137/** 138 * Compute the best RLE sequence for a line 139 */ 140static void qtrle_encode_line(QtrleEncContext *s, const AVFrame *p, int line, uint8_t **buf) 141{ 142 int width=s->logical_width; 143 int i; 144 signed char rlecode; 145 146 /* This will be the number of pixels equal to the preivous frame one's 147 * starting from the ith pixel */ 148 unsigned int skipcount; 149 /* This will be the number of consecutive equal pixels in the current 150 * frame, starting from the ith one also */ 151 unsigned int av_uninit(repeatcount); 152 153 /* The cost of the three different possibilities */ 154 int total_skip_cost; 155 int total_repeat_cost; 156 157 int base_bulk_cost; 158 int lowest_bulk_cost; 159 int lowest_bulk_cost_index; 160 int sec_lowest_bulk_cost; 161 int sec_lowest_bulk_cost_index; 162 163 uint8_t *this_line = p-> data[0] + line*p-> linesize[0] + 164 (width - 1)*s->pixel_size; 165 uint8_t *prev_line = s->previous_frame.data[0] + line*s->previous_frame.linesize[0] + 166 (width - 1)*s->pixel_size; 167 168 s->length_table[width] = 0; 169 skipcount = 0; 170 171 /* Initial values */ 172 lowest_bulk_cost = INT_MAX / 2; 173 lowest_bulk_cost_index = width; 174 sec_lowest_bulk_cost = INT_MAX / 2; 175 sec_lowest_bulk_cost_index = width; 176 177 base_bulk_cost = 1 + s->pixel_size; 178 179 for (i = width - 1; i >= 0; i--) { 180 181 int prev_bulk_cost; 182 183 /* If our lowest bulk cost index is too far away, replace it 184 * with the next lowest bulk cost */ 185 if (FFMIN(width, i + MAX_RLE_BULK) < lowest_bulk_cost_index) { 186 lowest_bulk_cost = sec_lowest_bulk_cost; 187 lowest_bulk_cost_index = sec_lowest_bulk_cost_index; 188 189 sec_lowest_bulk_cost = INT_MAX / 2; 190 sec_lowest_bulk_cost_index = width; 191 } 192 193 /* Deal with the first pixel's bulk cost */ 194 if (!i) { 195 base_bulk_cost++; 196 lowest_bulk_cost++; 197 sec_lowest_bulk_cost++; 198 } 199 200 /* Look at the bulk cost of the previous loop and see if it is 201 * a new lower bulk cost */ 202 prev_bulk_cost = s->length_table[i + 1] + base_bulk_cost; 203 if (prev_bulk_cost <= sec_lowest_bulk_cost) { 204 /* If it's lower than the 2nd lowest, then it may be lower 205 * than the lowest */ 206 if (prev_bulk_cost <= lowest_bulk_cost) { 207 208 /* If we have found a new lowest bulk cost, 209 * then the 2nd lowest bulk cost is now farther than the 210 * lowest bulk cost, and will never be used */ 211 sec_lowest_bulk_cost = INT_MAX / 2; 212 213 lowest_bulk_cost = prev_bulk_cost; 214 lowest_bulk_cost_index = i + 1; 215 } else { 216 /* Then it must be the 2nd lowest bulk cost */ 217 sec_lowest_bulk_cost = prev_bulk_cost; 218 sec_lowest_bulk_cost_index = i + 1; 219 } 220 } 221 222 if (!s->avctx->coded_frame->key_frame && !memcmp(this_line, prev_line, s->pixel_size)) 223 skipcount = FFMIN(skipcount + 1, MAX_RLE_SKIP); 224 else 225 skipcount = 0; 226 227 total_skip_cost = s->length_table[i + skipcount] + 2; 228 s->skip_table[i] = skipcount; 229 230 231 if (i < width - 1 && !memcmp(this_line, this_line + s->pixel_size, s->pixel_size)) 232 repeatcount = FFMIN(repeatcount + 1, MAX_RLE_REPEAT); 233 else 234 repeatcount = 1; 235 236 total_repeat_cost = s->length_table[i + repeatcount] + 1 + s->pixel_size; 237 238 /* skip code is free for the first pixel, it costs one byte for repeat and bulk copy 239 * so let's make it aware */ 240 if (i == 0) { 241 total_skip_cost--; 242 total_repeat_cost++; 243 } 244 245 if (repeatcount > 1 && (skipcount == 0 || total_repeat_cost < total_skip_cost)) { 246 /* repeat is the best */ 247 s->length_table[i] = total_repeat_cost; 248 s->rlecode_table[i] = -repeatcount; 249 } 250 else if (skipcount > 0) { 251 /* skip is the best choice here */ 252 s->length_table[i] = total_skip_cost; 253 s->rlecode_table[i] = 0; 254 } 255 else { 256 /* We cannot do neither skip nor repeat 257 * thus we use the best bulk copy */ 258 259 s->length_table[i] = lowest_bulk_cost; 260 s->rlecode_table[i] = lowest_bulk_cost_index - i; 261 262 } 263 264 /* These bulk costs increase every iteration */ 265 lowest_bulk_cost += s->pixel_size; 266 sec_lowest_bulk_cost += s->pixel_size; 267 268 this_line -= s->pixel_size; 269 prev_line -= s->pixel_size; 270 } 271 272 /* Good ! Now we have the best sequence for this line, let's output it */ 273 274 /* We do a special case for the first pixel so that we avoid testing it in 275 * the whole loop */ 276 277 i=0; 278 this_line = p-> data[0] + line*p->linesize[0]; 279 280 if (s->rlecode_table[0] == 0) { 281 bytestream_put_byte(buf, s->skip_table[0] + 1); 282 i += s->skip_table[0]; 283 } 284 else bytestream_put_byte(buf, 1); 285 286 287 while (i < width) { 288 rlecode = s->rlecode_table[i]; 289 bytestream_put_byte(buf, rlecode); 290 if (rlecode == 0) { 291 /* Write a skip sequence */ 292 bytestream_put_byte(buf, s->skip_table[i] + 1); 293 i += s->skip_table[i]; 294 } 295 else if (rlecode > 0) { 296 /* bulk copy */ 297 if (s->avctx->pix_fmt == AV_PIX_FMT_GRAY8) { 298 int j; 299 // QT grayscale colorspace has 0=white and 255=black, we will 300 // ignore the palette that is included in the AVFrame because 301 // AV_PIX_FMT_GRAY8 has defined color mapping 302 for (j = 0; j < rlecode*s->pixel_size; ++j) 303 bytestream_put_byte(buf, *(this_line + i*s->pixel_size + j) ^ 0xff); 304 } else { 305 bytestream_put_buffer(buf, this_line + i*s->pixel_size, rlecode*s->pixel_size); 306 } 307 i += rlecode; 308 } 309 else { 310 /* repeat the bits */ 311 if (s->avctx->pix_fmt == AV_PIX_FMT_GRAY8) { 312 int j; 313 // QT grayscale colorspace has 0=white and 255=black, ... 314 for (j = 0; j < s->pixel_size; ++j) 315 bytestream_put_byte(buf, *(this_line + i*s->pixel_size + j) ^ 0xff); 316 } else { 317 bytestream_put_buffer(buf, this_line + i*s->pixel_size, s->pixel_size); 318 } 319 i -= rlecode; 320 } 321 } 322 bytestream_put_byte(buf, -1); // end RLE line 323} 324 325/** Encode frame including header */ 326static int encode_frame(QtrleEncContext *s, const AVFrame *p, uint8_t *buf) 327{ 328 int i; 329 int start_line = 0; 330 int end_line = s->avctx->height; 331 uint8_t *orig_buf = buf; 332 333 if (!s->avctx->coded_frame->key_frame) { 334 unsigned line_size = s->logical_width * s->pixel_size; 335 for (start_line = 0; start_line < s->avctx->height; start_line++) 336 if (memcmp(p->data[0] + start_line*p->linesize[0], 337 s->previous_frame.data[0] + start_line*s->previous_frame.linesize[0], 338 line_size)) 339 break; 340 341 for (end_line=s->avctx->height; end_line > start_line; end_line--) 342 if (memcmp(p->data[0] + (end_line - 1)*p->linesize[0], 343 s->previous_frame.data[0] + (end_line - 1)*s->previous_frame.linesize[0], 344 line_size)) 345 break; 346 } 347 348 bytestream_put_be32(&buf, 0); // CHUNK SIZE, patched later 349 350 if ((start_line == 0 && end_line == s->avctx->height) || start_line == s->avctx->height) 351 bytestream_put_be16(&buf, 0); // header 352 else { 353 bytestream_put_be16(&buf, 8); // header 354 bytestream_put_be16(&buf, start_line); // starting line 355 bytestream_put_be16(&buf, 0); // unknown 356 bytestream_put_be16(&buf, end_line - start_line); // lines to update 357 bytestream_put_be16(&buf, 0); // unknown 358 } 359 for (i = start_line; i < end_line; i++) 360 qtrle_encode_line(s, p, i, &buf); 361 362 bytestream_put_byte(&buf, 0); // zero skip code = frame finished 363 AV_WB32(orig_buf, buf - orig_buf); // patch the chunk size 364 return buf - orig_buf; 365} 366 367static int qtrle_encode_frame(AVCodecContext *avctx, AVPacket *pkt, 368 const AVFrame *pict, int *got_packet) 369{ 370 QtrleEncContext * const s = avctx->priv_data; 371 AVFrame * const p = avctx->coded_frame; 372 int ret; 373 374 if ((ret = ff_alloc_packet2(avctx, pkt, s->max_buf_size)) < 0) 375 return ret; 376 377 if (avctx->gop_size == 0 || (s->avctx->frame_number % avctx->gop_size) == 0) { 378 /* I-Frame */ 379 p->pict_type = AV_PICTURE_TYPE_I; 380 p->key_frame = 1; 381 } else { 382 /* P-Frame */ 383 p->pict_type = AV_PICTURE_TYPE_P; 384 p->key_frame = 0; 385 } 386 387 pkt->size = encode_frame(s, pict, pkt->data); 388 389 /* save the current frame */ 390 av_picture_copy(&s->previous_frame, (const AVPicture *)pict, 391 avctx->pix_fmt, avctx->width, avctx->height); 392 393 if (p->key_frame) 394 pkt->flags |= AV_PKT_FLAG_KEY; 395 *got_packet = 1; 396 397 return 0; 398} 399 400AVCodec ff_qtrle_encoder = { 401 .name = "qtrle", 402 .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"), 403 .type = AVMEDIA_TYPE_VIDEO, 404 .id = AV_CODEC_ID_QTRLE, 405 .priv_data_size = sizeof(QtrleEncContext), 406 .init = qtrle_encode_init, 407 .encode2 = qtrle_encode_frame, 408 .close = qtrle_encode_end, 409 .pix_fmts = (const enum AVPixelFormat[]){ 410 AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_ARGB, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE 411 }, 412}; 413