← Back to branch summary

~ubuntu-branches/debian/sid/ffmpeg/sid

« back to all changes in this revision

Viewing changes to libswscale/utils.c

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun, Fabian Greffrath, Andreas Cadhalpun
  • Date: 2015-09-22 15:15:20 UTC
  • mfrom: (0.1.29)
  • Revision ID: package-import@ubuntu.com-20150922151520-hhmd3in9ykigjvs9
Tags: 7:2.8-1
http://bugs.debian.org/786670
http://bugs.debian.org/798189
[ Fabian Greffrath ]
* Pass the --dbg-package=ffmpeg-dbg parameter only to dh_strip.
* Add alternative Depends: libavcodec-ffmpeg-extra56 to libavcodec-dev and
  ffmpeg-dbg to allow for building and debugging with this library installed.

[ Andreas Cadhalpun ]
* Import new major upstream release 2.8.
* Remove the transitional lib*-ffmpeg-dev packages.
* Drop old Breaks on kodi-bin.
* Drop workaround for sparc, which is no Debian architecture anymore.
* Re-enable x265 on alpha, as it's available again.
* Disable unavailable frei0r, opencv and x264 on mips64el.
* Disable libopenjpeg (#787275) and libschroedinger (#787957) decoders.
  (Closes: #786670)
* Disable libdc1394 on sparc64, because it links against the broken due to
  #790560 libudev1.
* Enable libsnappy support.
* Add new symbols.
* Update debian/copyright.
* Update debian/tests/encdec_list.txt.
* Add hls-only-seek-if-there-is-an-offset.patch. (Closes: #798189)
* Add 'Breaks: libavutil-ffmpeg54 (>= 8:0)' to the libraries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libswscale/utils.c
166
166
    [AV_PIX_FMT_RGB444BE]    = { 1, 1 },
167
167
    [AV_PIX_FMT_BGR444LE]    = { 1, 1 },
168
168
    [AV_PIX_FMT_BGR444BE]    = { 1, 1 },
169
 
    [AV_PIX_FMT_YA8]         = { 1, 0 },
 
169
    [AV_PIX_FMT_YA8]         = { 1, 1 },
170
170
    [AV_PIX_FMT_YA16BE]      = { 1, 0 },
171
171
    [AV_PIX_FMT_YA16LE]      = { 1, 0 },
172
172
    [AV_PIX_FMT_BGR48BE]     = { 1, 1 },
225
225
    [AV_PIX_FMT_BAYER_GRBG16BE] = { 1, 0 },
226
226
    [AV_PIX_FMT_XYZ12BE]     = { 1, 1, 1 },
227
227
    [AV_PIX_FMT_XYZ12LE]     = { 1, 1, 1 },
 
228
    [AV_PIX_FMT_AYUV64LE]    = { 1, 1},
228
229
};
229
230
 
230
231
int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
854
855
    if (need_reinit && (c->srcBpc == 8 || !isYUV(c->srcFormat)))
855
856
        ff_sws_init_range_convert(c);
856
857
 
857
 
    if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat)))
858
 
        return -1;
859
 
 
860
858
    c->dstFormatBpp = av_get_bits_per_pixel(desc_dst);
861
859
    c->srcFormatBpp = av_get_bits_per_pixel(desc_src);
862
860
 
 
861
    if (c->cascaded_context[0])
 
862
        return sws_setColorspaceDetails(c->cascaded_context[0],inv_table, srcRange,table, dstRange, brightness,  contrast, saturation);
 
863
 
 
864
    if ((isYUV(c->dstFormat) || isGray(c->dstFormat)) && (isYUV(c->srcFormat) || isGray(c->srcFormat))) {
 
865
        if (!c->cascaded_context[0] &&
 
866
            memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
 
867
            c->srcW && c->srcH && c->dstW && c->dstH) {
 
868
            enum AVPixelFormat tmp_format;
 
869
            int tmp_width, tmp_height;
 
870
            int srcW = c->srcW;
 
871
            int srcH = c->srcH;
 
872
            int dstW = c->dstW;
 
873
            int dstH = c->dstH;
 
874
            int ret;
 
875
            av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
 
876
 
 
877
            if (isNBPS(c->dstFormat) || is16BPS(c->dstFormat)) {
 
878
                if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
 
879
                    tmp_format = AV_PIX_FMT_BGRA64;
 
880
                } else {
 
881
                    tmp_format = AV_PIX_FMT_BGR48;
 
882
                }
 
883
            } else {
 
884
                if (isALPHA(c->srcFormat) && isALPHA(c->dstFormat)) {
 
885
                    tmp_format = AV_PIX_FMT_BGRA;
 
886
                } else {
 
887
                    tmp_format = AV_PIX_FMT_BGR24;
 
888
                }
 
889
            }
 
890
 
 
891
            if (srcW*srcH > dstW*dstH) {
 
892
                tmp_width  = dstW;
 
893
                tmp_height = dstH;
 
894
            } else {
 
895
                tmp_width  = srcW;
 
896
                tmp_height = srcH;
 
897
            }
 
898
 
 
899
            ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
 
900
                                tmp_width, tmp_height, tmp_format, 64);
 
