FFmpeg: libavcodec/lagarith.c Source File

FFmpeg

[フレーム]

libavcodec

lagarith.c

Go to the documentation of this file.

1 /*

2 * Lagarith lossless decoder

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 */

22 /**

23 * @file

24 * Lagarith lossless decoder

25 * @author Nathan Caldwell

26 */

28 #include <inttypes.h>

30 #include "avcodec.h"

31 #include "get_bits.h"

32 #include "mathops.h"

33 #include "lagarithrac.h"

34 #include "lossless_videodsp.h"

35 #include "thread.h"

37 enum LagarithFrameType {

38 FRAME_RAW = 1, /**< uncompressed */

39 FRAME_U_RGB24 = 2, /**< unaligned RGB24 */

40 FRAME_ARITH_YUY2 = 3, /**< arithmetic coded YUY2 */

41 FRAME_ARITH_RGB24 = 4, /**< arithmetic coded RGB24 */

42 FRAME_SOLID_GRAY = 5, /**< solid grayscale color frame */

43 FRAME_SOLID_COLOR = 6, /**< solid non-grayscale color frame */

44 FRAME_OLD_ARITH_RGB = 7, /**< obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) */

45 FRAME_ARITH_RGBA = 8, /**< arithmetic coded RGBA */

46 FRAME_SOLID_RGBA = 9, /**< solid RGBA color frame */

47 FRAME_ARITH_YV12 = 10, /**< arithmetic coded YV12 */

48 FRAME_REDUCED_RES = 11, /**< reduced resolution YV12 frame */

49 };

51 typedef struct LagarithContext {

52 AVCodecContext *avctx;

53 LLVidDSPContext llviddsp;

54 int zeros; /**< number of consecutive zero bytes encountered */

55 int zeros_rem; /**< number of zero bytes remaining to output */

56 uint8_t *rgb_planes;

57 int rgb_planes_allocated;

58 int rgb_stride;

59 } LagarithContext;

61 /**

62 * Compute the 52-bit mantissa of 1/(double)denom.

63 * This crazy format uses floats in an entropy coder and we have to match x86

64 * rounding exactly, thus ordinary floats aren't portable enough.

65 * @param denom denominator

66 * @return 52-bit mantissa

67 * @see softfloat_mul

68 */

69 static uint64_t softfloat_reciprocal(uint32_t denom)

70 {

71 int shift = av_log2(denom - 1) + 1;

72 uint64_t ret = (1ULL << 52) / denom;

73 uint64_t err = (1ULL << 52) - ret * denom;

74 ret <<= shift;

75 err <<= shift;

76 err += denom / 2;

77 return ret + err / denom;

78 }

80 /**

81 * (uint32_t)(x*f), where f has the given mantissa, and exponent 0

82 * Used in combination with softfloat_reciprocal computes x/(double)denom.

83 * @param x 32-bit integer factor

84 * @param mantissa mantissa of f with exponent 0

85 * @return 32-bit integer value (x*f)

86 * @see softfloat_reciprocal

87 */

88 static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)

89 {

90 uint64_t l = x * (mantissa & 0xffffffff);

91 uint64_t h = x * (mantissa >> 32);

92 h += l >> 32;

93 l &= 0xffffffff;

94 l += 1LL << av_log2(h >> 21);

95 h += l >> 32;

96 return h >> 20;

97 }

99 static uint8_t lag_calc_zero_run(int8_t x)

100 {

101 return (x * 2) ^ (x >> 7);

102 }

103

104 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)

105 {

106 static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 };

107 int i;

108 int bit = 0;

109 int bits = 0;

110 int prevbit = 0;

111 unsigned val;

112

113 for (i = 0; i < 7; i++) {

114 if (prevbit && bit)

115 break;

116 prevbit = bit;

117 bit = get_bits1(gb);

118 if (bit && !prevbit)

119 bits += series[i];

120 }

121 bits--;

122 if (bits < 0 || bits > 31) {

123 *value = 0;

124 return -1;

125 } else if (bits == 0) {

126 *value = 0;

127 return 0;

128 }

129

130 val = get_bits_long(gb, bits);

