| @@ -39,6 +39,7 @@ · 38 unmodified lines |
| 39 | #include "put_golomb.h" | 39 | #include "put_golomb.h" |
| 40 | #include "rangecoder.h" | 40 | #include "rangecoder.h" |
| 41 | #include "ffv1.h" | 41 | #include "ffv1.h" |
| | 42 | #include "ffv1enc.h" |
| 42 | | 43 | |
| 43 | static const int8_t quant5_10bit[256] = { | 44 | static const int8_t quant5_10bit[256] = { |
| 44 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, | 45 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, |
| @@ -512,16 +513,42 @@ static int sort_stt(FFV1Context *s, uint8_t stt[256]) · 467 unmodified lines |
| 512 | return print; | 513 | return print; |
| 513 | } | 514 | } |
| 514 | | 515 | |
| 515 | static av_cold int encode_init(AVCodecContext *avctx) | 516 | |
| | 517 | static int encode_determine_slices(AVCodecContext *avctx) |
| 516 | { | 518 | { |
| 517 | FFV1Context *s = avctx->priv_data; | 519 | FFV1Context *s = avctx->priv_data; |
| 518 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); | 520 | int plane_count = 1 + 2*s->chroma_planes + s->transparency; |
| 519 | int i, j, k, m, ret; | 521 | int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift); |
| 520 | | 522 | int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift); |
| 521 | if ((ret = ff_ffv1_common_init(avctx)) < 0) | 523 | s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1; |
| 522 | return ret; | 524 | s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices); |
| | 525 | for (; s->num_v_slices < 32; s->num_v_slices++) { |
| | 526 | for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) { |
| | 527 | int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices; |
| | 528 | int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices; |
| | 529 | if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices) |
| | 530 | continue; |
| | 531 | if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24) |
| | 532 | continue; |
| | 533 | if (s->version < 4) |
| | 534 | if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift) |
| | 535 | ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift)) |
| | 536 | continue; |
| | 537 | if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices) |
| | 538 | return 0; |
| | 539 | } |
| | 540 | } |
| | 541 | av_log(avctx, AV_LOG_ERROR, |
| | 542 | "Unsupported number %d of slices requested, please specify a " |
| | 543 | "supported number with -slices (ex:4,6,9,12,16, ...)\n", |
| | 544 | avctx->slices); |
| | 545 | return AVERROR(ENOSYS); |
| | 546 | } |
| 523 | | 547 | |
| 524 | s->version = 0; | 548 | av_cold int ff_ffv1_encode_init(AVCodecContext *avctx) |
| | 549 | { |
| | 550 | FFV1Context *s = avctx->priv_data; |
| | 551 | int i, j, k, m, ret; |
| 525 | | 552 | |
| 526 | if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) || | 553 | if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) || |
| 527 | avctx->slices > 1) | 554 | avctx->slices > 1) |
| @@ -568,153 +595,6 @@ static av_cold int encode_init(AVCodecContext *avctx) · 40 unmodified lines |
| 568 | return AVERROR_INVALIDDATA; | 595 | return AVERROR_INVALIDDATA; |
| 569 | } | 596 | } |
| 570 | | 597 | |
| 571 | if (s->ac == 1) // Compatbility with common command line usage | | |
| 572 | s->ac = AC_RANGE_CUSTOM_TAB; | | |
| 573 | else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE) | | |
| 574 | s->ac = AC_RANGE_DEFAULT_TAB; | | |
| 575 | | | |
| 576 | s->plane_count = 3; | | |
| 577 | switch(avctx->pix_fmt) { | | |
| 578 | case AV_PIX_FMT_GRAY9: | | |
| 579 | case AV_PIX_FMT_YUV444P9: | | |
| 580 | case AV_PIX_FMT_YUV422P9: | | |
| 581 | case AV_PIX_FMT_YUV420P9: | | |
| 582 | case AV_PIX_FMT_YUVA444P9: | | |
| 583 | case AV_PIX_FMT_YUVA422P9: | | |
| 584 | case AV_PIX_FMT_YUVA420P9: | | |
| 585 | if (!avctx->bits_per_raw_sample) | | |
| 586 | s->bits_per_raw_sample = 9; | | |
| 587 | case AV_PIX_FMT_GRAY10: | | |
| 588 | case AV_PIX_FMT_YUV444P10: | | |
| 589 | case AV_PIX_FMT_YUV440P10: | | |
| 590 | case AV_PIX_FMT_YUV420P10: | | |
| 591 | case AV_PIX_FMT_YUV422P10: | | |
| 592 | case AV_PIX_FMT_YUVA444P10: | | |
| 593 | case AV_PIX_FMT_YUVA422P10: | | |
| 594 | case AV_PIX_FMT_YUVA420P10: | | |
| 595 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 596 | s->bits_per_raw_sample = 10; | | |
| 597 | case AV_PIX_FMT_GRAY12: | | |
| 598 | case AV_PIX_FMT_YUV444P12: | | |
| 599 | case AV_PIX_FMT_YUV440P12: | | |
| 600 | case AV_PIX_FMT_YUV420P12: | | |
| 601 | case AV_PIX_FMT_YUV422P12: | | |
| 602 | case AV_PIX_FMT_YUVA444P12: | | |
| 603 | case AV_PIX_FMT_YUVA422P12: | | |
| 604 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 605 | s->bits_per_raw_sample = 12; | | |
| 606 | case AV_PIX_FMT_GRAY14: | | |
| 607 | case AV_PIX_FMT_YUV444P14: | | |
| 608 | case AV_PIX_FMT_YUV420P14: | | |
| 609 | case AV_PIX_FMT_YUV422P14: | | |
| 610 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 611 | s->bits_per_raw_sample = 14; | | |
| 612 | s->packed_at_lsb = 1; | | |
| 613 | case AV_PIX_FMT_GRAY16: | | |
| 614 | case AV_PIX_FMT_YUV444P16: | | |
| 615 | case AV_PIX_FMT_YUV422P16: | | |
| 616 | case AV_PIX_FMT_YUV420P16: | | |
| 617 | case AV_PIX_FMT_YUVA444P16: | | |
| 618 | case AV_PIX_FMT_YUVA422P16: | | |
| 619 | case AV_PIX_FMT_YUVA420P16: | | |
| 620 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) { | | |
| 621 | s->bits_per_raw_sample = 16; | | |
| 622 | } else if (!s->bits_per_raw_sample) { | | |
| 623 | s->bits_per_raw_sample = avctx->bits_per_raw_sample; | | |
| 624 | } | | |
| 625 | if (s->bits_per_raw_sample <= 8) { | | |
| 626 | av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n"); | | |
| 627 | return AVERROR_INVALIDDATA; | | |
| 628 | } | | |
| 629 | s->version = FFMAX(s->version, 1); | | |
| 630 | case AV_PIX_FMT_GRAY8: | | |
| 631 | case AV_PIX_FMT_YA8: | | |
| 632 | case AV_PIX_FMT_YUV444P: | | |
| 633 | case AV_PIX_FMT_YUV440P: | | |
| 634 | case AV_PIX_FMT_YUV422P: | | |
| 635 | case AV_PIX_FMT_YUV420P: | | |
| 636 | case AV_PIX_FMT_YUV411P: | | |
| 637 | case AV_PIX_FMT_YUV410P: | | |
| 638 | case AV_PIX_FMT_YUVA444P: | | |
| 639 | case AV_PIX_FMT_YUVA422P: | | |
| 640 | case AV_PIX_FMT_YUVA420P: | | |
| 641 | s->chroma_planes = desc->nb_components < 3 ? 0 : 1; | | |
| 642 | s->colorspace = 0; | | |
| 643 | s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA); | | |
| 644 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 645 | s->bits_per_raw_sample = 8; | | |
| 646 | else if (!s->bits_per_raw_sample) | | |
| 647 | s->bits_per_raw_sample = 8; | | |
| 648 | break; | | |
| 649 | case AV_PIX_FMT_RGB32: | | |
| 650 | s->colorspace = 1; | | |
| 651 | s->transparency = 1; | | |
| 652 | s->chroma_planes = 1; | | |
| 653 | s->bits_per_raw_sample = 8; | | |
| 654 | break; | | |
| 655 | case AV_PIX_FMT_RGBA64: | | |
| 656 | s->colorspace = 1; | | |
| 657 | s->transparency = 1; | | |
| 658 | s->chroma_planes = 1; | | |
| 659 | s->bits_per_raw_sample = 16; | | |
| 660 | s->use32bit = 1; | | |
| 661 | s->version = FFMAX(s->version, 1); | | |
| 662 | break; | | |
| 663 | case AV_PIX_FMT_RGB48: | | |
| 664 | s->colorspace = 1; | | |
| 665 | s->chroma_planes = 1; | | |
| 666 | s->bits_per_raw_sample = 16; | | |
| 667 | s->use32bit = 1; | | |
| 668 | s->version = FFMAX(s->version, 1); | | |
| 669 | break; | | |
| 670 | case AV_PIX_FMT_0RGB32: | | |
| 671 | s->colorspace = 1; | | |
| 672 | s->chroma_planes = 1; | | |
| 673 | s->bits_per_raw_sample = 8; | | |
| 674 | break; | | |
| 675 | case AV_PIX_FMT_GBRP9: | | |
| 676 | if (!avctx->bits_per_raw_sample) | | |
| 677 | s->bits_per_raw_sample = 9; | | |
| 678 | case AV_PIX_FMT_GBRP10: | | |
| 679 | case AV_PIX_FMT_GBRAP10: | | |
| 680 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 681 | s->bits_per_raw_sample = 10; | | |
| 682 | case AV_PIX_FMT_GBRP12: | | |
| 683 | case AV_PIX_FMT_GBRAP12: | | |
| 684 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 685 | s->bits_per_raw_sample = 12; | | |
| 686 | case AV_PIX_FMT_GBRP14: | | |
| 687 | case AV_PIX_FMT_GBRAP14: | | |
| 688 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 689 | s->bits_per_raw_sample = 14; | | |
| 690 | case AV_PIX_FMT_GBRP16: | | |
| 691 | case AV_PIX_FMT_GBRAP16: | | |
| 692 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) | | |
| 693 | s->bits_per_raw_sample = 16; | | |
| 694 | else if (!s->bits_per_raw_sample) | | |
| 695 | s->bits_per_raw_sample = avctx->bits_per_raw_sample; | | |
| 696 | s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA); | | |
| 697 | s->colorspace = 1; | | |
| 698 | s->chroma_planes = 1; | | |
| 699 | if (s->bits_per_raw_sample >= 16) { | | |
| 700 | s->use32bit = 1; | | |
| 701 | } | | |
| 702 | s->version = FFMAX(s->version, 1); | | |
| 703 | break; | | |
| 704 | default: | | |
| 705 | av_log(avctx, AV_LOG_ERROR, "format not supported\n"); | | |
| 706 | return AVERROR(ENOSYS); | | |
| 707 | } | | |
| 708 | av_assert0(s->bits_per_raw_sample >= 8); | | |
| 709 | | | |
| 710 | if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8)) { | | |
| 711 | if (s->ac == AC_GOLOMB_RICE) { | | |
| 712 | av_log(avctx, AV_LOG_INFO, | | |
| 713 | "high bits_per_raw_sample, forcing range coder\n"); | | |
| 714 | s->ac = AC_RANGE_CUSTOM_TAB; | | |
| 715 | } | | |
| 716 | } | | |
| 717 | | | |
| 718 | if (s->ac == AC_RANGE_CUSTOM_TAB) { | 598 | if (s->ac == AC_RANGE_CUSTOM_TAB) { |
| 719 | for (i = 1; i < 256; i++) | 599 | for (i = 1; i < 256; i++) |
| 720 | s->state_transition[i] = ver2_state[i]; | 600 | s->state_transition[i] = ver2_state[i]; |
| @@ -725,7 +605,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 4 unmodified lines |
| 725 | s->state_transition[i] = c.one_state[i]; | 605 | s->state_transition[i] = c.one_state[i]; |
| 726 | } | 606 | } |
| 727 | | 607 | |
| 728 | for (i = 0; i < MAX_QUANT_TABLE_SIZE; i++) { | 608 | for (i = 0; i < 256; i++) { |
| 729 | s->quant_table_count = 2; | 609 | s->quant_table_count = 2; |
| 730 | if ((s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1) { | 610 | if ((s->qtable == -1 && s->bits_per_raw_sample <= 8) || s->qtable == 1) { |
| 731 | s->quant_tables[0][0][i]= quant11[i]; | 611 | s->quant_tables[0][0][i]= quant11[i]; |
| @@ -760,10 +640,6 @@ static av_cold int encode_init(AVCodecContext *avctx) · 28 unmodified lines |
| 760 | if (!s->chroma_planes && s->version > 3) | 640 | if (!s->chroma_planes && s->version > 3) |
| 761 | s->plane_count--; | 641 | s->plane_count--; |
| 762 | | 642 | |
| 763 | ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift); | | |
| 764 | if (ret) | | |
| 765 | return ret; | | |
| 766 | | | |
| 767 | s->picture_number = 0; | 643 | s->picture_number = 0; |
| 768 | | 644 | |
| 769 | if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) { | 645 | if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) { |
| @@ -856,36 +732,14 @@ static av_cold int encode_init(AVCodecContext *avctx) · 86 unmodified lines |
| 856 | av_freep(&best_state); | 732 | av_freep(&best_state); |
| 857 | } | 733 | } |
| 858 | | 734 | |
| 859 | if (s->version > 1) { | 735 | if (s->version <= 1) { |
| 860 | int plane_count = 1 + 2*s->chroma_planes + s->transparency; | 736 | /* Disable slices when the version doesn't support them */ |
| 861 | int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift); | 737 | s->num_h_slices = 1; |
| 862 | int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift); | 738 | s->num_v_slices = 1; |
| 863 | s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1; | 739 | } else { |
| 864 | | 740 | if ((ret = encode_determine_slices(avctx)) < 0) |
| 865 | s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices); | 741 | return ret; |
| 866 | | 742 | |
| 867 | for (; s->num_v_slices < 32; s->num_v_slices++) { | | |
| 868 | for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) { | | |
| 869 | int maxw = (avctx->width + s->num_h_slices - 1) / s->num_h_slices; | | |
| 870 | int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices; | | |
| 871 | if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices) | | |
| 872 | continue; | | |
| 873 | if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24) | | |
| 874 | continue; | | |
| 875 | if (s->version < 4) | | |
| 876 | if ( ff_need_new_slices(avctx->width , s->num_h_slices, s->chroma_h_shift) | | |
| 877 | ||ff_need_new_slices(avctx->height, s->num_v_slices, s->chroma_v_shift)) | | |
| 878 | continue; | | |
| 879 | if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices) | | |
| 880 | goto slices_ok; | | |
| 881 | } | | |
| 882 | } | | |
| 883 | av_log(avctx, AV_LOG_ERROR, | | |
| 884 | "Unsupported number %d of slices requested, please specify a " | | |
| 885 | "supported number with -slices (ex:4,6,9,12,16, ...)\n", | | |
| 886 | avctx->slices); | | |
| 887 | return AVERROR(ENOSYS); | | |
| 888 | slices_ok: | | |
| 889 | if ((ret = write_extradata(s)) < 0) | 743 | if ((ret = write_extradata(s)) < 0) |
| 890 | return ret; | 744 | return ret; |
| 891 | } | 745 | } |
| @@ -908,13 +762,178 @@ slices_ok: · 16 unmodified lines |
| 908 | if ((ret = ff_ffv1_init_slices_state(s)) < 0) | 762 | if ((ret = ff_ffv1_init_slices_state(s)) < 0) |
| 909 | return ret; | 763 | return ret; |
| 910 | | 764 | |
| | 765 | return 0; |
| | 766 | } |
| | 767 | |
| | 768 | static int encode_init_internal(AVCodecContext *avctx) |
| | 769 | { |
| | 770 | int ret; |
| | 771 | FFV1Context *s = avctx->priv_data; |
| | 772 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); |
| | 773 | |
| | 774 | if ((ret = ff_ffv1_common_init(avctx)) < 0) |
| | 775 | return ret; |
| | 776 | |
| | 777 | if (s->ac == 1) // Compatbility with common command line usage |
| | 778 | s->ac = AC_RANGE_CUSTOM_TAB; |
| | 779 | else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE) |
| | 780 | s->ac = AC_RANGE_DEFAULT_TAB; |
| | 781 | |
| | 782 | s->plane_count = 3; |
| | 783 | switch(avctx->pix_fmt) { |
| | 784 | case AV_PIX_FMT_GRAY9: |
| | 785 | case AV_PIX_FMT_YUV444P9: |
| | 786 | case AV_PIX_FMT_YUV422P9: |
| | 787 | case AV_PIX_FMT_YUV420P9: |
| | 788 | case AV_PIX_FMT_YUVA444P9: |
| | 789 | case AV_PIX_FMT_YUVA422P9: |
| | 790 | case AV_PIX_FMT_YUVA420P9: |
| | 791 | if (!avctx->bits_per_raw_sample) |
| | 792 | s->bits_per_raw_sample = 9; |
| | 793 | case AV_PIX_FMT_GRAY10: |
| | 794 | case AV_PIX_FMT_YUV444P10: |
| | 795 | case AV_PIX_FMT_YUV440P10: |
| | 796 | case AV_PIX_FMT_YUV420P10: |
| | 797 | case AV_PIX_FMT_YUV422P10: |
| | 798 | case AV_PIX_FMT_YUVA444P10: |
| | 799 | case AV_PIX_FMT_YUVA422P10: |
| | 800 | case AV_PIX_FMT_YUVA420P10: |
| | 801 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 802 | s->bits_per_raw_sample = 10; |
| | 803 | case AV_PIX_FMT_GRAY12: |
| | 804 | case AV_PIX_FMT_YUV444P12: |
| | 805 | case AV_PIX_FMT_YUV440P12: |
| | 806 | case AV_PIX_FMT_YUV420P12: |
| | 807 | case AV_PIX_FMT_YUV422P12: |
| | 808 | case AV_PIX_FMT_YUVA444P12: |
| | 809 | case AV_PIX_FMT_YUVA422P12: |
| | 810 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 811 | s->bits_per_raw_sample = 12; |
| | 812 | case AV_PIX_FMT_GRAY14: |
| | 813 | case AV_PIX_FMT_YUV444P14: |
| | 814 | case AV_PIX_FMT_YUV420P14: |
| | 815 | case AV_PIX_FMT_YUV422P14: |
| | 816 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 817 | s->bits_per_raw_sample = 14; |
| | 818 | s->packed_at_lsb = 1; |
| | 819 | case AV_PIX_FMT_GRAY16: |
| | 820 | case AV_PIX_FMT_YUV444P16: |
| | 821 | case AV_PIX_FMT_YUV422P16: |
| | 822 | case AV_PIX_FMT_YUV420P16: |
| | 823 | case AV_PIX_FMT_YUVA444P16: |
| | 824 | case AV_PIX_FMT_YUVA422P16: |
| | 825 | case AV_PIX_FMT_YUVA420P16: |
| | 826 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) { |
| | 827 | s->bits_per_raw_sample = 16; |
| | 828 | } else if (!s->bits_per_raw_sample) { |
| | 829 | s->bits_per_raw_sample = avctx->bits_per_raw_sample; |
| | 830 | } |
| | 831 | if (s->bits_per_raw_sample <= 8) { |
| | 832 | av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n"); |
| | 833 | return AVERROR_INVALIDDATA; |
| | 834 | } |
| | 835 | s->version = FFMAX(s->version, 1); |
| | 836 | case AV_PIX_FMT_GRAY8: |
| | 837 | case AV_PIX_FMT_YA8: |
| | 838 | case AV_PIX_FMT_YUV444P: |
| | 839 | case AV_PIX_FMT_YUV440P: |
| | 840 | case AV_PIX_FMT_YUV422P: |
| | 841 | case AV_PIX_FMT_YUV420P: |
| | 842 | case AV_PIX_FMT_YUV411P: |
| | 843 | case AV_PIX_FMT_YUV410P: |
| | 844 | case AV_PIX_FMT_YUVA444P: |
| | 845 | case AV_PIX_FMT_YUVA422P: |
| | 846 | case AV_PIX_FMT_YUVA420P: |
| | 847 | s->chroma_planes = desc->nb_components < 3 ? 0 : 1; |
| | 848 | s->colorspace = 0; |
| | 849 | s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA); |
| | 850 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 851 | s->bits_per_raw_sample = 8; |
| | 852 | else if (!s->bits_per_raw_sample) |
| | 853 | s->bits_per_raw_sample = 8; |
| | 854 | break; |
| | 855 | case AV_PIX_FMT_RGB32: |
| | 856 | s->colorspace = 1; |
| | 857 | s->transparency = 1; |
| | 858 | s->chroma_planes = 1; |
| | 859 | s->bits_per_raw_sample = 8; |
| | 860 | break; |
| | 861 | case AV_PIX_FMT_RGBA64: |
| | 862 | s->colorspace = 1; |
| | 863 | s->transparency = 1; |
| | 864 | s->chroma_planes = 1; |
| | 865 | s->bits_per_raw_sample = 16; |
| | 866 | s->use32bit = 1; |
| | 867 | s->version = FFMAX(s->version, 1); |
| | 868 | break; |
| | 869 | case AV_PIX_FMT_RGB48: |
| | 870 | s->colorspace = 1; |
| | 871 | s->chroma_planes = 1; |
| | 872 | s->bits_per_raw_sample = 16; |
| | 873 | s->use32bit = 1; |
| | 874 | s->version = FFMAX(s->version, 1); |
| | 875 | break; |
| | 876 | case AV_PIX_FMT_0RGB32: |
| | 877 | s->colorspace = 1; |
| | 878 | s->chroma_planes = 1; |
| | 879 | s->bits_per_raw_sample = 8; |
| | 880 | break; |
| | 881 | case AV_PIX_FMT_GBRP9: |
| | 882 | if (!avctx->bits_per_raw_sample) |
| | 883 | s->bits_per_raw_sample = 9; |
| | 884 | case AV_PIX_FMT_GBRP10: |
| | 885 | case AV_PIX_FMT_GBRAP10: |
| | 886 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 887 | s->bits_per_raw_sample = 10; |
| | 888 | case AV_PIX_FMT_GBRP12: |
| | 889 | case AV_PIX_FMT_GBRAP12: |
| | 890 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 891 | s->bits_per_raw_sample = 12; |
| | 892 | case AV_PIX_FMT_GBRP14: |
| | 893 | case AV_PIX_FMT_GBRAP14: |
| | 894 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 895 | s->bits_per_raw_sample = 14; |
| | 896 | case AV_PIX_FMT_GBRP16: |
| | 897 | case AV_PIX_FMT_GBRAP16: |
| | 898 | if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) |
| | 899 | s->bits_per_raw_sample = 16; |
| | 900 | else if (!s->bits_per_raw_sample) |
| | 901 | s->bits_per_raw_sample = avctx->bits_per_raw_sample; |
| | 902 | s->transparency = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA); |
| | 903 | s->colorspace = 1; |
| | 904 | s->chroma_planes = 1; |
| | 905 | if (s->bits_per_raw_sample >= 16) { |
| | 906 | s->use32bit = 1; |
| | 907 | } |
| | 908 | s->version = FFMAX(s->version, 1); |
| | 909 | break; |
| | 910 | default: |
| | 911 | av_log(avctx, AV_LOG_ERROR, "format not supported\n"); |
| | 912 | return AVERROR(ENOSYS); |
| | 913 | } |
| | 914 | av_assert0(s->bits_per_raw_sample >= 8); |
| | 915 | |
| | 916 | if (s->bits_per_raw_sample > (s->version > 3 ? 16 : 8)) { |
| | 917 | if (s->ac == AC_GOLOMB_RICE) { |
| | 918 | av_log(avctx, AV_LOG_INFO, |
| | 919 | "high bits_per_raw_sample, forcing range coder\n"); |
| | 920 | s->ac = AC_RANGE_CUSTOM_TAB; |
| | 921 | } |
| | 922 | } |
| | 923 | |
| | 924 | s->version = 0; |
| | 925 | |
| | 926 | ret = ff_ffv1_encode_init(avctx); |
| | 927 | if (ret < 0) |
| | 928 | return ret; |
| | 929 | |
| 911 | #define STATS_OUT_SIZE 1024 * 1024 * 6 | 930 | #define STATS_OUT_SIZE 1024 * 1024 * 6 |
| 912 | if (avctx->flags & AV_CODEC_FLAG_PASS1) { | 931 | if (avctx->flags & AV_CODEC_FLAG_PASS1) { |
| 913 | avctx->stats_out = av_mallocz(STATS_OUT_SIZE); | 932 | avctx->stats_out = av_mallocz(STATS_OUT_SIZE); |
| 914 | if (!avctx->stats_out) | 933 | if (!avctx->stats_out) |
| 915 | return AVERROR(ENOMEM); | 934 | return AVERROR(ENOMEM); |
| 916 | for (i = 0; i < s->quant_table_count; i++) | 935 | for (int i = 0; i < s->quant_table_count; i++) |
| 917 | for (j = 0; j < s->max_slice_count; j++) { | 936 | for (int j = 0; j < s->max_slice_count; j++) { |
| 918 | FFV1SliceContext *sc = &s->slices[j]; | 937 | FFV1SliceContext *sc = &s->slices[j]; |
| 919 | av_assert0(!sc->rc_stat2[i]); | 938 | av_assert0(!sc->rc_stat2[i]); |
| 920 | sc->rc_stat2[i] = av_mallocz(s->context_count[i] * | 939 | sc->rc_stat2[i] = av_mallocz(s->context_count[i] * |
| @@ -1321,7 +1340,7 @@ const FFCodec ff_ffv1_encoder = { · 400 unmodified lines |
| 1321 | AV_CODEC_CAP_SLICE_THREADS | | 1340 | AV_CODEC_CAP_SLICE_THREADS | |
| 1322 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | 1341 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, |
| 1323 | .priv_data_size = sizeof(FFV1Context), | 1342 | .priv_data_size = sizeof(FFV1Context), |
| 1324 | .init = encode_init, | 1343 | .init = encode_init_internal, |
| 1325 | FF_CODEC_ENCODE_CB(encode_frame), | 1344 | FF_CODEC_ENCODE_CB(encode_frame), |
| 1326 | .close = ff_ffv1_close, | 1345 | .close = ff_ffv1_close, |
| 1327 | .p.pix_fmts = (const enum AVPixelFormat[]) { | 1346 | .p.pix_fmts = (const enum AVPixelFormat[]) { |