901
            if (ret < 0)
 
902
                return ret;
 
903
 
 
904
            c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, c->srcFormat,
 
905
                                                        tmp_width, tmp_height, tmp_format,
 
906
                                                        c->flags, c->param);
 
907
            if (!c->cascaded_context[0])
 
908
                return -1;
 
909
 
 
910
            c->cascaded_context[0]->alphablend = c->alphablend;
 
911
            ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
 
912
            if (ret < 0)
 
913
                return ret;
 
914
            //we set both src and dst depending on that the RGB side will be ignored
 
915
            sws_setColorspaceDetails(c->cascaded_context[0], inv_table,
 
916
                                     srcRange, table, dstRange,
 
917
                                     brightness, contrast, saturation);
 
918
 
 
919
            c->cascaded_context[1] = sws_getContext(tmp_width, tmp_height, tmp_format,
 
920
                                                    dstW, dstH, c->dstFormat,
 
921
                                                    c->flags, NULL, NULL, c->param);
 
922
            if (!c->cascaded_context[1])
 
923
                return -1;
 
924
            sws_setColorspaceDetails(c->cascaded_context[1], inv_table,
 
925
                                     srcRange, table, dstRange,
 
926
                                     0, 1 << 16, 1 << 16);
 
927
            return 0;
 
928
        }
 
929
        return -1;
 
930
    }
 
931
 
863
932
    if (!isYUV(c->dstFormat) && !isGray(c->dstFormat)) {
864
933
        ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
865
934
                                 contrast, saturation);
978
1047
    return tbl;
979
1048
}
980
1049
 
 
1050
static enum AVPixelFormat alphaless_fmt(enum AVPixelFormat fmt)
 