131 val |= 1U << bits;

132

133 *value = val - 1;

134

135 return 0;

136 }

137

138 static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)

139 {

140 int i, j, scale_factor;

141 unsigned prob, cumulative_target;

142 unsigned cumul_prob = 0;

143 unsigned scaled_cumul_prob = 0;

144

145 rac->prob[0] = 0;

146 rac->prob[257] = UINT_MAX;

147 /* Read probabilities from bitstream */

148 for (i = 1; i < 257; i++) {

149 if (lag_decode_prob(gb, &rac->prob[i]) < 0) {

150 av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability encountered.\n");

151 return -1;

152 }

153 if ((uint64_t)cumul_prob + rac->prob[i] > UINT_MAX) {

154 av_log(rac->avctx, AV_LOG_ERROR, "Integer overflow encountered in cumulative probability calculation.\n");

155 return -1;

156 }

157 cumul_prob += rac->prob[i];

158 if (!rac->prob[i]) {

159 if (lag_decode_prob(gb, &prob)) {

160 av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability run encountered.\n");

161 return -1;

162 }

163 if (prob > 256 - i)

164 prob = 256 - i;

165 for (j = 0; j < prob; j++)

166 rac->prob[++i] = 0;

167 }

168 }

169

170 if (!cumul_prob) {

171 av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n");

172 return -1;

173 }

174

175 /* Scale probabilities so cumulative probability is an even power of 2. */

176 scale_factor = av_log2(cumul_prob);

177

178 if (cumul_prob & (cumul_prob - 1)) {

179 uint64_t mul = softfloat_reciprocal(cumul_prob);

180 for (i = 1; i <= 128; i++) {

181 rac->prob[i] = softfloat_mul(rac->prob[i], mul);

182 scaled_cumul_prob += rac->prob[i];

183 }

184 if (scaled_cumul_prob <= 0) {

185 av_log(rac->avctx, AV_LOG_ERROR, "Scaled probabilities invalid\n");

186 return AVERROR_INVALIDDATA;

187 }

188 for (; i < 257; i++) {

189 rac->prob[i] = softfloat_mul(rac->prob[i], mul);

190 scaled_cumul_prob += rac->prob[i];

191 }

192

193 scale_factor++;

194 if (scale_factor >= 32U)

195 return AVERROR_INVALIDDATA;

196 cumulative_target = 1U << scale_factor;

197

198 if (scaled_cumul_prob > cumulative_target) {

199 av_log(rac->avctx, AV_LOG_ERROR,

200 "Scaled probabilities are larger than target!\n");

201 return -1;

202 }

203

204 scaled_cumul_prob = cumulative_target - scaled_cumul_prob;

205

206 for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) {

207 if (rac->prob[i]) {

208 rac->prob[i]++;

209 scaled_cumul_prob--;

210 }

211 /* Comment from reference source:

212 * if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way

213 * // since the compression change is negligible and fixing it

214 * // breaks backwards compatibility

215 * b =- (signed int)b;

216 * b &= 0xFF;

217 * } else {

218 * b++;

219 * b &= 0x7f;

220 * }

221 */

222 }

223 }

224

225 rac->scale = scale_factor;

226

227 /* Fill probability array with cumulative probability for each symbol. */

228 for (i = 1; i < 257; i++)

229 rac->prob[i] += rac->prob[i - 1];

230

231 return 0;

232 }

233

234 static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1,

235 uint8_t *diff, int w, int *left,

236 int *left_top)

237 {

238 /* This is almost identical to add_hfyu_median_pred in huffyuvdsp.h.

239 * However the &0xFF on the gradient predictor yields incorrect output

240 * for lagarith.

241 */

242 int i;

243 uint8_t l, lt;

244

245 l = *left;

246 lt = *left_top;

247

248 for (i = 0; i < w; i++) {

249 l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i];

250 lt = src1[i];

251 dst[i] = l;

252 }

253

254 *left = l;

255 *left_top = lt;

256 }

257

258 static void lag_pred_line(LagarithContext *l, uint8_t *buf,

259 int width, int stride, int line)

