1/* 2 * huffyuv decoder 3 * 4 * Copyright (c) 2002-2014 Michael Niedermayer <michaelni@gmx.at> 5 * 6 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of 7 * the algorithm used 8 * 9 * This file is part of FFmpeg. 10 * 11 * FFmpeg is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU Lesser General Public 13 * License as published by the Free Software Foundation; either 14 * version 2.1 of the License, or (at your option) any later version. 15 * 16 * FFmpeg is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * Lesser General Public License for more details. 20 * 21 * You should have received a copy of the GNU Lesser General Public 22 * License along with FFmpeg; if not, write to the Free Software 23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 24 * 25 * yuva, gray, 4:4:4, 4:1:1, 4:1:0 and >8 bit per sample support sponsored by NOA 26 */ 27 28/** 29 * @file 30 * huffyuv decoder 31 */ 32 33#define UNCHECKED_BITSTREAM_READER 1 34 35#include "config_components.h" 36 37#include "avcodec.h" 38#include "codec_internal.h" 39#include "get_bits.h" 40#include "huffyuv.h" 41#include "huffyuvdsp.h" 42#include "lossless_videodsp.h" 43#include "thread.h" 44#include "libavutil/imgutils.h" 45#include "libavutil/pixdesc.h" 46 47#define classic_shift_luma_table_size 42 48static const unsigned char classic_shift_luma[classic_shift_luma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = { 49 34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10, 50 14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8, 51 10, 21, 9, 23, 8, 8, 199, 70, 69, 68, 0, 52 0,0,0,0,0,0,0,0, 53}; 54 55#define classic_shift_chroma_table_size 59 56static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = { 57 66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83, 58 84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141, 59 57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79, 60 78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34, 0, 61 0,0,0,0,0,0,0,0, 62}; 63 64static const unsigned char classic_add_luma[256] = { 65 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37, 66 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36, 67 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36, 68 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39, 69 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37, 70 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29, 71 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16, 72 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14, 73 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6, 74 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15, 75 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25, 76 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49, 77 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60, 78 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52, 79 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43, 80 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8, 81}; 82 83static const unsigned char classic_add_chroma[256] = { 84 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9, 85 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7, 86 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77, 87 43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63, 88 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 89 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22, 90 17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111, 91 112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1, 92 0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134, 93 135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96, 94 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41, 95 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36, 96 7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26, 97 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13, 98 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8, 99 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2, 100}; 101 102static int read_len_table(uint8_t *dst, GetBitContext *gb, int n) 103{ 104 int i, val, repeat; 105 106 for (i = 0; i < n;) { 107 repeat = get_bits(gb, 3); 108 val = get_bits(gb, 5); 109 if (repeat == 0) 110 repeat = get_bits(gb, 8); 111 if (i + repeat > n || get_bits_left(gb) < 0) { 112 av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n"); 113 return AVERROR_INVALIDDATA; 114 } 115 while (repeat--) 116 dst[i++] = val; 117 } 118 return 0; 119} 120 121static int generate_joint_tables(HYuvContext *s) 122{ 123 int ret; 124 uint16_t *symbols = av_mallocz(5 << VLC_BITS); 125 uint16_t *bits; 126 uint8_t *len; 127 if (!symbols) 128 return AVERROR(ENOMEM); 129 bits = symbols + (1 << VLC_BITS); 130 len = (uint8_t *)(bits + (1 << VLC_BITS)); 131 132 if (s->bitstream_bpp < 24 || s->version > 2) { 133 int p, i, y, u; 134 for (p = 0; p < 4; p++) { 135 int p0 = s->version > 2 ? p : 0; 136 for (i = y = 0; y < s->vlc_n; y++) { 137 int len0 = s->len[p0][y]; 138 int limit = VLC_BITS - len0; 139 if (limit <= 0 || !len0) 140 continue; 141 if ((sign_extend(y, 8) & (s->vlc_n-1)) != y) 142 continue; 143 for (u = 0; u < s->vlc_n; u++) { 144 int len1 = s->len[p][u]; 145 if (len1 > limit || !len1) 146 continue; 147 if ((sign_extend(u, 8) & (s->vlc_n-1)) != u) 148 continue; 149 av_assert0(i < (1 << VLC_BITS)); 150 len[i] = len0 + len1; 151 bits[i] = (s->bits[p0][y] << len1) + s->bits[p][u]; 152 symbols[i] = (y << 8) + (u & 0xFF); 153 i++; 154 } 155 } 156 ff_free_vlc(&s->vlc[4 + p]); 157 if ((ret = ff_init_vlc_sparse(&s->vlc[4 + p], VLC_BITS, i, len, 1, 1, 158 bits, 2, 2, symbols, 2, 2, 0)) < 0) 159 goto out; 160 } 161 } else { 162 uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map; 163 int i, b, g, r, code; 164 int p0 = s->decorrelate; 165 int p1 = !s->decorrelate; 166 /* Restrict the range to +/-16 because that's pretty much guaranteed 167 * to cover all the combinations that fit in 11 bits total, and it 168 * does not matter if we miss a few rare codes. */ 169 for (i = 0, g = -16; g < 16; g++) { 170 int len0 = s->len[p0][g & 255]; 171 int limit0 = VLC_BITS - len0; 172 if (limit0 < 2 || !len0) 173 continue; 174 for (b = -16; b < 16; b++) { 175 int len1 = s->len[p1][b & 255]; 176 int limit1 = limit0 - len1; 177 if (limit1 < 1 || !len1) 178 continue; 179 code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255]; 180 for (r = -16; r < 16; r++) { 181 int len2 = s->len[2][r & 255]; 182 if (len2 > limit1 || !len2) 183 continue; 184 av_assert0(i < (1 << VLC_BITS)); 185 len[i] = len0 + len1 + len2; 186 bits[i] = (code << len2) + s->bits[2][r & 255]; 187 if (s->decorrelate) { 188 map[i][G] = g; 189 map[i][B] = g + b; 190 map[i][R] = g + r; 191 } else { 192 map[i][B] = g; 193 map[i][G] = b; 194 map[i][R] = r; 195 } 196 i++; 197 } 198 } 199 } 200 ff_free_vlc(&s->vlc[4]); 201 if ((ret = init_vlc(&s->vlc[4], VLC_BITS, i, len, 1, 1, 202 bits, 2, 2, 0)) < 0) 203 goto out; 204 } 205 ret = 0; 206out: 207 av_freep(&symbols); 208 return ret; 209} 210 211static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length) 212{ 213 GetBitContext gb; 214 int i, ret; 215 int count = 3; 216 217 if ((ret = init_get_bits(&gb, src, length * 8)) < 0) 218 return ret; 219 220 if (s->version > 2) 221 count = 1 + s->alpha + 2*s->chroma; 222 223 for (i = 0; i < count; i++) { 224 if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0) 225 return ret; 226 if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0) 227 return ret; 228 ff_free_vlc(&s->vlc[i]); 229 if ((ret = init_vlc(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1, 230 s->bits[i], 4, 4, 0)) < 0) 231 return ret; 232 } 233 234 if ((ret = generate_joint_tables(s)) < 0) 235 return ret; 236 237 return (get_bits_count(&gb) + 7) / 8; 238} 239 240static int read_old_huffman_tables(HYuvContext *s) 241{ 242 GetBitContext gb; 243 int i, ret; 244 245 init_get_bits(&gb, classic_shift_luma, 246 classic_shift_luma_table_size * 8); 247 if ((ret = read_len_table(s->len[0], &gb, 256)) < 0) 248 return ret; 249 250 init_get_bits(&gb, classic_shift_chroma, 251 classic_shift_chroma_table_size * 8); 252 if ((ret = read_len_table(s->len[1], &gb, 256)) < 0) 253 return ret; 254 255 for (i = 0; i < 256; i++) 256 s->bits[0][i] = classic_add_luma[i]; 257 for (i = 0; i < 256; i++) 258 s->bits[1][i] = classic_add_chroma[i]; 259 260 if (s->bitstream_bpp >= 24) { 261 memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t)); 262 memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t)); 263 } 264 memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t)); 265 memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t)); 266 267 for (i = 0; i < 4; i++) { 268 ff_free_vlc(&s->vlc[i]); 269 if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, 270 s->bits[i], 4, 4, 0)) < 0) 271 return ret; 272 } 273 274 if ((ret = generate_joint_tables(s)) < 0) 275 return ret; 276 277 return 0; 278} 279 280static av_cold int decode_end(AVCodecContext *avctx) 281{ 282 HYuvContext *s = avctx->priv_data; 283 int i; 284 285 ff_huffyuv_common_end(s); 286 av_freep(&s->bitstream_buffer); 287 288 for (i = 0; i < 8; i++) 289 ff_free_vlc(&s->vlc[i]); 290 291 return 0; 292} 293 294static av_cold int decode_init(AVCodecContext *avctx) 295{ 296 HYuvContext *s = avctx->priv_data; 297 int ret; 298 299 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); 300 if (ret < 0) 301 return ret; 302 303 ff_huffyuvdsp_init(&s->hdsp, avctx->pix_fmt); 304 ff_llviddsp_init(&s->llviddsp); 305 memset(s->vlc, 0, 4 * sizeof(VLC)); 306 307 s->interlaced = avctx->height > 288; 308 s->bgr32 = 1; 309 310 if (avctx->extradata_size) { 311 if ((avctx->bits_per_coded_sample & 7) && 312 avctx->bits_per_coded_sample != 12) 313 s->version = 1; // do such files exist at all? 314 else if (avctx->extradata_size > 3 && avctx->extradata[3] == 0) 315 s->version = 2; 316 else 317 s->version = 3; 318 } else 319 s->version = 0; 320 321 s->bps = 8; 322 s->n = 1<<s->bps; 323 s->vlc_n = FFMIN(s->n, MAX_VLC_N); 324 s->chroma = 1; 325 if (s->version >= 2) { 326 int method, interlace; 327 328 if (avctx->extradata_size < 4) 329 return AVERROR_INVALIDDATA; 330 331 method = avctx->extradata[0]; 332 s->decorrelate = method & 64 ? 1 : 0; 333 s->predictor = method & 63; 334 if (s->version == 2) { 335 s->bitstream_bpp = avctx->extradata[1]; 336 if (s->bitstream_bpp == 0) 337 s->bitstream_bpp = avctx->bits_per_coded_sample & ~7; 338 } else { 339 s->bps = (avctx->extradata[1] >> 4) + 1; 340 s->n = 1<<s->bps; 341 s->vlc_n = FFMIN(s->n, MAX_VLC_N); 342 s->chroma_h_shift = avctx->extradata[1] & 3; 343 s->chroma_v_shift = (avctx->extradata[1] >> 2) & 3; 344 s->yuv = !!(avctx->extradata[2] & 1); 345 s->chroma= !!(avctx->extradata[2] & 3); 346 s->alpha = !!(avctx->extradata[2] & 4); 347 } 348 interlace = (avctx->extradata[2] & 0x30) >> 4; 349 s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced; 350 s->context = avctx->extradata[2] & 0x40 ? 1 : 0; 351 352 if ((ret = read_huffman_tables(s, avctx->extradata + 4, 353 avctx->extradata_size - 4)) < 0) 354 return ret; 355 } else { 356 switch (avctx->bits_per_coded_sample & 7) { 357 case 1: 358 s->predictor = LEFT; 359 s->decorrelate = 0; 360 break; 361 case 2: 362 s->predictor = LEFT; 363 s->decorrelate = 1; 364 break; 365 case 3: 366 s->predictor = PLANE; 367 s->decorrelate = avctx->bits_per_coded_sample >= 24; 368 break; 369 case 4: 370 s->predictor = MEDIAN; 371 s->decorrelate = 0; 372 break; 373 default: 374 s->predictor = LEFT; // OLD 375 s->decorrelate = 0; 376 break; 377 } 378 s->bitstream_bpp = avctx->bits_per_coded_sample & ~7; 379 s->context = 0; 380 381 if ((ret = read_old_huffman_tables(s)) < 0) 382 return ret; 383 } 384 385 if (s->version <= 2) { 386 switch (s->bitstream_bpp) { 387 case 12: 388 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 389 s->yuv = 1; 390 break; 391 case 16: 392 if (s->yuy2) 393 avctx->pix_fmt = AV_PIX_FMT_YUYV422; 394 else 395 avctx->pix_fmt = AV_PIX_FMT_YUV422P; 396 s->yuv = 1; 397 break; 398 case 24: 399 if (s->bgr32) 400 avctx->pix_fmt = AV_PIX_FMT_0RGB32; 401 else 402 avctx->pix_fmt = AV_PIX_FMT_BGR24; 403 break; 404 case 32: 405 av_assert0(s->bgr32); 406 avctx->pix_fmt = AV_PIX_FMT_RGB32; 407 s->alpha = 1; 408 break; 409 default: 410 return AVERROR_INVALIDDATA; 411 } 412 av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, 413 &s->chroma_h_shift, 414 &s->chroma_v_shift); 415 } else { 416 switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) { 417 case 0x070: 418 avctx->pix_fmt = AV_PIX_FMT_GRAY8; 419 break; 420 case 0x0F0: 421 avctx->pix_fmt = AV_PIX_FMT_GRAY16; 422 break; 423 case 0x470: 424 avctx->pix_fmt = AV_PIX_FMT_GBRP; 425 break; 426 case 0x480: 427 avctx->pix_fmt = AV_PIX_FMT_GBRP9; 428 break; 429 case 0x490: 430 avctx->pix_fmt = AV_PIX_FMT_GBRP10; 431 break; 432 case 0x4B0: 433 avctx->pix_fmt = AV_PIX_FMT_GBRP12; 434 break; 435 case 0x4D0: 436 avctx->pix_fmt = AV_PIX_FMT_GBRP14; 437 break; 438 case 0x4F0: 439 avctx->pix_fmt = AV_PIX_FMT_GBRP16; 440 break; 441 case 0x570: 442 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 443 break; 444 case 0x670: 445 avctx->pix_fmt = AV_PIX_FMT_YUV444P; 446 break; 447 case 0x680: 448 avctx->pix_fmt = AV_PIX_FMT_YUV444P9; 449 break; 450 case 0x690: 451 avctx->pix_fmt = AV_PIX_FMT_YUV444P10; 452 break; 453 case 0x6B0: 454 avctx->pix_fmt = AV_PIX_FMT_YUV444P12; 455 break; 456 case 0x6D0: 457 avctx->pix_fmt = AV_PIX_FMT_YUV444P14; 458 break; 459 case 0x6F0: 460 avctx->pix_fmt = AV_PIX_FMT_YUV444P16; 461 break; 462 case 0x671: 463 avctx->pix_fmt = AV_PIX_FMT_YUV422P; 464 break; 465 case 0x681: 466 avctx->pix_fmt = AV_PIX_FMT_YUV422P9; 467 break; 468 case 0x691: 469 avctx->pix_fmt = AV_PIX_FMT_YUV422P10; 470 break; 471 case 0x6B1: 472 avctx->pix_fmt = AV_PIX_FMT_YUV422P12; 473 break; 474 case 0x6D1: 475 avctx->pix_fmt = AV_PIX_FMT_YUV422P14; 476 break; 477 case 0x6F1: 478 avctx->pix_fmt = AV_PIX_FMT_YUV422P16; 479 break; 480 case 0x672: 481 avctx->pix_fmt = AV_PIX_FMT_YUV411P; 482 break; 483 case 0x674: 484 avctx->pix_fmt = AV_PIX_FMT_YUV440P; 485 break; 486 case 0x675: 487 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 488 break; 489 case 0x685: 490 avctx->pix_fmt = AV_PIX_FMT_YUV420P9; 491 break; 492 case 0x695: 493 avctx->pix_fmt = AV_PIX_FMT_YUV420P10; 494 break; 495 case 0x6B5: 496 avctx->pix_fmt = AV_PIX_FMT_YUV420P12; 497 break; 498 case 0x6D5: 499 avctx->pix_fmt = AV_PIX_FMT_YUV420P14; 500 break; 501 case 0x6F5: 502 avctx->pix_fmt = AV_PIX_FMT_YUV420P16; 503 break; 504 case 0x67A: 505 avctx->pix_fmt = AV_PIX_FMT_YUV410P; 506 break; 507 case 0x770: 508 avctx->pix_fmt = AV_PIX_FMT_YUVA444P; 509 break; 510 case 0x780: 511 avctx->pix_fmt = AV_PIX_FMT_YUVA444P9; 512 break; 513 case 0x790: 514 avctx->pix_fmt = AV_PIX_FMT_YUVA444P10; 515 break; 516 case 0x7F0: 517 avctx->pix_fmt = AV_PIX_FMT_YUVA444P16; 518 break; 519 case 0x771: 520 avctx->pix_fmt = AV_PIX_FMT_YUVA422P; 521 break; 522 case 0x781: 523 avctx->pix_fmt = AV_PIX_FMT_YUVA422P9; 524 break; 525 case 0x791: 526 avctx->pix_fmt = AV_PIX_FMT_YUVA422P10; 527 break; 528 case 0x7F1: 529 avctx->pix_fmt = AV_PIX_FMT_YUVA422P16; 530 break; 531 case 0x775: 532 avctx->pix_fmt = AV_PIX_FMT_YUVA420P; 533 break; 534 case 0x785: 535 avctx->pix_fmt = AV_PIX_FMT_YUVA420P9; 536 break; 537 case 0x795: 538 avctx->pix_fmt = AV_PIX_FMT_YUVA420P10; 539 break; 540 case 0x7F5: 541 avctx->pix_fmt = AV_PIX_FMT_YUVA420P16; 542 break; 543 default: 544 return AVERROR_INVALIDDATA; 545 } 546 } 547 548 ff_huffyuv_common_init(avctx); 549 550 if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) { 551 av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n"); 552 return AVERROR_INVALIDDATA; 553 } 554 if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P && 555 avctx->width % 4) { 556 av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 " 557 "for this combination of colorspace and predictor type.\n"); 558 return AVERROR_INVALIDDATA; 559 } 560 561 if ((ret = ff_huffyuv_alloc_temp(s)) < 0) 562 return ret; 563 564 return 0; 565} 566 567/** Subset of GET_VLC for use in hand-roller VLC code */ 568#define VLC_INTERN(dst, table, gb, name, bits, max_depth) \ 569 code = table[index].sym; \ 570 n = table[index].len; \ 571 if (max_depth > 1 && n < 0) { \ 572 LAST_SKIP_BITS(name, gb, bits); \ 573 UPDATE_CACHE(name, gb); \ 574 \ 575 nb_bits = -n; \ 576 index = SHOW_UBITS(name, gb, nb_bits) + code; \ 577 code = table[index].sym; \ 578 n = table[index].len; \ 579 if (max_depth > 2 && n < 0) { \ 580 LAST_SKIP_BITS(name, gb, nb_bits); \ 581 UPDATE_CACHE(name, gb); \ 582 \ 583 nb_bits = -n; \ 584 index = SHOW_UBITS(name, gb, nb_bits) + code; \ 585 code = table[index].sym; \ 586 n = table[index].len; \ 587 } \ 588 } \ 589 dst = code; \ 590 LAST_SKIP_BITS(name, gb, n) 591 592 593#define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2, \ 594 bits, max_depth, OP) \ 595 do { \ 596 unsigned int index = SHOW_UBITS(name, gb, bits); \ 597 int code, n = dtable[index].len; \ 598 \ 599 if (n<=0) { \ 600 int nb_bits; \ 601 VLC_INTERN(dst0, table1, gb, name, bits, max_depth); \ 602 \ 603 UPDATE_CACHE(re, gb); \ 604 index = SHOW_UBITS(name, gb, bits); \ 605 VLC_INTERN(dst1, table2, gb, name, bits, max_depth); \ 606 } else { \ 607 code = dtable[index].sym; \ 608 OP(dst0, dst1, code); \ 609 LAST_SKIP_BITS(name, gb, n); \ 610 } \ 611 } while (0) 612 613#define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code 614 615#define READ_2PIX(dst0, dst1, plane1) \ 616 UPDATE_CACHE(re, &s->gb); \ 617 GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table, \ 618 s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits) 619 620static void decode_422_bitstream(HYuvContext *s, int count) 621{ 622 int i, icount; 623 OPEN_READER(re, &s->gb); 624 count /= 2; 625 626 icount = get_bits_left(&s->gb) / (32 * 4); 627 if (count >= icount) { 628 for (i = 0; i < icount; i++) { 629 READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1); 630 READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2); 631 } 632 for (; i < count && BITS_LEFT(re, &s->gb) > 0; i++) { 633 READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1); 634 if (BITS_LEFT(re, &s->gb) <= 0) break; 635 READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2); 636 } 637 for (; i < count; i++) 638 s->temp[0][2 * i ] = s->temp[1][i] = 639 s->temp[0][2 * i + 1] = s->temp[2][i] = 0; 640 } else { 641 for (i = 0; i < count; i++) { 642 READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1); 643 READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2); 644 } 645 } 646 CLOSE_READER(re, &s->gb); 647} 648 649#define READ_2PIX_PLANE(dst0, dst1, plane, OP) \ 650 UPDATE_CACHE(re, &s->gb); \ 651 GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \ 652 s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP) 653 654#define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8) 655 656/* TODO instead of restarting the read when the code isn't in the first level 657 * of the joint table, jump into the 2nd level of the individual table. */ 658#define READ_2PIX_PLANE16(dst0, dst1, plane){\ 659 dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\ 660 dst0 += get_bits(&s->gb, 2);\ 661 dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\ 662 dst1 += get_bits(&s->gb, 2);\ 663} 664static void decode_plane_bitstream(HYuvContext *s, int width, int plane) 665{ 666 int i, count = width/2; 667 668 if (s->bps <= 8) { 669 OPEN_READER(re, &s->gb); 670 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) { 671 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) { 672 READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits); 673 } 674 } else { 675 for(i=0; i<count; i++){ 676 READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits); 677 } 678 } 679 if( width&1 && BITS_LEFT(re, &s->gb)>0 ) { 680 unsigned int index; 681 int nb_bits, code, n; 682 UPDATE_CACHE(re, &s->gb); 683 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 684 VLC_INTERN(s->temp[0][width-1], s->vlc[plane].table, 685 &s->gb, re, VLC_BITS, 3); 686 } 687 CLOSE_READER(re, &s->gb); 688 } else if (s->bps <= 14) { 689 OPEN_READER(re, &s->gb); 690 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) { 691 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) { 692 READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits); 693 } 694 } else { 695 for(i=0; i<count; i++){ 696 READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits); 697 } 698 } 699 if( width&1 && BITS_LEFT(re, &s->gb)>0 ) { 700 unsigned int index; 701 int nb_bits, code, n; 702 UPDATE_CACHE(re, &s->gb); 703 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 704 VLC_INTERN(s->temp16[0][width-1], s->vlc[plane].table, 705 &s->gb, re, VLC_BITS, 3); 706 } 707 CLOSE_READER(re, &s->gb); 708 } else { 709 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) { 710 for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) { 711 READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane); 712 } 713 } else { 714 for(i=0; i<count; i++){ 715 READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane); 716 } 717 } 718 if( width&1 && get_bits_left(&s->gb)>0 ) { 719 int dst = (unsigned)get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2; 720 s->temp16[0][width-1] = dst + get_bits(&s->gb, 2); 721 } 722 } 723} 724 725static void decode_gray_bitstream(HYuvContext *s, int count) 726{ 727 int i; 728 OPEN_READER(re, &s->gb); 729 count /= 2; 730 731 if (count >= (get_bits_left(&s->gb)) / (32 * 2)) { 732 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) { 733 READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0); 734 } 735 } else { 736 for (i = 0; i < count; i++) { 737 READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0); 738 } 739 } 740 CLOSE_READER(re, &s->gb); 741} 742 743static av_always_inline void decode_bgr_1(HYuvContext *s, int count, 744 int decorrelate, int alpha) 745{ 746 int i; 747 OPEN_READER(re, &s->gb); 748 749 for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) { 750 unsigned int index; 751 int code, n, nb_bits; 752 753 UPDATE_CACHE(re, &s->gb); 754 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 755 n = s->vlc[4].table[index].len; 756 757 if (n>0) { 758 code = s->vlc[4].table[index].sym; 759 *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code]; 760 LAST_SKIP_BITS(re, &s->gb, n); 761 } else { 762 if (decorrelate) { 763 VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table, 764 &s->gb, re, VLC_BITS, 3); 765 766 UPDATE_CACHE(re, &s->gb); 767 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 768 VLC_INTERN(code, s->vlc[0].table, &s->gb, re, VLC_BITS, 3); 769 s->temp[0][4 * i + B] = code + s->temp[0][4 * i + G]; 770 771 UPDATE_CACHE(re, &s->gb); 772 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 773 VLC_INTERN(code, s->vlc[2].table, &s->gb, re, VLC_BITS, 3); 774 s->temp[0][4 * i + R] = code + s->temp[0][4 * i + G]; 775 } else { 776 VLC_INTERN(s->temp[0][4 * i + B], s->vlc[0].table, 777 &s->gb, re, VLC_BITS, 3); 778 779 UPDATE_CACHE(re, &s->gb); 780 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 781 VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table, 782 &s->gb, re, VLC_BITS, 3); 783 784 UPDATE_CACHE(re, &s->gb); 785 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 786 VLC_INTERN(s->temp[0][4 * i + R], s->vlc[2].table, 787 &s->gb, re, VLC_BITS, 3); 788 } 789 } 790 if (alpha) { 791 UPDATE_CACHE(re, &s->gb); 792 index = SHOW_UBITS(re, &s->gb, VLC_BITS); 793 VLC_INTERN(s->temp[0][4 * i + A], s->vlc[2].table, 794 &s->gb, re, VLC_BITS, 3); 795 } else 796 s->temp[0][4 * i + A] = 0; 797 } 798 CLOSE_READER(re, &s->gb); 799} 800 801static void decode_bgr_bitstream(HYuvContext *s, int count) 802{ 803 if (s->decorrelate) { 804 if (s->bitstream_bpp == 24) 805 decode_bgr_1(s, count, 1, 0); 806 else 807 decode_bgr_1(s, count, 1, 1); 808 } else { 809 if (s->bitstream_bpp == 24) 810 decode_bgr_1(s, count, 0, 0); 811 else 812 decode_bgr_1(s, count, 0, 1); 813 } 814} 815 816static void draw_slice(HYuvContext *s, AVFrame *frame, int y) 817{ 818 int h, cy, i; 819 int offset[AV_NUM_DATA_POINTERS]; 820 821 if (!s->avctx->draw_horiz_band) 822 return; 823 824 h = y - s->last_slice_end; 825 y -= h; 826 827 if (s->bitstream_bpp == 12) 828 cy = y >> 1; 829 else 830 cy = y; 831 832 offset[0] = frame->linesize[0] * y; 833 offset[1] = frame->linesize[1] * cy; 834 offset[2] = frame->linesize[2] * cy; 835 for (i = 3; i < AV_NUM_DATA_POINTERS; i++) 836 offset[i] = 0; 837 emms_c(); 838 839 s->avctx->draw_horiz_band(s->avctx, frame, offset, y, 3, h); 840 841 s->last_slice_end = y + h; 842} 843 844static int left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int acc) 845{ 846 if (s->bps <= 8) { 847 return s->llviddsp.add_left_pred(dst, src, w, acc); 848 } else { 849 return s->llviddsp.add_left_pred_int16(( uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc); 850 } 851} 852 853static void add_bytes(HYuvContext *s, uint8_t *dst, uint8_t *src, int w) 854{ 855 if (s->bps <= 8) { 856 s->llviddsp.add_bytes(dst, src, w); 857 } else { 858 s->hdsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w); 859 } 860} 861 862static void add_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top) 863{ 864 if (s->bps <= 8) { 865 s->llviddsp.add_median_pred(dst, src, diff, w, left, left_top); 866 } else { 867 s->hdsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top); 868 } 869} 870 871static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height, 872 int buf_size, int y_offset, int table_size) 873{ 874 HYuvContext *s = avctx->priv_data; 875 int fake_ystride, fake_ustride, fake_vstride; 876 const int width = s->width; 877 const int width2 = s->width >> 1; 878 int ret; 879 880 if ((ret = init_get_bits8(&s->gb, s->bitstream_buffer + table_size, buf_size - table_size)) < 0) 881 return ret; 882 883 fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0]; 884 fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1]; 885 fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2]; 886 887 if (s->version > 2) { 888 int plane; 889 for(plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) { 890 int left, lefttop, y; 891 int w = width; 892 int h = height; 893 int fake_stride = fake_ystride; 894 895 if (s->chroma && (plane == 1 || plane == 2)) { 896 w >>= s->chroma_h_shift; 897 h >>= s->chroma_v_shift; 898 fake_stride = plane == 1 ? fake_ustride : fake_vstride; 899 } 900 901 switch (s->predictor) { 902 case LEFT: 903 case PLANE: 904 decode_plane_bitstream(s, w, plane); 905 left = left_prediction(s, p->data[plane], s->temp[0], w, 0); 906 907 for (y = 1; y < h; y++) { 908 uint8_t *dst = p->data[plane] + p->linesize[plane]*y; 909 910 decode_plane_bitstream(s, w, plane); 911 left = left_prediction(s, dst, s->temp[0], w, left); 912 if (s->predictor == PLANE) { 913 if (y > s->interlaced) { 914 add_bytes(s, dst, dst - fake_stride, w); 915 } 916 } 917 } 918 919 break; 920 case MEDIAN: 921 decode_plane_bitstream(s, w, plane); 922 left= left_prediction(s, p->data[plane], s->temp[0], w, 0); 923 924 y = 1; 925 if (y >= h) 926 break; 927 928 /* second line is left predicted for interlaced case */ 929 if (s->interlaced) { 930 decode_plane_bitstream(s, w, plane); 931 left = left_prediction(s, p->data[plane] + p->linesize[plane], s->temp[0], w, left); 932 y++; 933 if (y >= h) 934 break; 935 } 936 937 lefttop = p->data[plane][0]; 938 decode_plane_bitstream(s, w, plane); 939 add_median_prediction(s, p->data[plane] + fake_stride, p->data[plane], s->temp[0], w, &left, &lefttop); 940 y++; 941 942 for (; y<h; y++) { 943 uint8_t *dst; 944 945 decode_plane_bitstream(s, w, plane); 946 947 dst = p->data[plane] + p->linesize[plane] * y; 948 949 add_median_prediction(s, dst, dst - fake_stride, s->temp[0], w, &left, &lefttop); 950 } 951 952 break; 953 } 954 } 955 draw_slice(s, p, height); 956 } else if (s->bitstream_bpp < 24) { 957 int y, cy; 958 int lefty, leftu, leftv; 959 int lefttopy, lefttopu, lefttopv; 960 961 if (s->yuy2) { 962 p->data[0][3] = get_bits(&s->gb, 8); 963 p->data[0][2] = get_bits(&s->gb, 8); 964 p->data[0][1] = get_bits(&s->gb, 8); 965 p->data[0][0] = get_bits(&s->gb, 8); 966 967 av_log(avctx, AV_LOG_ERROR, 968 "YUY2 output is not implemented yet\n"); 969 return AVERROR_PATCHWELCOME; 970 } else { 971 leftv = 972 p->data[2][0 + y_offset * p->linesize[2]] = get_bits(&s->gb, 8); 973 lefty = 974 p->data[0][1 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8); 975 leftu = 976 p->data[1][0 + y_offset * p->linesize[1]] = get_bits(&s->gb, 8); 977 p->data[0][0 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8); 978 979 switch (s->predictor) { 980 case LEFT: 981 case PLANE: 982 decode_422_bitstream(s, width - 2); 983 lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0] * y_offset + 2, s->temp[0], 984 width - 2, lefty); 985 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 986 leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[1] * y_offset + 1, s->temp[1], width2 - 1, leftu); 987 leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[2] * y_offset + 1, s->temp[2], width2 - 1, leftv); 988 } 989 990 for (cy = y = 1; y < height; y++, cy++) { 991 uint8_t *ydst, *udst, *vdst; 992 993 if (s->bitstream_bpp == 12) { 994 decode_gray_bitstream(s, width); 995 996 ydst = p->data[0] + p->linesize[0] * (y + y_offset); 997 998 lefty = s->llviddsp.add_left_pred(ydst, s->temp[0], 999 width, lefty); 1000 if (s->predictor == PLANE) { 1001 if (y > s->interlaced) 1002 s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width); 1003 } 1004 y++; 1005 if (y >= height) 1006 break; 1007 } 1008 1009 draw_slice(s, p, y); 1010 1011 ydst = p->data[0] + p->linesize[0] * (y + y_offset); 1012 udst = p->data[1] + p->linesize[1] * (cy + y_offset); 1013 vdst = p->data[2] + p->linesize[2] * (cy + y_offset); 1014 1015 decode_422_bitstream(s, width); 1016 lefty = s->llviddsp.add_left_pred(ydst, s->temp[0], 1017 width, lefty); 1018 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1019 leftu = s->llviddsp.add_left_pred(udst, s->temp[1], width2, leftu); 1020 leftv = s->llviddsp.add_left_pred(vdst, s->temp[2], width2, leftv); 1021 } 1022 if (s->predictor == PLANE) { 1023 if (cy > s->interlaced) { 1024 s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width); 1025 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1026 s->llviddsp.add_bytes(udst, udst - fake_ustride, width2); 1027 s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2); 1028 } 1029 } 1030 } 1031 } 1032 draw_slice(s, p, height); 1033 1034 break; 1035 case MEDIAN: 1036 /* first line except first 2 pixels is left predicted */ 1037 decode_422_bitstream(s, width - 2); 1038 lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0], 1039 width - 2, lefty); 1040 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1041 leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu); 1042 leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv); 1043 } 1044 1045 cy = y = 1; 1046 if (y >= height) 1047 break; 1048 1049 /* second line is left predicted for interlaced case */ 1050 if (s->interlaced) { 1051 decode_422_bitstream(s, width); 1052 lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0], 1053 s->temp[0], width, lefty); 1054 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1055 leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu); 1056 leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv); 1057 } 1058 y++; 1059 cy++; 1060 if (y >= height) 1061 break; 1062 } 1063 1064 /* next 4 pixels are left predicted too */ 1065 decode_422_bitstream(s, 4); 1066 lefty = s->llviddsp.add_left_pred(p->data[0] + fake_ystride, 1067 s->temp[0], 4, lefty); 1068 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1069 leftu = s->llviddsp.add_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu); 1070 leftv = s->llviddsp.add_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv); 1071 } 1072 1073 /* next line except the first 4 pixels is median predicted */ 1074 lefttopy = p->data[0][3]; 1075 decode_422_bitstream(s, width - 4); 1076 s->llviddsp.add_median_pred(p->data[0] + fake_ystride + 4, 1077 p->data[0] + 4, s->temp[0], 1078 width - 4, &lefty, &lefttopy); 1079 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1080 lefttopu = p->data[1][1]; 1081 lefttopv = p->data[2][1]; 1082 s->llviddsp.add_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu); 1083 s->llviddsp.add_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv); 1084 } 1085 y++; 1086 cy++; 1087 1088 for (; y < height; y++, cy++) { 1089 uint8_t *ydst, *udst, *vdst; 1090 1091 if (s->bitstream_bpp == 12) { 1092 while (2 * cy > y) { 1093 decode_gray_bitstream(s, width); 1094 ydst = p->data[0] + p->linesize[0] * y; 1095 s->llviddsp.add_median_pred(ydst, ydst - fake_ystride, 1096 s->temp[0], width, 1097 &lefty, &lefttopy); 1098 y++; 1099 } 1100 if (y >= height) 1101 break; 1102 } 1103 draw_slice(s, p, y); 1104 1105 decode_422_bitstream(s, width); 1106 1107 ydst = p->data[0] + p->linesize[0] * y; 1108 udst = p->data[1] + p->linesize[1] * cy; 1109 vdst = p->data[2] + p->linesize[2] * cy; 1110 1111 s->llviddsp.add_median_pred(ydst, ydst - fake_ystride, 1112 s->temp[0], width, 1113 &lefty, &lefttopy); 1114 if (!(s->flags & AV_CODEC_FLAG_GRAY)) { 1115 s->llviddsp.add_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu); 1116 s->llviddsp.add_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv); 1117 } 1118 } 1119 1120 draw_slice(s, p, height); 1121 break; 1122 } 1123 } 1124 } else { 1125 int y; 1126 uint8_t left[4]; 1127 const int last_line = (y_offset + height - 1) * p->linesize[0]; 1128 1129 if (s->bitstream_bpp == 32) { 1130 left[A] = p->data[0][last_line + A] = get_bits(&s->gb, 8); 1131 left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8); 1132 left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8); 1133 left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8); 1134 } else { 1135 left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8); 1136 left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8); 1137 left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8); 1138 left[A] = p->data[0][last_line + A] = 255; 1139 skip_bits(&s->gb, 8); 1140 } 1141 1142 if (s->bgr32) { 1143 switch (s->predictor) { 1144 case LEFT: 1145 case PLANE: 1146 decode_bgr_bitstream(s, width - 1); 1147 s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4, 1148 s->temp[0], width - 1, left); 1149 1150 for (y = height - 2; y >= 0; y--) { // Yes it is stored upside down. 1151 decode_bgr_bitstream(s, width); 1152 1153 s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * (y + y_offset), 1154 s->temp[0], width, left); 1155 if (s->predictor == PLANE) { 1156 if (s->bitstream_bpp != 32) 1157 left[A] = 0; 1158 if (y < height - 1 - s->interlaced) { 1159 s->llviddsp.add_bytes(p->data[0] + p->linesize[0] * (y + y_offset), 1160 p->data[0] + p->linesize[0] * (y + y_offset) + 1161 fake_ystride, 4 * width); 1162 } 1163 } 1164 } 1165 // just 1 large slice as this is not possible in reverse order 1166 draw_slice(s, p, height); 1167 break; 1168 default: 1169 av_log(avctx, AV_LOG_ERROR, 1170 "prediction type not supported!\n"); 1171 } 1172 } else { 1173 av_log(avctx, AV_LOG_ERROR, 1174 "BGR24 output is not implemented yet\n"); 1175 return AVERROR_PATCHWELCOME; 1176 } 1177 } 1178 1179 return 0; 1180} 1181 1182static int decode_frame(AVCodecContext *avctx, AVFrame *p, 1183 int *got_frame, AVPacket *avpkt) 1184{ 1185 const uint8_t *buf = avpkt->data; 1186 int buf_size = avpkt->size; 1187 HYuvContext *s = avctx->priv_data; 1188 const int width = s->width; 1189 const int height = s->height; 1190 int slice, table_size = 0, ret, nb_slices; 1191 unsigned slices_info_offset; 1192 int slice_height; 1193 1194 if (buf_size < (width * height + 7)/8) 1195 return AVERROR_INVALIDDATA; 1196 1197 av_fast_padded_malloc(&s->bitstream_buffer, 1198 &s->bitstream_buffer_size, 1199 buf_size); 1200 if (!s->bitstream_buffer) 1201 return AVERROR(ENOMEM); 1202 1203 s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer, 1204 (const uint32_t *) buf, buf_size / 4); 1205 1206 if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0) 1207 return ret; 1208 1209 if (s->context) { 1210 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size); 1211 if (table_size < 0) 1212 return table_size; 1213 } 1214 1215 if ((unsigned) (buf_size - table_size) >= INT_MAX / 8) 1216 return AVERROR_INVALIDDATA; 1217 1218 s->last_slice_end = 0; 1219 1220 if (avctx->codec_id == AV_CODEC_ID_HYMT && 1221 (buf_size > 32 && AV_RL32(avpkt->data + buf_size - 16) == 0)) { 1222 slices_info_offset = AV_RL32(avpkt->data + buf_size - 4); 1223 slice_height = AV_RL32(avpkt->data + buf_size - 8); 1224 nb_slices = AV_RL32(avpkt->data + buf_size - 12); 1225 if (nb_slices * 8LL + slices_info_offset > buf_size - 16 || 1226 s->chroma_v_shift || 1227 slice_height <= 0 || nb_slices * (uint64_t)slice_height > height) 1228 return AVERROR_INVALIDDATA; 1229 } else { 1230 slice_height = height; 1231 nb_slices = 1; 1232 } 1233 1234 for (slice = 0; slice < nb_slices; slice++) { 1235 int y_offset, slice_offset, slice_size; 1236 1237 if (nb_slices > 1) { 1238 slice_offset = AV_RL32(avpkt->data + slices_info_offset + slice * 8); 1239 slice_size = AV_RL32(avpkt->data + slices_info_offset + slice * 8 + 4); 1240 1241 if (slice_offset < 0 || slice_size <= 0 || (slice_offset&3) || 1242 slice_offset + (int64_t)slice_size > buf_size) 1243 return AVERROR_INVALIDDATA; 1244 1245 y_offset = height - (slice + 1) * slice_height; 1246 s->bdsp.bswap_buf((uint32_t *)s->bitstream_buffer, 1247 (const uint32_t *)(buf + slice_offset), slice_size / 4); 1248 } else { 1249 y_offset = 0; 1250 slice_offset = 0; 1251 slice_size = buf_size; 1252 } 1253 1254 ret = decode_slice(avctx, p, slice_height, slice_size, y_offset, table_size); 1255 emms_c(); 1256 if (ret < 0) 1257 return ret; 1258 } 1259 1260 *got_frame = 1; 1261 1262 return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size; 1263} 1264 1265const FFCodec ff_huffyuv_decoder = { 1266 .p.name = "huffyuv", 1267 .p.long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"), 1268 .p.type = AVMEDIA_TYPE_VIDEO, 1269 .p.id = AV_CODEC_ID_HUFFYUV, 1270 .priv_data_size = sizeof(HYuvContext), 1271 .init = decode_init, 1272 .close = decode_end, 1273 FF_CODEC_DECODE_CB(decode_frame), 1274 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND | 1275 AV_CODEC_CAP_FRAME_THREADS, 1276 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 1277}; 1278 1279#if CONFIG_FFVHUFF_DECODER 1280const FFCodec ff_ffvhuff_decoder = { 1281 .p.name = "ffvhuff", 1282 .p.long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"), 1283 .p.type = AVMEDIA_TYPE_VIDEO, 1284 .p.id = AV_CODEC_ID_FFVHUFF, 1285 .priv_data_size = sizeof(HYuvContext), 1286 .init = decode_init, 1287 .close = decode_end, 1288 FF_CODEC_DECODE_CB(decode_frame), 1289 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND | 1290 AV_CODEC_CAP_FRAME_THREADS, 1291 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 1292}; 1293#endif /* CONFIG_FFVHUFF_DECODER */ 1294 1295#if CONFIG_HYMT_DECODER 1296const FFCodec ff_hymt_decoder = { 1297 .p.name = "hymt", 1298 .p.long_name = NULL_IF_CONFIG_SMALL("HuffYUV MT"), 1299 .p.type = AVMEDIA_TYPE_VIDEO, 1300 .p.id = AV_CODEC_ID_HYMT, 1301 .priv_data_size = sizeof(HYuvContext), 1302 .init = decode_init, 1303 .close = decode_end, 1304 FF_CODEC_DECODE_CB(decode_frame), 1305 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND | 1306 AV_CODEC_CAP_FRAME_THREADS, 1307 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 1308}; 1309#endif /* CONFIG_HYMT_DECODER */ 1310