1051
{
 
1052
    switch(fmt) {
 
1053
    case AV_PIX_FMT_ARGB:       return AV_PIX_FMT_RGB24;
 
1054
    case AV_PIX_FMT_RGBA:       return AV_PIX_FMT_RGB24;
 
1055
    case AV_PIX_FMT_ABGR:       return AV_PIX_FMT_BGR24;
 
1056
    case AV_PIX_FMT_BGRA:       return AV_PIX_FMT_BGR24;
 
1057
    case AV_PIX_FMT_YA8:        return AV_PIX_FMT_GRAY8;
 
1058
 
 
1059
    case AV_PIX_FMT_YUVA420P:   return AV_PIX_FMT_YUV420P;
 
1060
    case AV_PIX_FMT_YUVA422P:   return AV_PIX_FMT_YUV422P;
 
1061
    case AV_PIX_FMT_YUVA444P:           return AV_PIX_FMT_YUV444P;
 
1062
 
 
1063
    case AV_PIX_FMT_GBRAP:              return AV_PIX_FMT_GBRP;
 
1064
 
 
1065
    case AV_PIX_FMT_GBRAP16LE:          return AV_PIX_FMT_GBRP16;
 
1066
    case AV_PIX_FMT_GBRAP16BE:          return AV_PIX_FMT_GBRP16;
 
1067
 
 
1068
    case AV_PIX_FMT_RGBA64LE:   return AV_PIX_FMT_RGB48;
 
1069
    case AV_PIX_FMT_RGBA64BE:   return AV_PIX_FMT_RGB48;
 
1070
    case AV_PIX_FMT_BGRA64LE:   return AV_PIX_FMT_BGR48;
 
1071
    case AV_PIX_FMT_BGRA64BE:   return AV_PIX_FMT_BGR48;
 
1072
 
 
1073
    case AV_PIX_FMT_YA16BE:             return AV_PIX_FMT_GRAY16;
 
1074
    case AV_PIX_FMT_YA16LE:             return AV_PIX_FMT_GRAY16;
 
1075
 
 
1076
    case AV_PIX_FMT_YUVA420P9BE:        return AV_PIX_FMT_YUV420P9;
 
1077
    case AV_PIX_FMT_YUVA422P9BE:        return AV_PIX_FMT_YUV422P9;
 
1078
    case AV_PIX_FMT_YUVA444P9BE:        return AV_PIX_FMT_YUV444P9;
 
1079
    case AV_PIX_FMT_YUVA420P9LE:        return AV_PIX_FMT_YUV420P9;
 
1080
    case AV_PIX_FMT_YUVA422P9LE:        return AV_PIX_FMT_YUV422P9;
 
1081
    case AV_PIX_FMT_YUVA444P9LE:        return AV_PIX_FMT_YUV444P9;
 
1082
    case AV_PIX_FMT_YUVA420P10BE:       return AV_PIX_FMT_YUV420P10;
 
1083
    case AV_PIX_FMT_YUVA422P10BE:       return AV_PIX_FMT_YUV422P10;
 
1084
    case AV_PIX_FMT_YUVA444P10BE:       return AV_PIX_FMT_YUV444P10;
 
1085
    case AV_PIX_FMT_YUVA420P10LE:       return AV_PIX_FMT_YUV420P10;
 
1086
    case AV_PIX_FMT_YUVA422P10LE:       return AV_PIX_FMT_YUV422P10;
 
1087
    case AV_PIX_FMT_YUVA444P10LE:       return AV_PIX_FMT_YUV444P10;
 
1088
    case AV_PIX_FMT_YUVA420P16BE:       return AV_PIX_FMT_YUV420P16;
 
1089
    case AV_PIX_FMT_YUVA422P16BE:       return AV_PIX_FMT_YUV422P16;
 
1090
    case AV_PIX_FMT_YUVA444P16BE:       return AV_PIX_FMT_YUV444P16;
 
1091
    case AV_PIX_FMT_YUVA420P16LE:       return AV_PIX_FMT_YUV420P16;
 
1092
    case AV_PIX_FMT_YUVA422P16LE:       return AV_PIX_FMT_YUV422P16;
 
1093
    case AV_PIX_FMT_YUVA444P16LE:       return AV_PIX_FMT_YUV444P16;
 
1094
 
 
1095
//     case AV_PIX_FMT_AYUV64LE:
 
1096
//     case AV_PIX_FMT_AYUV64BE:
 
1097
//     case AV_PIX_FMT_PAL8:
 
1098
    default: return AV_PIX_FMT_NONE;
 
1099
    }
 
1100
}
 
1101
 
981
1102
av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
982
1103
                             SwsFilter *dstFilter)
983
1104
{
1036
1157
        return AVERROR(EINVAL);
1037
1158
    }
1038
1159
    }
 
1160
    av_assert2(desc_src && desc_dst);
1039
1161
 