260 {

261 int L, TL;

262

263 if (!line) {

264 /* Left prediction only for first line */

265 L = l->llviddsp.add_left_pred(buf, buf, width, 0);

266 } else {

267 /* Left pixel is actually prev_row[width] */

268 L = buf[width - stride - 1];

269

270 if (line == 1) {

271 /* Second line, left predict first pixel, the rest of the line is median predicted

272 * NOTE: In the case of RGB this pixel is top predicted */

273 TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L;

274 } else {

275 /* Top left is 2 rows back, last pixel */

276 TL = buf[width - (2 * stride) - 1];

277 }

278

279 add_lag_median_prediction(buf, buf - stride, buf,

280 width, &L, &TL);

281 }

282 }

283

284 static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf,

285 int width, int stride, int line,

286 int is_luma)

287 {

288 int L, TL;

289

290 if (!line) {

291 L= buf[0];

292 if (is_luma)

293 buf[0] = 0;

294 l->llviddsp.add_left_pred(buf, buf, width, 0);

295 if (is_luma)

296 buf[0] = L;

297 return;

298 }

299 if (line == 1) {

300 const int HEAD = is_luma ? 4 : 2;

301 int i;

302

303 L = buf[width - stride - 1];

304 TL = buf[HEAD - stride - 1];

305 for (i = 0; i < HEAD; i++) {

306 L += buf[i];

307 buf[i] = L;

308 }

309 for (; i < width; i++) {

310 L = mid_pred(L & 0xFF, buf[i - stride], (L + buf[i - stride] - TL) & 0xFF) + buf[i];

311 TL = buf[i - stride];

312 buf[i] = L;

313 }

314 } else {

315 TL = buf[width - (2 * stride) - 1];

316 L = buf[width - stride - 1];

317 l->llviddsp.add_median_pred(buf, buf - stride, buf, width, &L, &TL);

318 }

319 }

320

321 static int lag_decode_line(LagarithContext *l, lag_rac *rac,

322 uint8_t *dst, int width, int stride,

323 int esc_count)

324 {

325 int i = 0;

326 int ret = 0;

327

328 if (!esc_count)

329 esc_count = -1;

330

331 /* Output any zeros remaining from the previous run */

332 handle_zeros:

333 if (l->zeros_rem) {

334 int count = FFMIN(l->zeros_rem, width - i);

335 memset(dst + i, 0, count);

336 i += count;

337 l->zeros_rem -= count;

338 }

339

340 while (i < width) {

341 dst[i] = lag_get_rac(rac);

342 ret++;

343

344 if (dst[i])

345 l->zeros = 0;

346 else

347 l->zeros++;

348

349 i++;

350 if (l->zeros == esc_count) {

351 int index = lag_get_rac(rac);

352 ret++;

353

354 l->zeros = 0;

355

356 l->zeros_rem = lag_calc_zero_run(index);

357 goto handle_zeros;

358 }

359 }

360 return ret;

361 }

362

363 static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst,

364 const uint8_t *src, const uint8_t *src_end,

365 int width, int esc_count)

366 {

367 int i = 0;

368 int count;

369 uint8_t zero_run = 0;

370 const uint8_t *src_start = src;

371 uint8_t mask1 = -(esc_count < 2);

372 uint8_t mask2 = -(esc_count < 3);

373 uint8_t *end = dst + (width - 2);

374

375 avpriv_request_sample(l->avctx, "zero_run_line");

376

377 memset(dst, 0, width);

378

379 output_zeros:

380 if (l->zeros_rem) {

381 count = FFMIN(l->zeros_rem, width - i);

382 if (end - dst < count) {

383 av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n");

384 return AVERROR_INVALIDDATA;

385 }

386

387 memset(dst, 0, count);

388 l->zeros_rem -= count;

389 dst += count;

390 }

391

392 while (dst < end) {

393 i = 0;

394 while (!zero_run && dst + i < end) {

395 i++;

396 if (i+2 >= src_end - src)

397 return AVERROR_INVALIDDATA;

398 zero_run =

399 !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));

400 }

