1/* 2 * Lagarith lossless decoder 3 * Copyright (c) 2009 Nathan Caldwell <saintdev (at) gmail.com> 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 */ 21 22/** 23 * @file 24 * Lagarith lossless decoder 25 * @author Nathan Caldwell 26 */ 27 28#include <inttypes.h> 29 30#include "avcodec.h" 31#include "codec_internal.h" 32#include "get_bits.h" 33#include "mathops.h" 34#include "lagarithrac.h" 35#include "lossless_videodsp.h" 36#include "thread.h" 37 38enum LagarithFrameType { 39 FRAME_RAW = 1, /**< uncompressed */ 40 FRAME_U_RGB24 = 2, /**< unaligned RGB24 */ 41 FRAME_ARITH_YUY2 = 3, /**< arithmetic coded YUY2 */ 42 FRAME_ARITH_RGB24 = 4, /**< arithmetic coded RGB24 */ 43 FRAME_SOLID_GRAY = 5, /**< solid grayscale color frame */ 44 FRAME_SOLID_COLOR = 6, /**< solid non-grayscale color frame */ 45 FRAME_OLD_ARITH_RGB = 7, /**< obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) */ 46 FRAME_ARITH_RGBA = 8, /**< arithmetic coded RGBA */ 47 FRAME_SOLID_RGBA = 9, /**< solid RGBA color frame */ 48 FRAME_ARITH_YV12 = 10, /**< arithmetic coded YV12 */ 49 FRAME_REDUCED_RES = 11, /**< reduced resolution YV12 frame */ 50}; 51 52typedef struct LagarithContext { 53 AVCodecContext *avctx; 54 LLVidDSPContext llviddsp; 55 int zeros; /**< number of consecutive zero bytes encountered */ 56 int zeros_rem; /**< number of zero bytes remaining to output */ 57} LagarithContext; 58 59/** 60 * Compute the 52-bit mantissa of 1/(double)denom. 61 * This crazy format uses floats in an entropy coder and we have to match x86 62 * rounding exactly, thus ordinary floats aren't portable enough. 63 * @param denom denominator 64 * @return 52-bit mantissa 65 * @see softfloat_mul 66 */ 67static uint64_t softfloat_reciprocal(uint32_t denom) 68{ 69 int shift = av_log2(denom - 1) + 1; 70 uint64_t ret = (1ULL << 52) / denom; 71 uint64_t err = (1ULL << 52) - ret * denom; 72 ret <<= shift; 73 err <<= shift; 74 err += denom / 2; 75 return ret + err / denom; 76} 77 78/** 79 * (uint32_t)(x*f), where f has the given mantissa, and exponent 0 80 * Used in combination with softfloat_reciprocal computes x/(double)denom. 81 * @param x 32-bit integer factor 82 * @param mantissa mantissa of f with exponent 0 83 * @return 32-bit integer value (x*f) 84 * @see softfloat_reciprocal 85 */ 86static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa) 87{ 88 uint64_t l = x * (mantissa & 0xffffffff); 89 uint64_t h = x * (mantissa >> 32); 90 h += l >> 32; 91 l &= 0xffffffff; 92 l += 1LL << av_log2(h >> 21); 93 h += l >> 32; 94 return h >> 20; 95} 96 97static uint8_t lag_calc_zero_run(int8_t x) 98{ 99 return (x * 2) ^ (x >> 7); 100} 101 102static int lag_decode_prob(GetBitContext *gb, uint32_t *value) 103{ 104 static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 }; 105 int i; 106 int bit = 0; 107 int bits = 0; 108 int prevbit = 0; 109 unsigned val; 110 111 for (i = 0; i < 7; i++) { 112 if (prevbit && bit) 113 break; 114 prevbit = bit; 115 bit = get_bits1(gb); 116 if (bit && !prevbit) 117 bits += series[i]; 118 } 119 bits--; 120 if (bits < 0 || bits > 31) { 121 *value = 0; 122 return AVERROR_INVALIDDATA; 123 } else if (bits == 0) { 124 *value = 0; 125 return 0; 126 } 127 128 val = get_bits_long(gb, bits); 129 val |= 1U << bits; 130 131 *value = val - 1; 132 133 return 0; 134} 135 136static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb) 137{ 138 int i, j, scale_factor; 139 unsigned prob, cumulative_target; 140 unsigned cumul_prob = 0; 141 unsigned scaled_cumul_prob = 0; 142 int nnz = 0; 143 144 rac->prob[0] = 0; 145 rac->prob[257] = UINT_MAX; 146 /* Read probabilities from bitstream */ 147 for (i = 1; i < 257; i++) { 148 if (lag_decode_prob(gb, &rac->prob[i]) < 0) { 149 av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability encountered.\n"); 150 return AVERROR_INVALIDDATA; 151 } 152 if ((uint64_t)cumul_prob + rac->prob[i] > UINT_MAX) { 153 av_log(rac->avctx, AV_LOG_ERROR, "Integer overflow encountered in cumulative probability calculation.\n"); 154 return AVERROR_INVALIDDATA; 155 } 156 cumul_prob += rac->prob[i]; 157 if (!rac->prob[i]) { 158 if (lag_decode_prob(gb, &prob)) { 159 av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability run encountered.\n"); 160 return AVERROR_INVALIDDATA; 161 } 162 if (prob > 256 - i) 163 prob = 256 - i; 164 for (j = 0; j < prob; j++) 165 rac->prob[++i] = 0; 166 }else { 167 nnz++; 168 } 169 } 170 171 if (!cumul_prob) { 172 av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n"); 173 return AVERROR_INVALIDDATA; 174 } 175 176 if (nnz == 1 && (show_bits_long(gb, 32) & 0xFFFFFF)) { 177 return AVERROR_INVALIDDATA; 178 } 179 180 /* Scale probabilities so cumulative probability is an even power of 2. */ 181 scale_factor = av_log2(cumul_prob); 182 183 if (cumul_prob & (cumul_prob - 1)) { 184 uint64_t mul = softfloat_reciprocal(cumul_prob); 185 for (i = 1; i <= 128; i++) { 186 rac->prob[i] = softfloat_mul(rac->prob[i], mul); 187 scaled_cumul_prob += rac->prob[i]; 188 } 189 if (scaled_cumul_prob <= 0) { 190 av_log(rac->avctx, AV_LOG_ERROR, "Scaled probabilities invalid\n"); 191 return AVERROR_INVALIDDATA; 192 } 193 for (; i < 257; i++) { 194 rac->prob[i] = softfloat_mul(rac->prob[i], mul); 195 scaled_cumul_prob += rac->prob[i]; 196 } 197 198 scale_factor++; 199 if (scale_factor >= 32U) 200 return AVERROR_INVALIDDATA; 201 cumulative_target = 1U << scale_factor; 202 203 if (scaled_cumul_prob > cumulative_target) { 204 av_log(rac->avctx, AV_LOG_ERROR, 205 "Scaled probabilities are larger than target!\n"); 206 return AVERROR_INVALIDDATA; 207 } 208 209 scaled_cumul_prob = cumulative_target - scaled_cumul_prob; 210 211 for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) { 212 if (rac->prob[i]) { 213 rac->prob[i]++; 214 scaled_cumul_prob--; 215 } 216 /* Comment from reference source: 217 * if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way 218 * // since the compression change is negligible and fixing it 219 * // breaks backwards compatibility 220 * b =- (signed int)b; 221 * b &= 0xFF; 222 * } else { 223 * b++; 224 * b &= 0x7f; 225 * } 226 */ 227 } 228 } 229 230 if (scale_factor > 23) 231 return AVERROR_INVALIDDATA; 232 233 rac->scale = scale_factor; 234 235 /* Fill probability array with cumulative probability for each symbol. */ 236 for (i = 1; i < 257; i++) 237 rac->prob[i] += rac->prob[i - 1]; 238 239 return 0; 240} 241 242static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1, 243 uint8_t *diff, int w, int *left, 244 int *left_top) 245{ 246 /* This is almost identical to add_hfyu_median_pred in huffyuvdsp.h. 247 * However the &0xFF on the gradient predictor yields incorrect output 248 * for lagarith. 249 */ 250 int i; 251 uint8_t l, lt; 252 253 l = *left; 254 lt = *left_top; 255 256 for (i = 0; i < w; i++) { 257 l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i]; 258 lt = src1[i]; 259 dst[i] = l; 260 } 261 262 *left = l; 263 *left_top = lt; 264} 265 266static void lag_pred_line(LagarithContext *l, uint8_t *buf, 267 int width, int stride, int line) 268{ 269 int L, TL; 270 271 if (!line) { 272 /* Left prediction only for first line */ 273 L = l->llviddsp.add_left_pred(buf, buf, width, 0); 274 } else { 275 /* Left pixel is actually prev_row[width] */ 276 L = buf[width - stride - 1]; 277 278 if (line == 1) { 279 /* Second line, left predict first pixel, the rest of the line is median predicted 280 * NOTE: In the case of RGB this pixel is top predicted */ 281 TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L; 282 } else { 283 /* Top left is 2 rows back, last pixel */ 284 TL = buf[width - (2 * stride) - 1]; 285 } 286 287 add_lag_median_prediction(buf, buf - stride, buf, 288 width, &L, &TL); 289 } 290} 291 292static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf, 293 int width, int stride, int line, 294 int is_luma) 295{ 296 int L, TL; 297 298 if (!line) { 299 L= buf[0]; 300 if (is_luma) 301 buf[0] = 0; 302 l->llviddsp.add_left_pred(buf, buf, width, 0); 303 if (is_luma) 304 buf[0] = L; 305 return; 306 } 307 if (line == 1) { 308 const int HEAD = is_luma ? 4 : 2; 309 int i; 310 311 L = buf[width - stride - 1]; 312 TL = buf[HEAD - stride - 1]; 313 for (i = 0; i < HEAD; i++) { 314 L += buf[i]; 315 buf[i] = L; 316 } 317 for (; i < width; i++) { 318 L = mid_pred(L & 0xFF, buf[i - stride], (L + buf[i - stride] - TL) & 0xFF) + buf[i]; 319 TL = buf[i - stride]; 320 buf[i] = L; 321 } 322 } else { 323 TL = buf[width - (2 * stride) - 1]; 324 L = buf[width - stride - 1]; 325 l->llviddsp.add_median_pred(buf, buf - stride, buf, width, &L, &TL); 326 } 327} 328 329static int lag_decode_line(LagarithContext *l, lag_rac *rac, 330 uint8_t *dst, int width, int stride, 331 int esc_count) 332{ 333 int i = 0; 334 int ret = 0; 335 336 if (!esc_count) 337 esc_count = -1; 338 339 /* Output any zeros remaining from the previous run */ 340handle_zeros: 341 if (l->zeros_rem) { 342 int count = FFMIN(l->zeros_rem, width - i); 343 memset(dst + i, 0, count); 344 i += count; 345 l->zeros_rem -= count; 346 } 347 348 while (i < width) { 349 dst[i] = lag_get_rac(rac); 350 ret++; 351 352 if (dst[i]) 353 l->zeros = 0; 354 else 355 l->zeros++; 356 357 i++; 358 if (l->zeros == esc_count) { 359 int index = lag_get_rac(rac); 360 ret++; 361 362 l->zeros = 0; 363 364 l->zeros_rem = lag_calc_zero_run(index); 365 goto handle_zeros; 366 } 367 } 368 return ret; 369} 370 371static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst, 372 const uint8_t *src, const uint8_t *src_end, 373 int width, int esc_count) 374{ 375 int i = 0; 376 int count; 377 uint8_t zero_run = 0; 378 const uint8_t *src_start = src; 379 uint8_t mask1 = -(esc_count < 2); 380 uint8_t mask2 = -(esc_count < 3); 381 uint8_t *end = dst + (width - 2); 382 383 avpriv_request_sample(l->avctx, "zero_run_line"); 384 385 memset(dst, 0, width); 386 387output_zeros: 388 if (l->zeros_rem) { 389 count = FFMIN(l->zeros_rem, width - i); 390 if (end - dst < count) { 391 av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n"); 392 return AVERROR_INVALIDDATA; 393 } 394 395 memset(dst, 0, count); 396 l->zeros_rem -= count; 397 dst += count; 398 } 399 400 while (dst < end) { 401 i = 0; 402 while (!zero_run && dst + i < end) { 403 i++; 404 if (i+2 >= src_end - src) 405 return AVERROR_INVALIDDATA; 406 zero_run = 407 !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2)); 408 } 409 if (zero_run) { 410 zero_run = 0; 411 i += esc_count; 412 if (i > end - dst || 413 i >= src_end - src) 414 return AVERROR_INVALIDDATA; 415 memcpy(dst, src, i); 416 dst += i; 417 l->zeros_rem = lag_calc_zero_run(src[i]); 418 419 src += i + 1; 420 goto output_zeros; 421 } else { 422 memcpy(dst, src, i); 423 src += i; 424 dst += i; 425 } 426 } 427 return src - src_start; 428} 429 430 431 432static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst, 433 int width, int height, int stride, 434 const uint8_t *src, int src_size) 435{ 436 int i = 0; 437 int read = 0; 438 uint32_t length; 439 uint32_t offset = 1; 440 int esc_count; 441 GetBitContext gb; 442 lag_rac rac; 443 const uint8_t *src_end = src + src_size; 444 int ret; 445 446 rac.avctx = l->avctx; 447 l->zeros = 0; 448 449 if(src_size < 2) 450 return AVERROR_INVALIDDATA; 451 452 esc_count = src[0]; 453 if (esc_count < 4) { 454 length = width * height; 455 if(src_size < 5) 456 return AVERROR_INVALIDDATA; 457 if (esc_count && AV_RL32(src + 1) < length) { 458 length = AV_RL32(src + 1); 459 offset += 4; 460 } 461 462 if ((ret = init_get_bits8(&gb, src + offset, src_size - offset)) < 0) 463 return ret; 464 465 if ((ret = lag_read_prob_header(&rac, &gb)) < 0) 466 return ret; 467 468 ff_lag_rac_init(&rac, &gb, length - stride); 469 for (i = 0; i < height; i++) { 470 if (rac.overread > MAX_OVERREAD) 471 return AVERROR_INVALIDDATA; 472 read += lag_decode_line(l, &rac, dst + (i * stride), width, 473 stride, esc_count); 474 } 475 476 if (read > length) 477 av_log(l->avctx, AV_LOG_WARNING, 478 "Output more bytes than length (%d of %"PRIu32")\n", read, 479 length); 480 } else if (esc_count < 8) { 481 esc_count -= 4; 482 src ++; 483 src_size --; 484 if (esc_count > 0) { 485 /* Zero run coding only, no range coding. */ 486 for (i = 0; i < height; i++) { 487 int res = lag_decode_zero_run_line(l, dst + (i * stride), src, 488 src_end, width, esc_count); 489 if (res < 0) 490 return res; 491 src += res; 492 } 493 } else { 494 if (src_size < width * height) 495 return AVERROR_INVALIDDATA; // buffer not big enough 496 /* Plane is stored uncompressed */ 497 for (i = 0; i < height; i++) { 498 memcpy(dst + (i * stride), src, width); 499 src += width; 500 } 501 } 502 } else if (esc_count == 0xff) { 503 /* Plane is a solid run of given value */ 504 for (i = 0; i < height; i++) 505 memset(dst + i * stride, src[1], width); 506 /* Do not apply prediction. 507 Note: memset to 0 above, setting first value to src[1] 508 and applying prediction gives the same result. */ 509 return 0; 510 } else { 511 av_log(l->avctx, AV_LOG_ERROR, 512 "Invalid zero run escape code! (%#x)\n", esc_count); 513 return AVERROR_INVALIDDATA; 514 } 515 516 if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) { 517 for (i = 0; i < height; i++) { 518 lag_pred_line(l, dst, width, stride, i); 519 dst += stride; 520 } 521 } else { 522 for (i = 0; i < height; i++) { 523 lag_pred_line_yuy2(l, dst, width, stride, i, 524 width == l->avctx->width); 525 dst += stride; 526 } 527 } 528 529 return 0; 530} 531 532/** 533 * Decode a frame. 534 * @param avctx codec context 535 * @param data output AVFrame 536 * @param data_size size of output data or 0 if no picture is returned 537 * @param avpkt input packet 538 * @return number of consumed bytes on success or negative if decode fails 539 */ 540static int lag_decode_frame(AVCodecContext *avctx, AVFrame *p, 541 int *got_frame, AVPacket *avpkt) 542{ 543 const uint8_t *buf = avpkt->data; 544 unsigned int buf_size = avpkt->size; 545 LagarithContext *l = avctx->priv_data; 546 uint8_t frametype; 547 uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9; 548 uint32_t offs[4]; 549 uint8_t *srcs[4]; 550 int i, j, planes = 3; 551 int ret = 0; 552 553 p->key_frame = 1; 554 p->pict_type = AV_PICTURE_TYPE_I; 555 556 frametype = buf[0]; 557 558 offset_gu = AV_RL32(buf + 1); 559 offset_bv = AV_RL32(buf + 5); 560 561 switch (frametype) { 562 case FRAME_SOLID_RGBA: 563 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 564 case FRAME_SOLID_GRAY: 565 if (frametype == FRAME_SOLID_GRAY) 566 if (avctx->bits_per_coded_sample == 24) { 567 avctx->pix_fmt = AV_PIX_FMT_GBRP; 568 } else { 569 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 570 planes = 4; 571 } 572 573 if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0) 574 return ret; 575 576 if (frametype == FRAME_SOLID_RGBA) { 577 for (i = 0; i < avctx->height; i++) { 578 memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width); 579 memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width); 580 memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width); 581 memset(p->data[3] + i * p->linesize[3], buf[4], avctx->width); 582 } 583 } else { 584 for (i = 0; i < avctx->height; i++) { 585 for (j = 0; j < planes; j++) 586 memset(p->data[j] + i * p->linesize[j], buf[1], avctx->width); 587 } 588 } 589 break; 590 case FRAME_SOLID_COLOR: 591 if (avctx->bits_per_coded_sample == 24) { 592 avctx->pix_fmt = AV_PIX_FMT_GBRP; 593 } else { 594 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 595 } 596 597 if ((ret = ff_thread_get_buffer(avctx, p,0)) < 0) 598 return ret; 599 600 for (i = 0; i < avctx->height; i++) { 601 memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width); 602 memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width); 603 memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width); 604 if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) 605 memset(p->data[3] + i * p->linesize[3], 0xFFu, avctx->width); 606 } 607 break; 608 case FRAME_ARITH_RGBA: 609 avctx->pix_fmt = AV_PIX_FMT_GBRAP; 610 planes = 4; 611 offset_ry += 4; 612 offs[3] = AV_RL32(buf + 9); 613 case FRAME_ARITH_RGB24: 614 case FRAME_U_RGB24: 615 if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24) 616 avctx->pix_fmt = AV_PIX_FMT_GBRP; 617 618 if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0) 619 return ret; 620 621 offs[0] = offset_bv; 622 offs[1] = offset_gu; 623 offs[2] = offset_ry; 624 625 for (i = 0; i < planes; i++) 626 srcs[i] = p->data[i] + (avctx->height - 1) * p->linesize[i]; 627 for (i = 0; i < planes; i++) 628 if (buf_size <= offs[i]) { 629 av_log(avctx, AV_LOG_ERROR, 630 "Invalid frame offsets\n"); 631 return AVERROR_INVALIDDATA; 632 } 633 634 for (i = 0; i < planes; i++) { 635 ret = lag_decode_arith_plane(l, srcs[i], 636 avctx->width, avctx->height, 637 -p->linesize[i], buf + offs[i], 638 buf_size - offs[i]); 639 if (ret < 0) 640 return ret; 641 } 642 for (i = 0; i < avctx->height; i++) { 643 l->llviddsp.add_bytes(p->data[0] + i * p->linesize[0], p->data[1] + i * p->linesize[1], avctx->width); 644 l->llviddsp.add_bytes(p->data[2] + i * p->linesize[2], p->data[1] + i * p->linesize[1], avctx->width); 645 } 646 FFSWAP(uint8_t*, p->data[0], p->data[1]); 647 FFSWAP(int, p->linesize[0], p->linesize[1]); 648 FFSWAP(uint8_t*, p->data[2], p->data[1]); 649 FFSWAP(int, p->linesize[2], p->linesize[1]); 650 break; 651 case FRAME_ARITH_YUY2: 652 avctx->pix_fmt = AV_PIX_FMT_YUV422P; 653 654 if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0) 655 return ret; 656 657 if (offset_ry >= buf_size || 658 offset_gu >= buf_size || 659 offset_bv >= buf_size) { 660 av_log(avctx, AV_LOG_ERROR, 661 "Invalid frame offsets\n"); 662 return AVERROR_INVALIDDATA; 663 } 664 665 ret = lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height, 666 p->linesize[0], buf + offset_ry, 667 buf_size - offset_ry); 668 if (ret < 0) 669 return ret; 670 ret = lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2, 671 avctx->height, p->linesize[1], 672 buf + offset_gu, buf_size - offset_gu); 673 if (ret < 0) 674 return ret; 675 ret = lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2, 676 avctx->height, p->linesize[2], 677 buf + offset_bv, buf_size - offset_bv); 678 break; 679 case FRAME_ARITH_YV12: 680 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 681 682 if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0) 683 return ret; 684 685 if (offset_ry >= buf_size || 686 offset_gu >= buf_size || 687 offset_bv >= buf_size) { 688 av_log(avctx, AV_LOG_ERROR, 689 "Invalid frame offsets\n"); 690 return AVERROR_INVALIDDATA; 691 } 692 693 ret = lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height, 694 p->linesize[0], buf + offset_ry, 695 buf_size - offset_ry); 696 if (ret < 0) 697 return ret; 698 ret = lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2, 699 (avctx->height + 1) / 2, p->linesize[2], 700 buf + offset_gu, buf_size - offset_gu); 701 if (ret < 0) 702 return ret; 703 ret = lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2, 704 (avctx->height + 1) / 2, p->linesize[1], 705 buf + offset_bv, buf_size - offset_bv); 706 break; 707 default: 708 av_log(avctx, AV_LOG_ERROR, 709 "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype); 710 return AVERROR_PATCHWELCOME; 711 } 712 713 if (ret < 0) 714 return ret; 715 716 *got_frame = 1; 717 718 return buf_size; 719} 720 721static av_cold int lag_decode_init(AVCodecContext *avctx) 722{ 723 LagarithContext *l = avctx->priv_data; 724 l->avctx = avctx; 725 726 ff_llviddsp_init(&l->llviddsp); 727 728 return 0; 729} 730 731const FFCodec ff_lagarith_decoder = { 732 .p.name = "lagarith", 733 .p.long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"), 734 .p.type = AVMEDIA_TYPE_VIDEO, 735 .p.id = AV_CODEC_ID_LAGARITH, 736 .priv_data_size = sizeof(LagarithContext), 737 .init = lag_decode_init, 738 FF_CODEC_DECODE_CB(lag_decode_frame), 739 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, 740 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 741}; 742