1040
1162
    i = flags & (SWS_POINT         |
1041
1163
                 SWS_AREA          |
1157
1279
    if (flags & SWS_FULL_CHR_H_INT &&
1158
1280
        isAnyRGB(dstFormat)        &&
1159
1281
        !isPlanarRGB(dstFormat)    &&
 
1282
        dstFormat != AV_PIX_FMT_RGBA64LE &&
 
1283
        dstFormat != AV_PIX_FMT_RGBA64BE &&
 
1284
        dstFormat != AV_PIX_FMT_BGRA64LE &&
 
1285
        dstFormat != AV_PIX_FMT_BGRA64BE &&
 
1286
        dstFormat != AV_PIX_FMT_RGB48LE &&
 
1287
        dstFormat != AV_PIX_FMT_RGB48BE &&
 
1288
        dstFormat != AV_PIX_FMT_BGR48LE &&
 
1289
        dstFormat != AV_PIX_FMT_BGR48BE &&
1160
1290
        dstFormat != AV_PIX_FMT_RGBA  &&
1161
1291
        dstFormat != AV_PIX_FMT_ARGB  &&
1162
1292
        dstFormat != AV_PIX_FMT_BGRA  &&
1289
1419
        if (!c2->gamma || !c2->inv_gamma)
1290
1420
            return AVERROR(ENOMEM);
1291
1421
 
 
1422
        // is_internal_flag is set after creating the context
 
1423
        // to properly create the gamma convert FilterDescriptor
 
1424
        // we have to re-initialize it
 
1425
        ff_free_filters(c2);
 
1426
        if (ff_init_filters(c2) < 0) {
 
1427
            sws_freeContext(c2);
 
1428
            return -1;
 
1429
        }
 
1430
 
1292
1431
        c->cascaded_context[2] = NULL;
1293
1432
        if (dstFormat != tmpFmt) {
1294
1433
            ret = av_image_alloc(c->cascaded1_tmp, c->cascaded1_tmpStride,
1330
1469
        }
1331
1470
    }
1332
1471
 
 
1472
    if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
 
1473
        enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
 
1474
 
 
1475
        if (tmpFormat != AV_PIX_FMT_NONE && c->alphablend != SWS_ALPHA_BLEND_NONE)
 
1476
        if (!unscaled ||
 
1477
            dstFormat != tmpFormat ||
 
1478
            usesHFilter || usesVFilter ||
 
1479
            c->srcRange != c->dstRange
 
1480
        ) {
 
1481
            ret = av_image_alloc(c->cascaded_tmp, c->cascaded_tmpStride,
 
1482
                                srcW, srcH, tmpFormat, 64);
 
1483
            if (ret < 0)
 
1484
                return ret;
 
1485
 
 
1486
            c->cascaded_context[0] = sws_alloc_set_opts(srcW, srcH, srcFormat,
 
1487
                                                        srcW, srcH, tmpFormat,
 
1488
                                                        flags, c->param);
 
1489
            if (!c->cascaded_context[0])
 
1490
                return -1;
 
1491
            c->cascaded_context[0]->alphablend = c->alphablend;
 
1492
            ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
 
1493
            if (ret < 0)
 
1494
                return ret;
 
1495
 
 
1496
            c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
 
1497
                                                    dstW, dstH, dstFormat,
 
1498
                                                    flags, srcFilter, dstFilter, c->param);
 
1499
            if (!c->cascaded_context[1])
 
1500
                return -1;
 
1501
            return 0;
 
1502
        }
 
1503
    }
 
1504
 
1333
1505
#define USE_MMAP (HAVE_MMAP && HAVE_MPROTECT && defined MAP_ANONYMOUS)
1334
1506
 
1335
1507
    /* precalculate horizontal scaler filter coefficients */
1576
1748
               c->chrXInc, c->chrYInc);
1577
1749
    }
1578
1750
 
 
1751
    /* alpha blend special case, note this has been split via cascaded contexts if its scaled */
 
1752
    if (unscaled && !usesHFilter && !usesVFilter &&
 
1753
        c->alphablend != SWS_ALPHA_BLEND_NONE &&
 
1754
        isALPHA(srcFormat) &&
 
1755
        (c->srcRange == c->dstRange || isAnyRGB(dstFormat)) &&
 
1756
        alphaless_fmt(srcFormat) == dstFormat
 
1757
    ) {
 
1758
        c->swscale = ff_sws_alphablendaway;
 
1759
 
 
1760
        if (flags & SWS_PRINT_INFO)
 
1761
            av_log(c, AV_LOG_INFO,
 
1762
                    "using alpha blendaway %s -> %s special converter\n",
 
1763
                    av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
 
1764
        return 0;
 
1765
    }
 
1766
 
1579
1767
    /* unscaled special cases */
1580
1768
    if (unscaled && !usesHFilter && !usesVFilter &&
1581
1769
        (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
1591
1779
    }
1592
1780
 
1593
1781
    c->swscale = ff_getSwsFunc(c);
1594
 
    return 0;
 
1782
    return ff_init_filters(c);
1595
1783
fail: // FIXME replace things by appropriate error codes
1596
1784
    if (ret == RETCODE_USE_CASCADE)  {
1597
1785
        int tmpW = sqrt(srcW * (int64_t)dstW);
1622
1810
    return -1;
1623
1811
}
1624
1812
 
1625
 
SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
1626
 
                           int dstW, int dstH, enum AVPixelFormat dstFormat,
1627
 
                           int flags, SwsFilter *srcFilter,
1628
 
                           SwsFilter *dstFilter, const double *param)
 
1813
SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
 
1814
                               int dstW, int dstH, enum AVPixelFormat dstFormat,
 
1815
                               int flags, const double *param)