401 if (zero_run) {

402 zero_run = 0;

403 i += esc_count;

404 memcpy(dst, src, i);

405 dst += i;

406 l->zeros_rem = lag_calc_zero_run(src[i]);

407

408 src += i + 1;

409 goto output_zeros;

410 } else {

411 memcpy(dst, src, i);

412 src += i;

413 dst += i;

414 }

415 }

416 return src - src_start;

417 }

418

419

420

421 static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,

422 int width, int height, int stride,

423 const uint8_t *src, int src_size)

424 {

425 int i = 0;

426 int read = 0;

427 uint32_t length;

428 uint32_t offset = 1;

429 int esc_count;

430 GetBitContext gb;

431 lag_rac rac;

432 const uint8_t *src_end = src + src_size;

433 int ret;

434

435 rac.avctx = l->avctx;

436 l->zeros = 0;

437

438 if(src_size < 2)

439 return AVERROR_INVALIDDATA;

440

441 esc_count = src[0];

442 if (esc_count < 4) {

443 length = width * height;

444 if(src_size < 5)

445 return AVERROR_INVALIDDATA;

446 if (esc_count && AV_RL32(src + 1) < length) {

447 length = AV_RL32(src + 1);

448 offset += 4;

449 }

450

451 if ((ret = init_get_bits8(&gb, src + offset, src_size - offset)) < 0)

452 return ret;

453

454 if (lag_read_prob_header(&rac, &gb) < 0)

455 return -1;

456

457 ff_lag_rac_init(&rac, &gb, length - stride);

458 for (i = 0; i < height; i++) {

459 if (rac.overread > MAX_OVERREAD)

460 return AVERROR_INVALIDDATA;

461 read += lag_decode_line(l, &rac, dst + (i * stride), width,

462 stride, esc_count);

463 }

464

465 if (read > length)

466 av_log(l->avctx, AV_LOG_WARNING,

467 "Output more bytes than length (%d of %"PRIu32")\n", read,

468 length);

469 } else if (esc_count < 8) {

470 esc_count -= 4;

471 src ++;

472 src_size --;

473 if (esc_count > 0) {

474 /* Zero run coding only, no range coding. */

475 for (i = 0; i < height; i++) {

476 int res = lag_decode_zero_run_line(l, dst + (i * stride), src,

477 src_end, width, esc_count);

478 if (res < 0)

479 return res;

480 src += res;

481 }

482 } else {

483 if (src_size < width * height)

484 return AVERROR_INVALIDDATA; // buffer not big enough

485 /* Plane is stored uncompressed */

486 for (i = 0; i < height; i++) {

487 memcpy(dst + (i * stride), src, width);

488 src += width;

489 }

490 }

491 } else if (esc_count == 0xff) {

492 /* Plane is a solid run of given value */

493 for (i = 0; i < height; i++)

494 memset(dst + i * stride, src[1], width);

495 /* Do not apply prediction.

496 Note: memset to 0 above, setting first value to src[1]

497 and applying prediction gives the same result. */

498 return 0;

499 } else {

500 av_log(l->avctx, AV_LOG_ERROR,

501 "Invalid zero run escape code! (%#x)\n", esc_count);

502 return -1;

503 }

504

505 if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {

506 for (i = 0; i < height; i++) {

507 lag_pred_line(l, dst, width, stride, i);

508 dst += stride;

509 }

510 } else {

511 for (i = 0; i < height; i++) {

512 lag_pred_line_yuy2(l, dst, width, stride, i,

513 width == l->avctx->width);

514 dst += stride;

515 }

516 }

517

518 return 0;

519 }

520

521 /**

522 * Decode a frame.

523 * @param avctx codec context

524 * @param data output AVFrame

525 * @param data_size size of output data or 0 if no picture is returned

526 * @param avpkt input packet

527 * @return number of consumed bytes on success or negative if decode fails

528 */

529 static int lag_decode_frame(AVCodecContext *avctx,

530 void *data, int *got_frame, AVPacket *avpkt)

531 {

532 const uint8_t *buf = avpkt->data;

533 unsigned int buf_size = avpkt->size;

534 LagarithContext *l = avctx->priv_data;

535 ThreadFrame frame = { .f = data };

536 AVFrame *const p = data;

537 uint8_t frametype = 0;

538 uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;

539 uint32_t offs[4];

540 uint8_t *srcs[4], *dst;

541 int i, j, planes = 3;

542 int ret;

543

544 p->key_frame = 1;

545

546 frametype = buf[0];

547

548 offset_gu = AV_RL32(buf + 1);

549 offset_bv = AV_RL32(buf + 5);

550

551 switch (frametype) {

552 case FRAME_SOLID_RGBA:

553 avctx->pix_fmt = AV_PIX_FMT_RGB32;

554 case FRAME_SOLID_GRAY:

555 if (frametype == FRAME_SOLID_GRAY)

556 if (avctx->bits_per_coded_sample == 24) {

557 avctx->pix_fmt = AV_PIX_FMT_RGB24;

558 } else {

559 avctx->pix_fmt = AV_PIX_FMT_0RGB32;

560 planes = 4;

561 }

562

563 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

564 return ret;

565

566 dst = p->data[0];

567 if (frametype == FRAME_SOLID_RGBA) {

568 for (j = 0; j < avctx->height; j++) {

569 for (i = 0; i < avctx->width; i++)

570 AV_WN32(dst + i * 4, offset_gu);

571 dst += p->linesize[0];

572 }

573 } else {

574 for (j = 0; j < avctx->height; j++) {

575 memset(dst, buf[1], avctx->width * planes);

576 dst += p->linesize[0];

577 }

578 }

579 break;

580 case FRAME_SOLID_COLOR:

581 if (avctx->bits_per_coded_sample == 24) {

582 avctx->pix_fmt = AV_PIX_FMT_RGB24;

583 } else {

584 avctx->pix_fmt = AV_PIX_FMT_RGB32;

585 offset_gu |= 0xFFU << 24;

586 }

587

588 if ((ret = ff_thread_get_buffer(avctx, &frame,0)) < 0)

589 return ret;

590

591 dst = p->data[0];

592 for (j = 0; j < avctx->height; j++) {

593 for (i = 0; i < avctx->width; i++)

594 if (avctx->bits_per_coded_sample == 24) {

595 AV_WB24(dst + i * 3, offset_gu);

596 } else {

597 AV_WN32(dst + i * 4, offset_gu);

598 }

599 dst += p->linesize[0];

600 }

601 break;

602 case FRAME_ARITH_RGBA:

603 avctx->pix_fmt = AV_PIX_FMT_RGB32;

604 planes = 4;

605 offset_ry += 4;

606 offs[3] = AV_RL32(buf + 9);

607 case FRAME_ARITH_RGB24:

608 case FRAME_U_RGB24:

609 if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)

610 avctx->pix_fmt = AV_PIX_FMT_RGB24;

611

612 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

613 return ret;

614

615 offs[0] = offset_bv;

616 offs[1] = offset_gu;

617 offs[2] = offset_ry;

618

619 l->rgb_stride = FFALIGN(avctx->width, 16);

620 av_fast_malloc(&l->rgb_planes, &l->rgb_planes_allocated,

621 l->rgb_stride * avctx->height * planes + 1);

622 if (!l->rgb_planes) {

623 av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");

624 return AVERROR(ENOMEM);

625 }

626 for (i = 0; i < planes; i++)

627 srcs[i] = l->rgb_planes + (i + 1) * l->rgb_stride * avctx->height - l->rgb_stride;

628 for (i = 0; i < planes; i++)

629 if (buf_size <= offs[i]) {

630 av_log(avctx, AV_LOG_ERROR,

631 "Invalid frame offsets\n");

632 return AVERROR_INVALIDDATA;

633 }

634

635 for (i = 0; i < planes; i++)

636 lag_decode_arith_plane(l, srcs[i],

637 avctx->width, avctx->height,

638 -l->rgb_stride, buf + offs[i],

639 buf_size - offs[i]);

640 dst = p->data[0];

641 for (i = 0; i < planes; i++)

642 srcs[i] = l->rgb_planes + i * l->rgb_stride * avctx->height;

643 for (j = 0; j < avctx->height; j++) {

644 for (i = 0; i < avctx->width; i++) {

645 uint8_t r, g, b, a;

646 r = srcs[0][i];

647 g = srcs[1][i];

648 b = srcs[2][i];

649 r += g;

650 b += g;

651 if (frametype == FRAME_ARITH_RGBA) {

652 a = srcs[3][i];

653 AV_WN32(dst + i * 4, MKBETAG(a, r, g, b));

654 } else {

655 dst[i * 3 + 0] = r;

656 dst[i * 3 + 1] = g;

657 dst[i * 3 + 2] = b;

658 }

659 }

660 dst += p->linesize[0];

661 for (i = 0; i < planes; i++)

662 srcs[i] += l->rgb_stride;

663 }

664 break;

665 case FRAME_ARITH_YUY2:

666 avctx->pix_fmt = AV_PIX_FMT_YUV422P;

667

668 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

669 return ret;

670

671 if (offset_ry >= buf_size ||

672 offset_gu >= buf_size ||

673 offset_bv >= buf_size) {

674 av_log(avctx, AV_LOG_ERROR,

675 "Invalid frame offsets\n");

676 return AVERROR_INVALIDDATA;

677 }

678

679 lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,

680 p->linesize[0], buf + offset_ry,

681 buf_size - offset_ry);