1629
1816
{
1630
1817
    SwsContext *c;
1631
1818
 
1645
1832
        c->param[1] = param[1];
1646
1833
    }
1647
1834
 
 
1835
    return c;
 
1836
}
 
1837
 
 
1838
SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
 
1839
                           int dstW, int dstH, enum AVPixelFormat dstFormat,
 
1840
                           int flags, SwsFilter *srcFilter,
 
1841
                           SwsFilter *dstFilter, const double *param)
 
1842
{
 
1843
    SwsContext *c;
 
1844
 
 
1845
    c = sws_alloc_set_opts(srcW, srcH, srcFormat,
 
1846
                           dstW, dstH, dstFormat,
 
1847
                           flags, param);
 
1848
    if (!c)
 
1849
        return NULL;
 
1850
 
1648
1851
    if (sws_init_context(c, srcFilter, dstFilter) < 0) {
1649
1852
        sws_freeContext(c);
1650
1853
        return NULL;
1653
1856
    return c;
1654
1857
}
1655
1858
 
 
1859
static int isnan_vec(SwsVector *a)
 
1860
{
 
1861
    int i;
 
1862
    for (i=0; i<a->length; i++)
 
1863
        if (isnan(a->coeff[i]))
 
1864
            return 1;
 
1865
    return 0;
 
1866
}
 
1867
 
 
1868
static void makenan_vec(SwsVector *a)
 
1869
{
 
1870
    int i;
 
1871
    for (i=0; i<a->length; i++)
 
1872
        a->coeff[i] = NAN;
 
1873
}
 
1874
 
1656
1875
SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur,
1657
1876
                                float lumaSharpen, float chromaSharpen,
1658
1877
                                float chromaHShift, float chromaVShift,
1714
1933
    sws_normalizeVec(filter->lumH, 1.0);
1715
1934
    sws_normalizeVec(filter->lumV, 1.0);
1716
1935
 
 
1936
    if (isnan_vec(filter->chrH) ||
 
1937
        isnan_vec(filter->chrV) ||
 
1938
        isnan_vec(filter->lumH) ||
 
1939
        isnan_vec(filter->lumV))
 
1940
        goto fail;
 
1941
 
1717
1942
    if (verbose)
1718
1943
        sws_printVec2(filter->chrH, NULL, AV_LOG_DEBUG);
1719
1944
    if (verbose)
1889
2114
void sws_shiftVec(SwsVector *a, int shift)
1890
2115
{
1891
2116
    SwsVector *shifted = sws_getShiftedVec(a, shift);
 
2117
    if (!shifted) {
 
2118
        makenan_vec(a);
 
2119
        return;
 
2120
    }
1892
2121
    av_free(a->coeff);
1893
2122
    a->coeff  = shifted->coeff;
1894
2123
    a->length = shifted->length;
1898
2127
void sws_addVec(SwsVector *a, SwsVector *b)
1899
2128
{
1900
2129
    SwsVector *sum = sws_sumVec(a, b);
 
2130
    if (!sum) {
 
2131
        makenan_vec(a);
 
2132
        return;
 
2133
    }
1901
2134
    av_free(a->coeff);
1902
2135
    a->coeff  = sum->coeff;
1903
2136
    a->length = sum->length;
1907
2140
void sws_subVec(SwsVector *a, SwsVector *b)
1908
2141
{
1909
2142
    SwsVector *diff = sws_diffVec(a, b);
 
2143
    if (!diff) {
 
2144
        makenan_vec(a);
 
2145
        return;
 
2146
    }
1910
2147
    av_free(a->coeff);
1911
2148
    a->coeff  = diff->coeff;
1912
2149
    a->length = diff->length;
1916
2153
void sws_convVec(SwsVector *a, SwsVector *b)
1917
2154
{
1918
2155
    SwsVector *conv = sws_getConvVec(a, b);
 
2156
    if (!conv) {
 
2157
        makenan_vec(a);
 
2158
        return;
 
2159
    }
1919
2160
    av_free(a->coeff);
1920
2161
    a->coeff  = conv->coeff;
1921
2162
    a->length = conv->length;
2055
2296
    av_freep(&c->gamma);
2056
2297
    av_freep(&c->inv_gamma);
2057
2298
 
 
2299
    ff_free_filters(c);
2058
2300
 
2059
2301
    av_free(c);
2060
2302
}