682 lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,

683 avctx->height, p->linesize[1],

684 buf + offset_gu, buf_size - offset_gu);

685 lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,

686 avctx->height, p->linesize[2],

687 buf + offset_bv, buf_size - offset_bv);

688 break;

689 case FRAME_ARITH_YV12:

690 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

691

692 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

693 return ret;

694 if (buf_size <= offset_ry || buf_size <= offset_gu || buf_size <= offset_bv) {

695 return AVERROR_INVALIDDATA;

696 }

697

698 if (offset_ry >= buf_size ||

699 offset_gu >= buf_size ||

700 offset_bv >= buf_size) {

701 av_log(avctx, AV_LOG_ERROR,

702 "Invalid frame offsets\n");

703 return AVERROR_INVALIDDATA;

704 }

705

706 lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,

707 p->linesize[0], buf + offset_ry,

708 buf_size - offset_ry);

709 lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,

710 (avctx->height + 1) / 2, p->linesize[2],

711 buf + offset_gu, buf_size - offset_gu);

712 lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,

713 (avctx->height + 1) / 2, p->linesize[1],

714 buf + offset_bv, buf_size - offset_bv);

715 break;

716 default:

717 av_log(avctx, AV_LOG_ERROR,

718 "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype);

719 return AVERROR_PATCHWELCOME;

720 }

721

722 *got_frame = 1;

723

724 return buf_size;

725 }

726

727 static av_cold int lag_decode_init(AVCodecContext *avctx)

728 {

729 LagarithContext *l = avctx->priv_data;

730 l->avctx = avctx;

731

732 ff_llviddsp_init(&l->llviddsp);

733

734 return 0;

735 }

736

737 #if HAVE_THREADS

738 static av_cold int lag_decode_init_thread_copy(AVCodecContext *avctx)

739 {

740 LagarithContext *l = avctx->priv_data;

741 l->avctx = avctx;

742

743 return 0;

744 }

745 #endif

746

747 static av_cold int lag_decode_end(AVCodecContext *avctx)

748 {

749 LagarithContext *l = avctx->priv_data;

750

751 av_freep(&l->rgb_planes);

752

753 return 0;

754 }

755

756 AVCodec ff_lagarith_decoder = {

757 .name = "lagarith",

758 .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),

759 .type = AVMEDIA_TYPE_VIDEO,

760 .id = AV_CODEC_ID_LAGARITH,

761 .priv_data_size = sizeof(LagarithContext),

762 .init = lag_decode_init,

763 .init_thread_copy = ONLY_IF_THREADS_ENABLED(lag_decode_init_thread_copy),

764 .close = lag_decode_end,

765 .decode = lag_decode_frame,

766 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

767 };

lag_rac::avctx

AVCodecContext * avctx

Definition: lagarithrac.h:40

lag_get_rac

static uint8_t lag_get_rac(lag_rac *l)

Decode a single byte from the compressed plane described by *l.

Definition: lagarithrac.h:78

val

const char const char void * val

Definition: avisynth_c.h:771

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

shift

static int shift(int a, int b)

Definition: sonic.c:82

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:218

Definition: vp9dsp_template.c:2038

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

ff_lag_rac_init

void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)

Definition: lagarithrac.c:33

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

init_thread_copy

static int init_thread_copy(AVCodecContext *avctx)

Definition: tta.c:392

AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:64

const char * g

Definition: vf_curves.c:112

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AVPacket::size

int size

Definition: avcodec.h:1431

const char * b

Definition: vf_curves.c:113

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

lossless_videodsp.h

src

#define src

Definition: vp8dsp.c:254

AVCodec

AVCodec.

Definition: avcodec.h:3408

lag_decode_arith_plane

static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst, int width, int height, int stride, const uint8_t *src, int src_size)

Definition: lagarith.c:421

LagarithContext::zeros

int zeros

number of consecutive zero bytes encountered

Definition: lagarith.c:54

ff_lagarith_decoder

AVCodec ff_lagarith_decoder

Definition: lagarith.c:756

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

lag_decode_zero_run_line

static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst, const uint8_t *src, const uint8_t *src_end, int width, int esc_count)

Definition: lagarith.c:363

lagarithrac.h

Lagarith range decoder.

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

FRAME_SOLID_GRAY

solid grayscale color frame

Definition: lagarith.c:42

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

lag_pred_line

static void lag_pred_line(LagarithContext *l, uint8_t *buf, int width, int stride, int line)

Definition: lagarith.c:258

thread.h

Multithreading support functions.

LagarithContext::zeros_rem

int zeros_rem

number of zero bytes remaining to output

Definition: lagarith.c:55

LLVidDSPContext

Definition: lossless_videodsp.h:31

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

height

#define height

lag_rac::scale

unsigned scale

Number of bits of precision in range.

Definition: lagarithrac.h:43

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

get_bits.h

bitstream reader API header.

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:2734

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:48

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

#define U(x)

Definition: vp56_arith.h:37

FRAME_RAW

uncompressed

Definition: lagarith.c:38

LagarithFrameType

Definition: lagarith.c:37

AV_CODEC_ID_LAGARITH

Definition: avcodec.h:365

LagarithContext

Definition: lagarith.c:51

FRAME_ARITH_RGB24

arithmetic coded RGB24

Definition: lagarith.c:41

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVERROR

#define AVERROR(e)

Definition: error.h:43

add_lag_median_prediction

static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top)

Definition: lagarith.c:234

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:186

const char * r

Definition: vf_curves.c:111

LagarithContext::avctx

AVCodecContext * avctx

Definition: lagarith.c:52

line

Definition: graph2dot.c:48

width

uint16_t width

Definition: gdv.c:47

length

GLsizei GLsizei * length

Definition: opengl_enc.c:115

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3415

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

count

GLsizei count

Definition: opengl_enc.c:109

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: avcodec.h:1015

lag_decode_init

static av_cold int lag_decode_init(AVCodecContext *avctx)

Definition: lagarith.c:727

AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:66

ONLY_IF_THREADS_ENABLED

#define ONLY_IF_THREADS_ENABLED(x)

Define a function with only the non-default version specified.

Definition: internal.h:225

FRAME_ARITH_YV12

arithmetic coded YV12

Definition: lagarith.c:47

av_fast_malloc

void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)

Allocate a buffer, reusing the given one if large enough.

Definition: mem.c:488

LagarithContext::rgb_planes_allocated

int rgb_planes_allocated

Definition: lagarith.c:57

softfloat_reciprocal

static uint64_t softfloat_reciprocal(uint32_t denom)

Compute the 52-bit mantissa of 1/(double)denom.

Definition: lagarith.c:69

FRAME_OLD_ARITH_RGB

obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) ...

Definition: lagarith.c:44

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1690

uint8_t w

Definition: llviddspenc.c:38

value

GLsizei GLboolean const GLfloat * value

Definition: opengl_enc.c:109

mathops.h

FRAME_ARITH_YUY2

arithmetic coded YUY2

Definition: lagarith.c:40

lag_decode_frame

static int lag_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Decode a frame.

Definition: lagarith.c:529

AV_WB24

#define AV_WB24(p, d)

Definition: intreadwrite.h:450

lag_rac

Definition: lagarithrac.h:39

ThreadFrame

Definition: thread.h:34

lag_decode_prob

static int lag_decode_prob(GetBitContext *gb, uint32_t *value)

Definition: lagarith.c:104

#define L(x)

Definition: vp56_arith.h:36

AVCodecContext::height

int height

Definition: avcodec.h:1690

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

src1

#define src1

Definition: h264pred.c:139

lag_decode_line

static int lag_decode_line(LagarithContext *l, lag_rac *rac, uint8_t *dst, int width, int stride, int esc_count)

Definition: lagarith.c:321

avcodec.h

Libavcodec external API header.

lag_rac::prob

uint32_t prob[258]

Table of cumulative probability for each symbol.

Definition: lagarithrac.h:53

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:249

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:464

softfloat_mul

static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)

(uint32_t)(x*f), where f has the given mantissa, and exponent 0 Used in combination with softfloat_re...

Definition: lagarith.c:88

ff_thread_get_buffer

int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)

Wrapper around get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:965

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

AV_PIX_FMT_RGB32

#define AV_PIX_FMT_RGB32

Definition: pixfmt.h:342

buf

void * buf

Definition: avisynth_c.h:690

lag_rac::overread

int overread

Definition: lagarithrac.h:50

ff_llviddsp_init

void ff_llviddsp_init(LLVidDSPContext *c)

Definition: lossless_videodsp.c:112

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:321

index

int index

Definition: gxfenc.c:89

MAX_OVERREAD

#define MAX_OVERREAD

Definition: lagarithrac.h:51

mid_pred

#define mid_pred

Definition: mathops.h:97

lag_read_prob_header

static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)

Definition: lagarith.c:138

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:354

LagarithContext::rgb_planes

uint8_t * rgb_planes

Definition: lagarith.c:56

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:232

stride

GLint GLenum GLboolean GLsizei stride

Definition: opengl_enc.c:105

LagarithContext::llviddsp

LLVidDSPContext llviddsp

Definition: lagarith.c:53

AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:62

lag_decode_end

static av_cold int lag_decode_end(AVCodecContext *avctx)

Definition: lagarith.c:747

GetBitContext

Definition: get_bits.h:56

AV_WN32

#define AV_WN32(p, v)

Definition: intreadwrite.h:376

planes

static const struct @272 planes[]

FRAME_SOLID_COLOR

solid non-grayscale color frame

Definition: lagarith.c:43

MKBETAG

#define MKBETAG(a, b, c, d)

Definition: common.h:367

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

lag_calc_zero_run

static uint8_t lag_calc_zero_run(int8_t x)

Definition: lagarith.c:99

diff

static av_always_inline int diff(const uint32_t a, const uint32_t b)

Definition: vf_palettegen.c:136

LLVidDSPContext::add_left_pred

int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)

Definition: lossless_videodsp.h:37

lag_pred_line_yuy2

static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf, int width, int stride, int line, int is_luma)

Definition: lagarith.c:284

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:296

FRAME_SOLID_RGBA

solid RGBA color frame

Definition: lagarith.c:46

FRAME_ARITH_RGBA

arithmetic coded RGBA

Definition: lagarith.c:45

FRAME_REDUCED_RES

reduced resolution YV12 frame

Definition: lagarith.c:48

FRAME_U_RGB24

unaligned RGB24

Definition: lagarith.c:39

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

LagarithContext::rgb_stride

int rgb_stride

Definition: lagarith.c:58

stride

#define stride

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:87

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() for allocating buffers and supports custom allocators.

Definition: avcodec.h:959

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

LLVidDSPContext::add_median_pred

void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)

Definition: lossless_videodsp.h:34

AV_PIX_FMT_0RGB32

#define AV_PIX_FMT_0RGB32

Definition: pixfmt.h:346

Definition: h264pred_template.c:468

Generated on Sun May 13 2018 02:03:49 for FFmpeg by doxygen 1.8.6