xpra icon
Bug tracker and wiki

This bug tracker and wiki are being discontinued
please use https://github.com/Xpra-org/xpra instead.


Ticket #784: bpg-v0.patch

File bpg-v0.patch, 145.5 KB (added by Antoine Martin, 6 years ago)

updated patch including a modified libbpg bundled in

  • xpra/codecs/bpg/__init__.py

     
     1# This file is part of Xpra.
     2# Copyright (C) 2015 Antoine Martin <antoine@devloop.org.uk>
     3# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
     4# later version. See the file COPYING for details.
  • xpra/codecs/bpg/bpgenc.c

     
     1/*
     2 * BPG encoder
     3 *
     4 * Copyright (c) 2014 Fabrice Bellard
     5 *
     6 * Permission is hereby granted, free of charge, to any person obtaining a copy
     7 * of this software and associated documentation files (the "Software"), to deal
     8 * in the Software without restriction, including without limitation the rights
     9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     10 * copies of the Software, and to permit persons to whom the Software is
     11 * furnished to do so, subject to the following conditions:
     12 *
     13 * The above copyright notice and this permission notice shall be included in
     14 * all copies or substantial portions of the Software.
     15 *
     16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     22 * THE SOFTWARE.
     23 */
     24#include <stdlib.h>
     25#include <stdio.h>
     26#include <string.h>
     27#include <inttypes.h>
     28#include <getopt.h>
     29#include <math.h>
     30#include <assert.h>
     31
     32#include <png.h>
     33#include <jpeglib.h>
     34
     35#include "bpgenc.h"
     36
     37#define CONFIG_BPG_VERSION 0.9.5
     38
     39typedef uint16_t PIXEL;
     40
     41static void put_ue(uint8_t **pp, uint32_t v);
     42
     43static inline int clamp_pix(int a, int pixel_max)
     44{
     45    if (a < 0)
     46        return 0;
     47    else if (a > pixel_max)
     48        return pixel_max;
     49    else
     50        return a;
     51}
     52
     53static inline int sub_mod_int(int a, int b, int m)
     54{
     55    a -= b;
     56    if (a < 0)
     57        a += m;
     58    return a;
     59}
     60
     61static inline int add_mod_int(int a, int b, int m)
     62{
     63    a += b;
     64    if (a >= m)
     65        a -= m;
     66    return a;
     67}
     68
     69typedef struct {
     70    int c_shift;
     71    int c_rnd;
     72    int c_0_25, c_0_5, c_one;
     73    int rgb_to_ycc[3 * 3];
     74    int y_one;
     75    int y_offset;
     76    int bit_depth;
     77    int pixel_max;
     78    int c_center;
     79} ColorConvertState;
     80
     81static void convert_init(ColorConvertState *s, int in_bit_depth,
     82                         int out_bit_depth, BPGColorSpaceEnum color_space,
     83                         int limited_range)
     84{
     85    double k_r, k_b, mult, mult_y, mult_c;
     86    int in_pixel_max, out_pixel_max, c_shift, i;
     87    double rgb_to_ycc[3 * 3];
     88
     89    /* XXX: could use one more bit */
     90    c_shift = 31 - out_bit_depth;
     91    in_pixel_max = (1 << in_bit_depth) - 1;
     92    out_pixel_max = (1 << out_bit_depth) - 1;
     93    mult = (double)out_pixel_max * (1 << c_shift) / (double)in_pixel_max;
     94    //    printf("mult=%f c_shift=%d\n", mult, c_shift);
     95    if (limited_range) {
     96        mult_y = (double)(219 << (out_bit_depth - 8)) * (1 << c_shift) /
     97            (double)in_pixel_max;
     98        mult_c = (double)(224 << (out_bit_depth - 8)) * (1 << c_shift) /
     99            (double)in_pixel_max;
     100    } else {
     101        mult_y = mult;
     102        mult_c = mult;
     103    }
     104    switch(color_space) {
     105    case BPG_CS_YCbCr:
     106        k_r = 0.299;
     107        k_b = 0.114;
     108        goto convert_ycc;
     109       
     110    case BPG_CS_YCbCr_BT709:
     111        k_r = 0.2126;
     112        k_b = 0.0722;
     113        goto convert_ycc;
     114       
     115    case BPG_CS_YCbCr_BT2020:
     116        k_r = 0.2627;
     117        k_b = 0.0593;
     118    convert_ycc:
     119        rgb_to_ycc[0] = k_r;
     120        rgb_to_ycc[1] = 1 - k_r - k_b;
     121        rgb_to_ycc[2] = k_b;
     122        rgb_to_ycc[3] = -0.5 * k_r / (1 - k_b);
     123        rgb_to_ycc[4] = -0.5 * (1 - k_r - k_b) / (1 - k_b);
     124        rgb_to_ycc[5] = 0.5;
     125        rgb_to_ycc[6] = 0.5;
     126        rgb_to_ycc[7] = -0.5 * (1 - k_r - k_b) / (1 - k_r);
     127        rgb_to_ycc[8] = -0.5 * k_b / (1 - k_r);
     128       
     129        for(i = 0; i < 3; i++)
     130            s->rgb_to_ycc[i] = lrint(rgb_to_ycc[i] * mult_y);
     131        for(i = 3; i < 9; i++)
     132            s->rgb_to_ycc[i] = lrint(rgb_to_ycc[i] * mult_c);
     133        break;
     134    case BPG_CS_YCgCo:
     135        s->c_0_25 = lrint(0.25 * mult_y);
     136        s->c_0_5 = lrint(0.5 * mult_y);
     137        break;
     138    default:
     139        break;
     140    }
     141
     142    s->c_one = lrint(mult);
     143    s->c_shift = c_shift;
     144    s->c_rnd = (1 << (c_shift - 1));
     145    if (limited_range) {
     146        s->y_offset = s->c_rnd + (16 << (c_shift + out_bit_depth - 8));
     147        s->y_one = lrint(mult_y);
     148    } else {
     149        s->y_offset = s->c_rnd;
     150        s->y_one = s->c_one;
     151    }
     152
     153    s->bit_depth = out_bit_depth;
     154    s->c_center = 1 << (out_bit_depth - 1);
     155    s->pixel_max = out_pixel_max;
     156}
     157
     158/* 8 bit input */
     159static void rgb24_to_ycc(ColorConvertState *s,
     160                         PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     161                         const void *src1, int n, int incr)
     162{
     163    const uint8_t *src = src1;
     164    int i, r, g, b, c0, c1, c2, c3, c4, c5, c6, c7, c8, shift, rnd, center;
     165    int pixel_max, y_offset;
     166
     167    c0 = s->rgb_to_ycc[0];
     168    c1 = s->rgb_to_ycc[1];
     169    c2 = s->rgb_to_ycc[2];
     170    c3 = s->rgb_to_ycc[3];
     171    c4 = s->rgb_to_ycc[4];
     172    c5 = s->rgb_to_ycc[5];
     173    c6 = s->rgb_to_ycc[6];
     174    c7 = s->rgb_to_ycc[7];
     175    c8 = s->rgb_to_ycc[8];
     176    shift = s->c_shift;
     177    rnd = s->c_rnd;
     178    y_offset = s->y_offset;
     179    center = s->c_center;
     180    pixel_max = s->pixel_max;
     181    for(i = 0; i < n; i++) {
     182        r = src[0];
     183        g = src[1];
     184        b = src[2];
     185        y_ptr[i] = clamp_pix((c0 * r + c1 * g + c2 * b +
     186                              y_offset) >> shift, pixel_max);
     187        cb_ptr[i] = clamp_pix(((c3 * r + c4 * g + c5 * b +
     188                                rnd) >> shift) + center, pixel_max);
     189        cr_ptr[i] = clamp_pix(((c6 * r + c7 * g + c8 * b +
     190                                rnd) >> shift) + center, pixel_max);
     191        src += incr;
     192    }
     193}
     194
     195static void rgb24_to_rgb(ColorConvertState *s,
     196                         PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     197                         const void *src1, int n, int incr)
     198{
     199    const uint8_t *src = src1;
     200    int i, r, g, b, c, shift, rnd;
     201
     202    c = s->y_one;
     203    shift = s->c_shift;
     204    rnd = s->y_offset;
     205    for(i = 0; i < n; i++) {
     206        r = src[0];
     207        g = src[1];
     208        b = src[2];
     209        y_ptr[i] = (c * g + rnd) >> shift;
     210        cb_ptr[i] = (c * b + rnd) >> shift;
     211        cr_ptr[i] = (c * r + rnd) >> shift;
     212        src += incr;
     213    }
     214}
     215
     216static void rgb24_to_ycgco(ColorConvertState *s,
     217                           PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     218                           const void *src1, int n, int incr)
     219{
     220    const uint8_t *src = src1;
     221    int i, r, g, b, t1, t2, pixel_max, c_0_5, c_0_25, rnd, shift, center;
     222    int y_offset;
     223
     224    c_0_25 = s->c_0_25;
     225    c_0_5 = s->c_0_5;
     226    rnd = s->c_rnd;
     227    shift = s->c_shift;
     228    pixel_max = s->pixel_max;
     229    center = s->c_center;
     230    y_offset = s->y_offset;
     231    for(i = 0; i < n; i++) {
     232        r = src[0];
     233        g = src[1];
     234        b = src[2];
     235        t1 = c_0_5 * g;
     236        t2 = c_0_25 * (r + b);
     237        y_ptr[i] = clamp_pix((t1 + t2 + y_offset) >> shift, pixel_max);
     238        cb_ptr[i] = clamp_pix(((t1 - t2 + rnd) >> shift) + center,
     239                              pixel_max);
     240        cr_ptr[i] = clamp_pix(((c_0_5 * (r - b) +
     241                                rnd) >> shift) + center, pixel_max);
     242        src += incr;
     243    }
     244}
     245
     246/* Note: used for alpha/W so no limited range */
     247static void gray8_to_gray(ColorConvertState *s,
     248                          PIXEL *y_ptr, const uint8_t *src, int n, int incr)
     249{
     250    int i, g, c, shift, rnd;
     251
     252    c = s->c_one;
     253    shift = s->c_shift;
     254    rnd = s->c_rnd;
     255    for(i = 0; i < n; i++) {
     256        g = src[0];
     257        y_ptr[i] = (c * g + rnd) >> shift;
     258        src += incr;
     259    }
     260}
     261
     262static void luma8_to_gray(ColorConvertState *s,
     263                          PIXEL *y_ptr, const uint8_t *src, int n, int incr)
     264{
     265    int i, g, c, shift, rnd;
     266
     267    c = s->y_one;
     268    shift = s->c_shift;
     269    rnd = s->y_offset;
     270    for(i = 0; i < n; i++) {
     271        g = src[0];
     272        y_ptr[i] = (c * g + rnd) >> shift;
     273        src += incr;
     274    }
     275}
     276
     277/* 16 bit input */
     278
     279static void rgb48_to_ycc(ColorConvertState *s,
     280                         PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     281                         const void *src1, int n, int incr)
     282{
     283    const uint16_t *src = src1;
     284    int i, r, g, b, c0, c1, c2, c3, c4, c5, c6, c7, c8, shift, rnd, center;
     285    int pixel_max, y_offset;
     286
     287    c0 = s->rgb_to_ycc[0];
     288    c1 = s->rgb_to_ycc[1];
     289    c2 = s->rgb_to_ycc[2];
     290    c3 = s->rgb_to_ycc[3];
     291    c4 = s->rgb_to_ycc[4];
     292    c5 = s->rgb_to_ycc[5];
     293    c6 = s->rgb_to_ycc[6];
     294    c7 = s->rgb_to_ycc[7];
     295    c8 = s->rgb_to_ycc[8];
     296    shift = s->c_shift;
     297    rnd = s->c_rnd;
     298    y_offset = s->y_offset;
     299    center = s->c_center;
     300    pixel_max = s->pixel_max;
     301    for(i = 0; i < n; i++) {
     302        r = src[0];
     303        g = src[1];
     304        b = src[2];
     305        y_ptr[i] = clamp_pix((c0 * r + c1 * g + c2 * b +
     306                              y_offset) >> shift, pixel_max);
     307        cb_ptr[i] = clamp_pix(((c3 * r + c4 * g + c5 * b +
     308                                rnd) >> shift) + center, pixel_max);
     309        cr_ptr[i] = clamp_pix(((c6 * r + c7 * g + c8 * b +
     310                                rnd) >> shift) + center, pixel_max);
     311        src += incr;
     312    }
     313}
     314
     315static void rgb48_to_ycgco(ColorConvertState *s,
     316                           PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     317                           const void *src1, int n, int incr)
     318{
     319    const uint16_t *src = src1;
     320    int i, r, g, b, t1, t2, pixel_max, c_0_5, c_0_25, rnd, shift, center;
     321    int y_offset;
     322
     323    c_0_25 = s->c_0_25;
     324    c_0_5 = s->c_0_5;
     325    rnd = s->c_rnd;
     326    y_offset = s->y_offset;
     327    shift = s->c_shift;
     328    pixel_max = s->pixel_max;
     329    center = s->c_center;
     330    for(i = 0; i < n; i++) {
     331        r = src[0];
     332        g = src[1];
     333        b = src[2];
     334        t1 = c_0_5 * g;
     335        t2 = c_0_25 * (r + b);
     336        y_ptr[i] = clamp_pix((t1 + t2 + y_offset) >> shift, pixel_max);
     337        cb_ptr[i] = clamp_pix(((t1 - t2 + rnd) >> shift) + center,
     338                              pixel_max);
     339        cr_ptr[i] = clamp_pix(((c_0_5 * (r - b) +
     340                                rnd) >> shift) + center, pixel_max);
     341        src += incr;
     342    }
     343}
     344
     345/* Note: use for alpha/W so no limited range */
     346static void gray16_to_gray(ColorConvertState *s,
     347                           PIXEL *y_ptr, const uint16_t *src, int n, int incr)
     348{
     349    int i, g, c, shift, rnd;
     350
     351    c = s->c_one;
     352    shift = s->c_shift;
     353    rnd = s->c_rnd;
     354    for(i = 0; i < n; i++) {
     355        g = src[0];
     356        y_ptr[i] = (c * g + rnd) >> shift;
     357        src += incr;
     358    }
     359}
     360
     361static void luma16_to_gray(ColorConvertState *s,
     362                           PIXEL *y_ptr, const uint16_t *src, int n, int incr)
     363{
     364    int i, g, c, shift, rnd;
     365
     366    c = s->y_one;
     367    shift = s->c_shift;
     368    rnd = s->y_offset;
     369    for(i = 0; i < n; i++) {
     370        g = src[0];
     371        y_ptr[i] = (c * g + rnd) >> shift;
     372        src += incr;
     373    }
     374}
     375
     376static void rgb48_to_rgb(ColorConvertState *s,
     377                         PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     378                         const void *src1, int n, int incr)
     379{
     380    const uint16_t *src = src1;
     381
     382    luma16_to_gray(s, y_ptr, src + 1, n, incr);
     383    luma16_to_gray(s, cb_ptr, src + 2, n, incr);
     384    luma16_to_gray(s, cr_ptr, src + 0, n, incr);
     385}
     386
     387typedef void RGBConvertFunc(ColorConvertState *s,
     388                            PIXEL *y_ptr, PIXEL *cb_ptr, PIXEL *cr_ptr,
     389                            const void *src, int n, int incr);
     390
     391static RGBConvertFunc *rgb_to_cs[2][BPG_CS_COUNT] = {
     392    {
     393        rgb24_to_ycc,
     394        rgb24_to_rgb,
     395        rgb24_to_ycgco,
     396        rgb24_to_ycc,
     397        rgb24_to_ycc,
     398    },
     399    {
     400        rgb48_to_ycc,
     401        rgb48_to_rgb,
     402        rgb48_to_ycgco,
     403        rgb48_to_ycc,
     404        rgb48_to_ycc,
     405    }
     406};
     407   
     408/* val = 1.0 - val */
     409static void gray_one_minus(ColorConvertState *s, PIXEL *y_ptr, int n)
     410{
     411    int pixel_max = s->pixel_max;
     412    int i;
     413
     414    for(i = 0; i < n; i++) {
     415        y_ptr[i] = pixel_max - y_ptr[i];
     416    }
     417}
     418
     419/* val = -val for chroma */
     420static void gray_neg_c(ColorConvertState *s, PIXEL *y_ptr, int n)
     421{
     422    int pixel_max = s->pixel_max;
     423    int i, v;
     424
     425    for(i = 0; i < n; i++) {
     426        v = y_ptr[i];
     427        if (v == 0)
     428            v = pixel_max;
     429        else
     430            v = pixel_max + 1 - v;
     431        y_ptr[i] = v;
     432    }
     433}
     434
     435
     436/* decimation */
     437
     438/* phase = 0 */
     439#define DP0TAPS2 7
     440#define DP0TAPS (2 * DP0TAPS + 1)
     441#define DP0C0 64
     442#define DP0C1 40
     443#define DP0C3 (-11)
     444#define DP0C5 4
     445#define DP0C7 (-1)
     446
     447/* phase = 0.5 */
     448#define DP1TAPS2 5
     449#define DP1TAPS (2 * DP1TAPS2)
     450#define DP1C0 57
     451#define DP1C1 17
     452#define DP1C2 (-8)
     453#define DP1C3 (-4)
     454#define DP1C4 2
     455
     456#define DTAPS_MAX 7
     457
     458/* chroma aligned with luma samples */
     459static void decimate2p0_simple(PIXEL *dst, PIXEL *src, int n, int bit_depth)
     460{
     461    int n2, i, pixel_max;
     462    pixel_max = (1 << bit_depth) - 1;
     463    n2 = (n + 1) / 2;
     464    for(i = 0; i < n2; i++) {
     465        dst[i] = clamp_pix(((src[-7] + src[7]) * DP0C7 +
     466                            (src[-5] + src[5]) * DP0C5 +
     467                            (src[-3] + src[3]) * DP0C3 +
     468                            (src[-1] + src[1]) * DP0C1 +
     469                            src[0] * DP0C0 + 64) >> 7, pixel_max);
     470        src += 2;
     471    }
     472}
     473
     474/* same with more precision and no saturation */
     475static void decimate2p0_simple16(int16_t *dst, PIXEL *src, int n, int bit_depth)
     476{
     477    int n2, i, shift, rnd;
     478    shift = bit_depth - 7;
     479    rnd = 1 << (shift - 1);
     480    n2 = (n + 1) / 2;
     481    for(i = 0; i < n2; i++) {
     482        dst[i] = ((src[-7] + src[7]) * DP0C7 +
     483                  (src[-5] + src[5]) * DP0C5 +
     484                  (src[-3] + src[3]) * DP0C3 +
     485                  (src[-1] + src[1]) * DP0C1 +
     486                  src[0] * DP0C0 + rnd) >> shift;
     487    src += 2;
     488    }
     489}
     490
     491
     492/* chroma half way between luma samples */
     493static void decimate2p1_simple(PIXEL *dst, PIXEL *src, int n, int bit_depth)
     494{
     495    int n2, i, pixel_max;
     496    pixel_max = (1 << bit_depth) - 1;
     497    n2 = (n + 1) / 2;
     498    for(i = 0; i < n2; i++) {
     499        dst[i] = clamp_pix(((src[-4] + src[5]) * DP1C4 +
     500                            (src[-3] + src[4]) * DP1C3 +
     501                            (src[-2] + src[3]) * DP1C2 +
     502                            (src[-1] + src[2]) * DP1C1 +
     503                            (src[0] + src[1]) * DP1C0 + 64) >> 7, pixel_max);
     504        src += 2;
     505    }
     506}
     507
     508/* same with more precision and no saturation */
     509static void decimate2p1_simple16(int16_t *dst, PIXEL *src, int n, int bit_depth)
     510{
     511    int n2, i, shift, rnd;
     512    shift = bit_depth - 7;
     513    rnd = 1 << (shift - 1);
     514    n2 = (n + 1) / 2;
     515    for(i = 0; i < n2; i++) {
     516        dst[i] = ((src[-4] + src[5]) * DP1C4 +
     517                  (src[-3] + src[4]) * DP1C3 +
     518                  (src[-2] + src[3]) * DP1C2 +
     519                  (src[-1] + src[2]) * DP1C1 +
     520                  (src[0] + src[1]) * DP1C0 + rnd) >> shift;
     521        src += 2;
     522    }
     523}
     524
     525static void decimate2_h(PIXEL *dst, PIXEL *src, int n, int bit_depth, int phase)
     526{
     527    PIXEL *src1, v;
     528    int d, i;
     529
     530    if (phase == 0)
     531        d = DP0TAPS2;
     532    else
     533        d = DP1TAPS2;
     534    /* add edge pixels */
     535    src1 = malloc(sizeof(PIXEL) * (n + 2 * d));
     536    v = src[0];
     537    for(i = 0; i < d; i++)
     538        src1[i] = v;
     539    memcpy(src1 + d, src, n * sizeof(PIXEL));
     540    v = src[n - 1];
     541    for(i = 0; i < d; i++)
     542        src1[d + n + i] = v;
     543    if (phase == 0)
     544        decimate2p0_simple(dst, src1 + d, n, bit_depth);
     545    else
     546        decimate2p1_simple(dst, src1 + d, n, bit_depth);
     547    free(src1);
     548}
     549
     550/* src1 is a temporary buffer of length n + 2 * DTAPS */
     551static void decimate2_h16(int16_t *dst, PIXEL *src, int n, PIXEL *src1,
     552                          int bit_depth, int phase)
     553{
     554    PIXEL v;
     555    int d, i;
     556
     557    if (phase == 0)
     558        d = DP0TAPS2;
     559    else
     560        d = DP1TAPS2;
     561    /* add edge pixels */
     562    v = src[0];
     563    for(i = 0; i < d; i++)
     564        src1[i] = v;
     565    memcpy(src1 + d, src, n * sizeof(PIXEL));
     566    v = src[n - 1];
     567    for(i = 0; i < d; i++)
     568        src1[d + n + i] = v;
     569    if (phase == 0)
     570        decimate2p0_simple16(dst, src1 + d, n, bit_depth);
     571    else
     572        decimate2p1_simple16(dst, src1 + d, n, bit_depth);
     573       
     574}
     575
     576static void decimate2_v(PIXEL *dst, int16_t **src, int pos, int n,
     577                        int bit_depth)
     578{
     579    int16_t *src0, *src1, *src2, *src3, *src4, *src5, *srcm1, *srcm2, *srcm3, *srcm4;
     580    int i, shift, offset, pixel_max;
     581
     582    pos = sub_mod_int(pos, 4, DP1TAPS);
     583    srcm4 = src[pos];
     584    pos = add_mod_int(pos, 1, DP1TAPS);
     585    srcm3 = src[pos];
     586    pos = add_mod_int(pos, 1, DP1TAPS);
     587    srcm2 = src[pos];
     588    pos = add_mod_int(pos, 1, DP1TAPS);
     589    srcm1 = src[pos];
     590    pos = add_mod_int(pos, 1, DP1TAPS);
     591    src0 = src[pos];
     592    pos = add_mod_int(pos, 1, DP1TAPS);
     593    src1 = src[pos];
     594    pos = add_mod_int(pos, 1, DP1TAPS);
     595    src2 = src[pos];
     596    pos = add_mod_int(pos, 1, DP1TAPS);
     597    src3 = src[pos];
     598    pos = add_mod_int(pos, 1, DP1TAPS);
     599    src4 = src[pos];
     600    pos = add_mod_int(pos, 1, DP1TAPS);
     601    src5 = src[pos];
     602   
     603    shift = 21 - bit_depth;
     604    offset = 1 << (shift - 1);
     605    pixel_max = (1 << bit_depth) - 1;
     606    for(i = 0; i < n; i++) {
     607        dst[i] = clamp_pix(((srcm4[i] + src5[i]) * DP1C4 +
     608                            (srcm3[i] + src4[i]) * DP1C3 +
     609                            (srcm2[i] + src3[i]) * DP1C2 +
     610                            (srcm1[i] + src2[i]) * DP1C1 +
     611                            (src0[i] + src1[i]) * DP1C0 + offset) >> shift, pixel_max);
     612    }
     613}
     614
     615/* Note: we do the horizontal decimation first to use less CPU cache */
     616static void decimate2_hv(uint8_t *dst, int dst_linesize,
     617                         uint8_t *src, int src_linesize,
     618                         int w, int h, int bit_depth, int h_phase)
     619{
     620    PIXEL *buf1;
     621    int16_t *buf2[DP1TAPS];
     622    int w2, pos, i, y, y1, y2;
     623   
     624    w2 = (w + 1) / 2;
     625
     626    buf1 = malloc(sizeof(PIXEL) * (w + 2 * DTAPS_MAX));
     627    /* init line buffer */
     628    for(i = 0; i < DP1TAPS; i++) {
     629        buf2[i] = malloc(sizeof(int16_t) * w2);
     630        y = i;
     631        if (y > DP1TAPS2)
     632            y -= DP1TAPS;
     633        if (y < 0) {
     634            /* copy from first line */
     635            memcpy(buf2[i], buf2[0], sizeof(int16_t) * w2);
     636        } else if (y >= h) {
     637            /* copy from last line (only happens for small height) */
     638            memcpy(buf2[i], buf2[h - 1], sizeof(int16_t) * w2);
     639        } else {
     640            decimate2_h16(buf2[i], (PIXEL *)(src + src_linesize * y), w,
     641                          buf1, bit_depth, h_phase);
     642        }
     643    }
     644
     645    for(y = 0; y < h; y++) {
     646        pos = y % DP1TAPS;
     647        if ((y & 1) == 0) {
     648            /* filter one line */
     649            y2 = y >> 1;
     650            decimate2_v((PIXEL *)(dst + y2 * dst_linesize), buf2,
     651                        pos, w2, bit_depth);
     652        }
     653        /* add a new line in the buffer */
     654        y1 = y + DP1TAPS2 + 1;
     655        pos = add_mod_int(pos, DP1TAPS2 + 1, DP1TAPS);
     656        if (y1 >= h) {
     657            /* copy last line */
     658            memcpy(buf2[pos], buf2[sub_mod_int(pos, 1, DP1TAPS)],
     659                   sizeof(int16_t) * w2);
     660        } else {
     661            /* horizontally decimate new line */
     662            decimate2_h16(buf2[pos], (PIXEL *)(src + src_linesize * y1), w,
     663                          buf1, bit_depth, h_phase);
     664        }
     665    }
     666
     667    for(i = 0; i < DP1TAPS; i++)
     668        free(buf2[i]);
     669    free(buf1);
     670}
     671
     672static void get_plane_res(Image *img, int *pw, int *ph, int i)
     673{
     674    if (img->format == BPG_FORMAT_420 && (i == 1 || i == 2)) {
     675        *pw = (img->w + 1) / 2;
     676        *ph = (img->h + 1) / 2;
     677    } else if (img->format == BPG_FORMAT_422 && (i == 1 || i == 2)) {
     678        *pw = (img->w + 1) / 2;
     679        *ph = img->h;
     680    } else {
     681        *pw = img->w;
     682        *ph = img->h;
     683    }
     684}
     685
     686#define W_PAD 16
     687
     688Image *image_alloc(int w, int h, BPGImageFormatEnum format, int has_alpha,
     689                   BPGColorSpaceEnum color_space, int bit_depth)
     690{
     691    Image *img;
     692    int i, linesize, w1, h1, c_count;
     693
     694    img = malloc(sizeof(Image));
     695    memset(img, 0, sizeof(*img));
     696   
     697    img->w = w;
     698    img->h = h;
     699    img->format = format;
     700    img->has_alpha = has_alpha;
     701    img->bit_depth = bit_depth;
     702    img->color_space = color_space;
     703    img->pixel_shift = 1;
     704    img->c_h_phase = 1;
     705
     706    if (img->format == BPG_FORMAT_GRAY)
     707        c_count = 1;
     708    else
     709        c_count = 3;
     710    if (has_alpha)
     711        c_count++;
     712    for(i = 0; i < c_count; i++) {
     713        get_plane_res(img, &w1, &h1, i);
     714        /* multiple of 16 pixels to add borders */
     715        w1 = (w1 + (W_PAD - 1)) & ~(W_PAD - 1);
     716        h1 = (h1 + (W_PAD - 1)) & ~(W_PAD - 1);
     717       
     718        linesize = w1 << img->pixel_shift;
     719        img->data[i] = malloc(linesize * h1);
     720        img->linesize[i] = linesize;
     721    }
     722    return img;
     723}
     724
     725void image_free(Image *img)
     726{
     727    int i, c_count;
     728    if (img->format == BPG_FORMAT_GRAY)
     729        c_count = 1;
     730    else
     731        c_count = 3;
     732    if (img->has_alpha)
     733        c_count++;
     734    for(i = 0; i < c_count; i++)
     735        free(img->data[i]);
     736    free(img);
     737}
     738
     739int image_ycc444_to_ycc422(Image *img, int h_phase)
     740{
     741    uint8_t *data1;
     742    int w1, h1, bpp, linesize1, i, y;
     743
     744    if (img->format != BPG_FORMAT_444 || img->pixel_shift != 1)
     745        return -1;
     746    bpp = 2;
     747    w1 = (img->w + 1) / 2;
     748    w1 = (w1 + (W_PAD - 1)) & ~(W_PAD - 1);
     749    h1 = (img->h + (W_PAD - 1)) & ~(W_PAD - 1);
     750    linesize1 = bpp * w1;
     751    for(i = 1; i <= 2; i++) {
     752        data1 = malloc(linesize1 * h1);
     753        for(y = 0; y < img->h; y++) {
     754            decimate2_h((PIXEL *)(data1 + y * linesize1),
     755                        (PIXEL *)(img->data[i] + y * img->linesize[i]),
     756                        img->w, img->bit_depth, h_phase);
     757        }
     758        free(img->data[i]);
     759        img->data[i] = data1;
     760        img->linesize[i] = linesize1;
     761    }
     762    img->format = BPG_FORMAT_422;
     763    img->c_h_phase = h_phase;
     764    return 0;
     765}
     766
     767int image_ycc444_to_ycc420(Image *img, int h_phase)
     768{
     769    uint8_t *data1;
     770    int w1, h1, bpp, linesize1, i;
     771
     772    if (img->format != BPG_FORMAT_444 || img->pixel_shift != 1)
     773        return -1;
     774    bpp = 2;
     775    w1 = (img->w + 1) / 2;
     776    h1 = (img->h + 1) / 2;
     777    w1 = (w1 + (W_PAD - 1)) & ~(W_PAD - 1);
     778    h1 = (h1 + (W_PAD - 1)) & ~(W_PAD - 1);
     779    linesize1 = bpp * w1;
     780    for(i = 1; i <= 2; i++) {
     781        data1 = malloc(linesize1 * h1);
     782        decimate2_hv(data1, linesize1,
     783                     img->data[i], img->linesize[i],
     784                     img->w, img->h, img->bit_depth, h_phase);
     785        free(img->data[i]);
     786        img->data[i] = data1;
     787        img->linesize[i] = linesize1;
     788    }
     789    img->format = BPG_FORMAT_420;
     790    img->c_h_phase = h_phase;
     791    return 0;
     792}
     793
     794/* duplicate right and bottom samples so that the image has a width
     795   and height multiple of cb_size (power of two) */
     796void image_pad(Image *img, int cb_size)
     797{
     798    int w1, h1, x, y, c_count, c_w, c_h, c_w1, c_h1, h_shift, v_shift, c_idx;
     799    PIXEL *ptr, v, *ptr1;
     800
     801    assert(img->pixel_shift == 1);
     802    if (cb_size <= 1)
     803        return;
     804    w1 = (img->w + cb_size - 1) & ~(cb_size - 1);
     805    h1 = (img->h + cb_size - 1) & ~(cb_size - 1);
     806   
     807    if (img->format == BPG_FORMAT_GRAY)
     808        c_count = 1;
     809    else
     810        c_count = 3;
     811    if (img->has_alpha)
     812        c_count++;
     813    for(c_idx = 0; c_idx < c_count; c_idx++) {
     814        if (img->format == BPG_FORMAT_420 &&
     815            (c_idx == 1 || c_idx == 2)) {
     816            h_shift = 1;
     817            v_shift = 1;
     818        } else if (img->format == BPG_FORMAT_422 &&
     819                   (c_idx == 1 || c_idx == 2)) {
     820            h_shift = 1;
     821            v_shift = 0;
     822        } else {
     823            h_shift = 0;
     824            v_shift = 0;
     825        }
     826
     827        c_w = (img->w + h_shift) >> h_shift;
     828        c_h = (img->h + v_shift) >> v_shift;
     829        c_w1 = w1 >> h_shift;
     830        c_h1 = h1 >> v_shift;
     831
     832        /* pad horizontally */
     833        for(y = 0; y < c_h; y++) {
     834            ptr = (PIXEL *)(img->data[c_idx] + img->linesize[c_idx] * y);
     835            v = ptr[c_w - 1];
     836            for(x = c_w; x < c_w1; x++) {
     837                ptr[x] = v;
     838            }
     839        }
     840
     841        /* pad vertically */
     842        ptr1 = (PIXEL *)(img->data[c_idx] + img->linesize[c_idx] * (c_h - 1));
     843        for(y = c_h; y < c_h1; y++) {
     844            ptr = (PIXEL *)(img->data[c_idx] + img->linesize[c_idx] * y);
     845            memcpy(ptr, ptr1, c_w1 * sizeof(PIXEL));
     846        }
     847    }
     848    img->w = w1;
     849    img->h = h1;
     850}
     851
     852/* convert the 16 bit components to 8 bits */
     853void image_convert16to8(Image *img)
     854{
     855    int w, h, stride, y, x, c_count, i;
     856    uint8_t *plane;
     857
     858    if (img->bit_depth > 8 || img->pixel_shift != 1)
     859        return;
     860    if (img->format == BPG_FORMAT_GRAY)
     861        c_count = 1;
     862    else
     863        c_count = 3;
     864    if (img->has_alpha)
     865        c_count++;
     866    for(i = 0; i < c_count; i++) {
     867        get_plane_res(img, &w, &h, i);
     868        stride = w;
     869        plane = malloc(stride * h);
     870        for(y = 0; y < h; y++) {
     871            const uint16_t *src;
     872            uint8_t *dst;
     873            dst = plane + stride * y;
     874            src = (uint16_t *)(img->data[i] + img->linesize[i] * y);
     875            for(x = 0; x < w; x++)
     876                dst[x] = src[x];
     877        }
     878        free(img->data[i]);
     879        img->data[i] = plane;
     880        img->linesize[i] = stride;
     881    }
     882    img->pixel_shift = 0;
     883}
     884
     885typedef struct BPGMetaData {
     886    uint32_t tag;
     887    uint8_t *buf;
     888    int buf_len;
     889    struct BPGMetaData *next;
     890} BPGMetaData;
     891
     892BPGMetaData *bpg_md_alloc(uint32_t tag)
     893{
     894    BPGMetaData *md;
     895    md = malloc(sizeof(BPGMetaData));
     896    memset(md, 0, sizeof(*md));
     897    md->tag = tag;
     898    return md;
     899}
     900
     901void bpg_md_free(BPGMetaData *md)
     902{
     903    BPGMetaData *md_next;
     904
     905    while (md != NULL) {
     906        md_next = md->next;
     907        free(md->buf);
     908        free(md);
     909        md = md_next;
     910    }
     911}
     912
     913Image *read_png(BPGMetaData **pmd,
     914                FILE *f, BPGColorSpaceEnum color_space, int out_bit_depth,
     915                int limited_range, int premultiplied_alpha)
     916{
     917    png_structp png_ptr;
     918    png_infop info_ptr;
     919    int bit_depth, color_type;
     920    Image *img;
     921    uint8_t **rows;
     922    int y, has_alpha, linesize, bpp;
     923    BPGImageFormatEnum format;
     924    ColorConvertState cvt_s, *cvt = &cvt_s;
     925    BPGMetaData *md, **plast_md, *first_md;
     926   
     927    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
     928                                     NULL, NULL, NULL);
     929    if (png_ptr == NULL) {
     930        return NULL;
     931    }
     932   
     933    info_ptr = png_create_info_struct(png_ptr);
     934    if (info_ptr == NULL) {
     935       png_destroy_read_struct(&png_ptr, NULL, NULL);
     936       return NULL;
     937    }
     938   
     939    if (setjmp(png_jmpbuf(png_ptr))) {
     940        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
     941        return NULL;
     942    }
     943   
     944    png_init_io(png_ptr, f);
     945   
     946    png_read_info(png_ptr, info_ptr);
     947   
     948    bit_depth   = png_get_bit_depth(png_ptr, info_ptr);
     949    color_type = png_get_color_type(png_ptr, info_ptr);
     950
     951    switch (color_type) {
     952    case PNG_COLOR_TYPE_PALETTE:
     953        png_set_palette_to_rgb(png_ptr);
     954        bit_depth = 8;
     955        break;
     956    case PNG_COLOR_TYPE_GRAY:
     957    case PNG_COLOR_TYPE_GRAY_ALPHA:
     958        if (bit_depth < 8) {
     959            png_set_expand_gray_1_2_4_to_8(png_ptr);
     960            bit_depth = 8;
     961        }
     962        break;
     963    }
     964    assert(bit_depth == 8 || bit_depth == 16);
     965
     966#if __BYTE_ORDER__ != __ORDER_BIG_ENDIAN__
     967    if (bit_depth == 16) {
     968        png_set_swap(png_ptr);
     969    }
     970#endif
     971
     972    if (color_type == PNG_COLOR_TYPE_GRAY ||
     973        color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
     974        format = BPG_FORMAT_GRAY;
     975        color_space = BPG_CS_YCbCr;
     976    } else {
     977        format = BPG_FORMAT_444;
     978    }
     979   
     980    has_alpha = (color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
     981                 color_type == PNG_COLOR_TYPE_RGB_ALPHA);
     982
     983    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
     984        png_set_tRNS_to_alpha(png_ptr);
     985        has_alpha = 1;
     986    }
     987
     988    if (premultiplied_alpha) {
     989        png_set_alpha_mode(png_ptr, PNG_ALPHA_ASSOCIATED, PNG_GAMMA_LINEAR);
     990    }
     991
     992    img = image_alloc(png_get_image_width(png_ptr, info_ptr),
     993                      png_get_image_height(png_ptr, info_ptr),
     994                      format, has_alpha, color_space,
     995                      out_bit_depth);
     996    img->limited_range = limited_range;
     997    img->premultiplied_alpha = premultiplied_alpha;
     998
     999    rows = malloc(sizeof(rows[0]) * img->h);
     1000    if (format == BPG_FORMAT_GRAY)
     1001        bpp = (1 + has_alpha) * (bit_depth / 8);
     1002    else
     1003        bpp = (3 + has_alpha) * (bit_depth / 8);
     1004    linesize = bpp * img->w;
     1005    for (y = 0; y < img->h; y++) {
     1006        rows[y] = malloc(linesize);
     1007    }
     1008   
     1009    png_read_image(png_ptr, rows);
     1010   
     1011    convert_init(cvt, bit_depth, out_bit_depth, color_space, limited_range);
     1012
     1013    if (format != BPG_FORMAT_GRAY) {
     1014        int idx;
     1015        RGBConvertFunc *convert_func;
     1016
     1017        idx = (bit_depth == 16);
     1018        convert_func = rgb_to_cs[idx][color_space];
     1019       
     1020        for (y = 0; y < img->h; y++) {
     1021            convert_func(cvt, (PIXEL *)(img->data[0] + y * img->linesize[0]),
     1022                         (PIXEL *)(img->data[1] + y * img->linesize[1]),
     1023                         (PIXEL *)(img->data[2] + y * img->linesize[2]),
     1024                         rows[y], img->w, 3 + has_alpha);
     1025            if (has_alpha) {
     1026                if (idx) {
     1027                    gray16_to_gray(cvt, (PIXEL *)(img->data[3] + y * img->linesize[3]),
     1028                                   (uint16_t *)rows[y] + 3, img->w, 4);
     1029                } else {
     1030                    gray8_to_gray(cvt, (PIXEL *)(img->data[3] + y * img->linesize[3]),
     1031                                  rows[y] + 3, img->w, 4);
     1032                }
     1033            }
     1034        }
     1035    } else {
     1036        if (bit_depth == 16) {
     1037            for (y = 0; y < img->h; y++) {
     1038                luma16_to_gray(cvt, (PIXEL *)(img->data[0] + y * img->linesize[0]),
     1039                               (uint16_t *)rows[y], img->w, 1 + has_alpha);
     1040                if (has_alpha) {
     1041                    gray16_to_gray(cvt, (PIXEL *)(img->data[1] + y * img->linesize[1]),
     1042                                   (uint16_t *)rows[y] + 1, img->w, 2);
     1043                }
     1044            }
     1045        } else {
     1046            for (y = 0; y < img->h; y++) {
     1047                luma8_to_gray(cvt, (PIXEL *)(img->data[0] + y * img->linesize[0]),
     1048                              rows[y], img->w, 1 + has_alpha);
     1049                if (has_alpha) {
     1050                    gray8_to_gray(cvt, (PIXEL *)(img->data[1] + y * img->linesize[1]),
     1051                                  rows[y] + 1, img->w, 2);
     1052                }
     1053            }
     1054        }
     1055    }
     1056
     1057    for (y = 0; y < img->h; y++) {
     1058        free(rows[y]);
     1059    }
     1060    free(rows);
     1061       
     1062    png_read_end(png_ptr, info_ptr);
     1063   
     1064    /* get the ICC profile if present */
     1065    first_md = NULL;
     1066    plast_md = &first_md;
     1067    {
     1068        png_charp name;
     1069        int comp_type;
     1070        png_bytep iccp_buf;
     1071        png_uint_32 iccp_buf_len;
     1072       
     1073        if (png_get_iCCP(png_ptr, info_ptr,
     1074                         &name, &comp_type, &iccp_buf, &iccp_buf_len) ==
     1075            PNG_INFO_iCCP) {
     1076            md = bpg_md_alloc(BPG_EXTENSION_TAG_ICCP);
     1077            md->buf_len = iccp_buf_len;
     1078            md->buf = malloc(iccp_buf_len);
     1079            memcpy(md->buf, iccp_buf, iccp_buf_len);
     1080            *plast_md = md;
     1081            plast_md = &md->next;
     1082        }
     1083    }
     1084
     1085    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
     1086   
     1087    *pmd = first_md;
     1088    return img;
     1089}
     1090
     1091static BPGMetaData *jpeg_get_metadata(jpeg_saved_marker_ptr first_marker)
     1092{
     1093    static const char app1_exif[] = "Exif";
     1094    static const char app1_xmp[] = "http://ns.adobe.com/xap/1.0/";
     1095    static const char app2_iccp[] = "ICC_PROFILE";
     1096    jpeg_saved_marker_ptr marker;
     1097    BPGMetaData *md, **plast_md, *first_md;
     1098    int has_exif, has_xmp, l, iccp_chunk_count, i;
     1099    jpeg_saved_marker_ptr iccp_chunks[256];
     1100   
     1101    iccp_chunk_count = 0;
     1102    has_exif = 0;
     1103    has_xmp = 0;
     1104    first_md = NULL;
     1105    plast_md = &first_md;
     1106    for (marker = first_marker; marker != NULL; marker = marker->next) {
     1107#if 0
     1108        printf("marker=APP%d len=%d\n",
     1109               marker->marker - JPEG_APP0, marker->data_length);
     1110#endif
     1111        if (!has_exif && marker->marker == JPEG_APP0 + 1 &&
     1112            marker->data_length > sizeof(app1_exif) &&
     1113            !memcmp(marker->data, app1_exif, sizeof(app1_exif))) {
     1114            md = bpg_md_alloc(BPG_EXTENSION_TAG_EXIF);
     1115            l = sizeof(app1_exif);
     1116            md->buf_len = marker->data_length - l;
     1117            md->buf = malloc(md->buf_len);
     1118            memcpy(md->buf, marker->data + l, md->buf_len);
     1119            *plast_md = md;
     1120            plast_md = &md->next;
     1121            has_exif = 1;
     1122        } else if (!has_xmp && marker->marker == JPEG_APP0 + 1 &&
     1123                   marker->data_length > sizeof(app1_xmp) &&
     1124                   !memcmp(marker->data, app1_xmp, sizeof(app1_xmp)) &&
     1125                   !has_xmp) {
     1126            md = bpg_md_alloc(BPG_EXTENSION_TAG_XMP);
     1127            l = sizeof(app1_xmp);
     1128            md->buf_len = marker->data_length - l;
     1129            md->buf = malloc(md->buf_len);
     1130            memcpy(md->buf, marker->data + l, md->buf_len);
     1131            *plast_md = md;
     1132            plast_md = &md->next;
     1133            has_xmp = 1;
     1134        } else if (marker->marker == JPEG_APP0 + 2 &&
     1135                   marker->data_length > (sizeof(app2_iccp) + 2) &&
     1136                   !memcmp(marker->data, app2_iccp, sizeof(app2_iccp))) {
     1137            int chunk_count, chunk_index;
     1138            l = sizeof(app2_iccp);
     1139            chunk_index = marker->data[l];
     1140            chunk_count = marker->data[l];
     1141            if (chunk_index == 0 || chunk_count == 0)
     1142                continue;
     1143            if (iccp_chunk_count == 0) {
     1144                iccp_chunk_count = chunk_count;
     1145                for(i = 0; i < chunk_count; i++) {
     1146                    iccp_chunks[i] = NULL;
     1147                }
     1148            } else {
     1149                if (chunk_count != iccp_chunk_count)
     1150                    continue;
     1151            }
     1152            if (chunk_index > iccp_chunk_count)
     1153                continue;
     1154            iccp_chunks[chunk_index - 1] = marker;
     1155        }
     1156    }
     1157
     1158    if (iccp_chunk_count != 0) {
     1159        int len, hlen, idx;
     1160        /* check that no chunk are missing */
     1161        len = 0;
     1162        hlen = sizeof(app2_iccp) + 2;
     1163        for(i = 0; i < iccp_chunk_count; i++) {
     1164            if (!iccp_chunks[i])
     1165                break;
     1166            len += iccp_chunks[i]->data_length - hlen;
     1167        }
     1168        if (i == iccp_chunk_count) {
     1169            md = bpg_md_alloc(BPG_EXTENSION_TAG_ICCP);
     1170            md->buf_len = len;
     1171            md->buf = malloc(md->buf_len);
     1172            idx = 0;
     1173            for(i = 0; i < iccp_chunk_count; i++) {
     1174                l = iccp_chunks[i]->data_length - hlen;
     1175                memcpy(md->buf + idx, iccp_chunks[i]->data + hlen, l);
     1176                idx += l;
     1177            }
     1178            assert(idx == len);
     1179            *plast_md = md;
     1180            plast_md = &md->next;
     1181        }
     1182    }
     1183    return first_md;
     1184}
     1185
     1186Image *read_jpeg(BPGMetaData **pmd, FILE *f,
     1187                 int out_bit_depth)
     1188{
     1189    struct jpeg_decompress_struct cinfo;
     1190    struct jpeg_error_mgr jerr;
     1191    int w, h, w1, i, y_h, c_h, y, v_shift, c_w, y1, idx, c_idx, h_shift;
     1192    int h1, plane_idx[4], has_alpha, has_w_plane;
     1193    Image *img;
     1194    BPGImageFormatEnum format;
     1195    BPGColorSpaceEnum color_space;
     1196    ColorConvertState cvt_s, *cvt = &cvt_s;
     1197    BPGMetaData *first_md = NULL;
     1198    uint32_t comp_hv;
     1199
     1200    cinfo.err = jpeg_std_error(&jerr);
     1201    jpeg_create_decompress(&cinfo);
     1202
     1203    jpeg_save_markers(&cinfo, JPEG_APP0 + 1, 65535);
     1204    jpeg_save_markers(&cinfo, JPEG_APP0 + 2, 65535);
     1205
     1206    jpeg_stdio_src(&cinfo, f);
     1207   
     1208    jpeg_read_header(&cinfo, TRUE);
     1209   
     1210    cinfo.raw_data_out = TRUE;
     1211    cinfo.do_fancy_upsampling = TRUE;
     1212   
     1213    w = cinfo.image_width;
     1214    h = cinfo.image_height;
     1215
     1216    has_w_plane = 0;
     1217    comp_hv = 0;
     1218    if (cinfo.num_components < 1 || cinfo.num_components > 4)
     1219        goto unsupported;
     1220    for(i = 0; i < cinfo.num_components; i++) {
     1221        comp_hv |= cinfo.comp_info[i].h_samp_factor << (i * 8 + 4);
     1222        comp_hv |= cinfo.comp_info[i].v_samp_factor << (i * 8);
     1223    }
     1224    switch(cinfo.jpeg_color_space) {
     1225    case JCS_GRAYSCALE:
     1226        if (cinfo.num_components != 1 || comp_hv != 0x11)
     1227            goto unsupported;
     1228        format = BPG_FORMAT_GRAY;
     1229        color_space = BPG_CS_YCbCr;
     1230        break;
     1231    case JCS_YCbCr:
     1232        if (cinfo.num_components != 3)
     1233            goto unsupported;
     1234        switch(comp_hv) {
     1235        case 0x111111:
     1236            format = BPG_FORMAT_444;
     1237            break;
     1238        case 0x111121:
     1239            format = BPG_FORMAT_422;
     1240            break;
     1241        case 0x111122:
     1242            format = BPG_FORMAT_420;
     1243            break;
     1244        default:
     1245            cinfo.raw_data_out = FALSE;
     1246            format = BPG_FORMAT_444;
     1247            cinfo.out_color_space = JCS_YCbCr;
     1248            break;
     1249        }
     1250        color_space = BPG_CS_YCbCr;
     1251        break;
     1252    case JCS_RGB:
     1253        if (cinfo.num_components != 3)
     1254            goto unsupported;
     1255        format = BPG_FORMAT_444;
     1256        color_space = BPG_CS_RGB;
     1257        cinfo.raw_data_out = FALSE;
     1258        cinfo.out_color_space = JCS_RGB;
     1259        break;
     1260    case JCS_YCCK:
     1261        if (cinfo.num_components != 4)
     1262            goto unsupported;
     1263        switch(comp_hv) {
     1264        case 0x11111111:
     1265            format = BPG_FORMAT_444;
     1266            color_space = BPG_CS_YCbCr;
     1267            break;
     1268        case 0x22111121:
     1269            format = BPG_FORMAT_422;
     1270            color_space = BPG_CS_YCbCr;
     1271            break;
     1272        case 0x22111122:
     1273            format = BPG_FORMAT_420;
     1274            color_space = BPG_CS_YCbCr;
     1275            break;
     1276        default:
     1277            cinfo.raw_data_out = FALSE;
     1278            format = BPG_FORMAT_444;
     1279            cinfo.out_color_space = JCS_CMYK;
     1280            color_space = BPG_CS_RGB;
     1281            break;
     1282        }
     1283        has_w_plane = 1;
     1284        break;
     1285    case JCS_CMYK:
     1286        if (cinfo.num_components != 4)
     1287            goto unsupported;
     1288        format = BPG_FORMAT_444;
     1289        color_space = BPG_CS_RGB;
     1290        has_w_plane = 1;
     1291        cinfo.raw_data_out = FALSE;
     1292        cinfo.out_color_space = JCS_CMYK;
     1293        break;
     1294    default:
     1295    unsupported:
     1296        fprintf(stderr, "Unsupported JPEG parameters (cs=%d n_comp=%d comp_hv=%x)\n",
     1297                cinfo.jpeg_color_space, cinfo.num_components, comp_hv);
     1298        img = NULL;
     1299        goto the_end;
     1300    }
     1301
     1302    v_shift = (format == BPG_FORMAT_420);
     1303    h_shift = (format == BPG_FORMAT_422 || format == BPG_FORMAT_420);
     1304    has_alpha = (cinfo.num_components == 4);
     1305    img = image_alloc(w, h, format, has_alpha, color_space, out_bit_depth);
     1306    img->has_w_plane = has_w_plane;
     1307
     1308    convert_init(cvt, 8, out_bit_depth, color_space, 0);
     1309
     1310    jpeg_start_decompress(&cinfo);
     1311
     1312    if (color_space == BPG_CS_RGB) {
     1313        plane_idx[0] = 2;
     1314        plane_idx[1] = 0;
     1315        plane_idx[2] = 1;
     1316    } else {
     1317        plane_idx[0] = 0;
     1318        plane_idx[1] = 1;
     1319        plane_idx[2] = 2;
     1320    }
     1321    plane_idx[3] = 3;
     1322       
     1323    if (cinfo.raw_data_out) {
     1324        JSAMPROW rows[4][16];
     1325        JSAMPROW *plane_pointer[4];
     1326
     1327        y_h = 8 * cinfo.max_v_samp_factor;
     1328        if (cinfo.num_components == 1) {
     1329            c_h = 0;
     1330            c_w = 0;
     1331        } else {
     1332            c_h = 8;
     1333            if (h_shift)
     1334                c_w = (w + 1) / 2;
     1335            else
     1336                c_w = w;
     1337        }
     1338        w1 = (w + 15) & ~15;
     1339        for(c_idx = 0; c_idx < cinfo.num_components; c_idx++) {
     1340            if (c_idx == 1 || c_idx == 2) {
     1341                h1 = c_h;
     1342            } else {
     1343                h1 = y_h;
     1344            }
     1345            for(i = 0; i < h1; i++) {
     1346                rows[c_idx][i] = malloc(w1);
     1347            }
     1348            plane_pointer[c_idx] = rows[c_idx];
     1349        }
     1350       
     1351        while (cinfo.output_scanline < cinfo.output_height) {
     1352            y = cinfo.output_scanline;
     1353            jpeg_read_raw_data(&cinfo, plane_pointer, y_h);
     1354           
     1355            for(c_idx = 0; c_idx < cinfo.num_components; c_idx++) {
     1356                if (c_idx == 1 || c_idx == 2) {
     1357                    h1 = c_h;
     1358                    w1 = c_w;
     1359                    y1 = (y >> v_shift);
     1360                } else {
     1361                    h1 = y_h;
     1362                    w1 = img->w;
     1363                    y1 = y;
     1364                }
     1365                idx = plane_idx[c_idx];
     1366                for(i = 0; i < h1; i++) {
     1367                    PIXEL *ptr;
     1368                    ptr = (PIXEL *)(img->data[idx] +
     1369                                    img->linesize[idx] * (y1 + i));
     1370                    gray8_to_gray(cvt, ptr, rows[c_idx][i], w1, 1);
     1371                    if (color_space == BPG_CS_YCbCr && has_w_plane) {
     1372                        /* negate color */
     1373                        if (c_idx == 0) {
     1374                            gray_one_minus(cvt, ptr, w1);
     1375                        } else if (c_idx <= 2) {
     1376                            gray_neg_c(cvt, ptr, w1);
     1377                        }
     1378                    }
     1379                }
     1380            }
     1381        }
     1382   
     1383        for(c_idx = 0; c_idx < cinfo.num_components; c_idx++) {
     1384            if (c_idx == 1 || c_idx == 2) {
     1385                h1 = c_h;
     1386            } else {
     1387                h1 = y_h;
     1388            }
     1389            for(i = 0; i < h1; i++) {
     1390                free(rows[c_idx][i]);
     1391            }
     1392        }
     1393    } else {
     1394        JSAMPROW rows[1];
     1395        uint8_t *buf;
     1396        int c_count;
     1397
     1398        c_count = 3 + has_w_plane;
     1399        buf = malloc(c_count * w);
     1400        rows[0] = buf;
     1401        while (cinfo.output_scanline < cinfo.output_height) {
     1402            y = cinfo.output_scanline;
     1403            jpeg_read_scanlines(&cinfo, rows, 1);
     1404
     1405            for(c_idx = 0; c_idx < c_count; c_idx++) {
     1406                idx = plane_idx[c_idx];
     1407                gray8_to_gray(cvt, (PIXEL *)(img->data[idx] +
     1408                                             img->linesize[idx] * y),
     1409                              buf + c_idx, w, c_count);
     1410            }
     1411        }
     1412        free(buf);
     1413    }
     1414   
     1415    first_md = jpeg_get_metadata(cinfo.marker_list);
     1416
     1417 the_end:
     1418    jpeg_finish_decompress(&cinfo);
     1419   
     1420    jpeg_destroy_decompress(&cinfo);
     1421    *pmd = first_md;
     1422    return img;
     1423}
     1424
     1425Image *load_image(BPGMetaData **pmd, const char *infilename,
     1426                  BPGColorSpaceEnum color_space, int bit_depth,
     1427                  int limited_range, int premultiplied_alpha)
     1428{
     1429    FILE *f;
     1430    int is_png;
     1431    Image *img;
     1432    BPGMetaData *md;
     1433
     1434    *pmd = NULL;
     1435
     1436    f = fopen(infilename, "rb");
     1437    if (!f)
     1438        return NULL;
     1439    {
     1440        uint8_t buf[8];
     1441        if (fread(buf, 1, 8, f) == 8 &&
     1442            png_sig_cmp(buf, 0, 8) == 0)
     1443            is_png = 1;
     1444        else
     1445            is_png = 0;
     1446        fseek(f, 0, SEEK_SET);
     1447    }
     1448   
     1449    if (is_png) {
     1450        img = read_png(&md, f, color_space, bit_depth, limited_range,
     1451                       premultiplied_alpha);
     1452    } else {
     1453        img = read_jpeg(&md, f, bit_depth);
     1454    }
     1455    fclose(f);
     1456    *pmd = md;
     1457    return img;
     1458}
     1459
     1460void save_yuv1(Image *img, FILE *f)
     1461{
     1462    int c_w, c_h, i, c_count, y;
     1463
     1464    if (img->format == BPG_FORMAT_GRAY)
     1465        c_count = 1;
     1466    else
     1467        c_count = 3;
     1468    for(i = 0; i < c_count; i++) {
     1469        get_plane_res(img, &c_w, &c_h, i);
     1470        for(y = 0; y < c_h; y++) {
     1471            fwrite(img->data[i] + y * img->linesize[i],
     1472                   1, c_w << img->pixel_shift, f);
     1473        }
     1474    }
     1475}
     1476
     1477void save_yuv(Image *img, const char *filename)
     1478{
     1479    FILE *f;
     1480
     1481    f = fopen(filename, "wb");
     1482    if (!f) {
     1483        fprintf(stderr, "Could not open %s\n", filename);
     1484        exit(1);
     1485    }
     1486    save_yuv1(img, f);
     1487    fclose(f);
     1488}
     1489
     1490/* return the position of the end of the NAL or -1 if error */
     1491static int find_nal_end(const uint8_t *buf, int buf_len)
     1492{
     1493    int idx;
     1494
     1495    idx = 0;
     1496    if (buf_len >= 4 &&
     1497        buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 1) {
     1498        idx = 4;
     1499    } else if (buf_len >= 3 &&
     1500               buf[0] == 0 && buf[1] == 0 && buf[2] == 1) {
     1501        idx = 3;
     1502    } else {
     1503        return -1;
     1504    }
     1505    /* NAL header */
     1506    if (idx + 2 > buf_len)
     1507        return -1;
     1508    /* find the last byte */
     1509    for(;;) {
     1510        if (idx + 2 >= buf_len) {
     1511            idx = buf_len;
     1512            break;
     1513        }
     1514        if (buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 1)
     1515            break;
     1516        if (idx + 3 < buf_len &&
     1517            buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 0 && buf[idx + 3] == 1)
     1518            break;
     1519        idx++;
     1520    }
     1521    return idx;
     1522}
     1523
     1524/* return the position of the end of the NAL or -1 if error */
     1525static int extract_nal(uint8_t **pnal_buf, int *pnal_len,
     1526                       const uint8_t *buf, int buf_len)
     1527{
     1528    int idx, start, end, len;
     1529    uint8_t *nal_buf;
     1530    int nal_len;
     1531
     1532    end = find_nal_end(buf, buf_len);
     1533    if (end < 0)
     1534        return -1;
     1535    if (buf[2] == 1)
     1536        start = 3;
     1537    else
     1538        start = 4;
     1539    len = end - start;
     1540   
     1541    nal_buf = malloc(len);
     1542    nal_len = 0;
     1543    idx = start;
     1544    while (idx < end) {
     1545        if (idx + 2 < end && buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 3) {
     1546            nal_buf[nal_len++] = 0;
     1547            nal_buf[nal_len++] = 0;
     1548            idx += 3;
     1549        } else {
     1550            nal_buf[nal_len++] = buf[idx++];
     1551        }
     1552    }
     1553    while (idx < end) {
     1554        nal_buf[nal_len++] = buf[idx++];
     1555    }
     1556    *pnal_buf = nal_buf;
     1557    *pnal_len = nal_len;
     1558    return idx;
     1559}
     1560
     1561/* big endian variable length 7 bit encoding */
     1562static void put_ue(uint8_t **pp, uint32_t v)
     1563{
     1564    uint8_t *p = *pp;
     1565    int i, j;
     1566   
     1567    for(i = 1; i < 5; i++) {
     1568        if (v < (1 << (7 * i)))
     1569            break;
     1570    }
     1571    for(j = i - 1; j >= 1; j--)
     1572        *p++ = ((v >> (7 * j)) & 0x7f) | 0x80;
     1573    *p++ = v & 0x7f;
     1574    *pp = p;
     1575}
     1576
     1577typedef struct {
     1578    const uint8_t *buf;
     1579    int idx;
     1580    int buf_len;
     1581} GetBitState;
     1582
     1583static void init_get_bits(GetBitState *s, const uint8_t *buf, int buf_len)
     1584{
     1585    s->buf = buf;
     1586    s->buf_len = buf_len;
     1587    s->idx = 0;
     1588}
     1589
     1590static void skip_bits(GetBitState *s, int n)
     1591{
     1592    s->idx += n;
     1593}
     1594
     1595/* 1 <= n <= 25. return '0' bits if past the end of the buffer. */
     1596static uint32_t get_bits(GetBitState *s, int n)
     1597{
     1598    const uint8_t *buf = s->buf;
     1599    int p, i;
     1600    uint32_t v;
     1601
     1602    p = s->idx >> 3;
     1603    if ((p + 3) < s->buf_len) {
     1604        v = (buf[p] << 24) | (buf[p + 1] << 16) |
     1605            (buf[p + 2] << 8) | buf[p + 3];
     1606    } else {
     1607        v = 0;
     1608        for(i = 0; i < 3; i++) {
     1609            if ((p + i) < s->buf_len)
     1610                v |= buf[p + i] << (24 - i * 8);
     1611        }
     1612    }
     1613    v = (v >> (32 - (s->idx & 7) - n)) & ((1 << n) - 1);
     1614    s->idx += n;
     1615    return v;
     1616}
     1617
     1618/* 1 <= n <= 32 */
     1619static uint32_t get_bits_long(GetBitState *s, int n)
     1620{
     1621    uint32_t v;
     1622
     1623    if (n <= 25) {
     1624        v = get_bits(s, n);
     1625    } else {
     1626        n -= 16;
     1627        v = get_bits(s, 16) << n;
     1628        v |= get_bits(s, n);
     1629    }
     1630    return v;
     1631}
     1632
     1633/* at most 32 bits are supported */
     1634static uint32_t get_ue_golomb(GetBitState *s)
     1635{
     1636    int i;
     1637    i = 0;
     1638    for(;;) {
     1639        if (get_bits(s, 1))
     1640            break;
     1641        i++;
     1642        if (i == 32)
     1643            return 0xffffffff;
     1644    }
     1645    if (i == 0)
     1646        return 0;
     1647    else
     1648        return ((1 << i) | get_bits_long(s, i)) - 1;
     1649}
     1650
     1651typedef struct {
     1652    uint8_t *buf;
     1653    int idx;
     1654} PutBitState;
     1655
     1656static void init_put_bits(PutBitState *s, uint8_t *buf)
     1657{
     1658    s->buf = buf;
     1659    s->idx = 0;
     1660}
     1661
     1662static void put_bit(PutBitState *s, int bit)
     1663{
     1664    s->buf[s->idx >> 3] |= bit << (7 - (s->idx & 7));
     1665    s->idx++;
     1666}
     1667
     1668static void put_bits(PutBitState *s, int n, uint32_t v)
     1669{
     1670    int i;
     1671
     1672    for(i = 0; i < n; i++) {
     1673        put_bit(s, (v >> (n - 1 - i)) & 1);
     1674    }
     1675}
     1676
     1677static void put_ue_golomb(PutBitState *s, uint32_t v)
     1678{
     1679    uint32_t a;
     1680    int n;
     1681
     1682    v++;
     1683    n = 0;
     1684    a = v;
     1685    while (a != 0) {
     1686        a >>= 1;
     1687        n++;
     1688    }
     1689    if (n > 1)
     1690        put_bits(s, n - 1, 0);
     1691    put_bits(s, n, v);
     1692}
     1693
     1694typedef struct {
     1695    uint8_t *buf;
     1696    int size;
     1697    int len;
     1698} DynBuf;
     1699
     1700static void dyn_buf_init(DynBuf *s)
     1701{
     1702    s->buf = NULL;
     1703    s->size = 0;
     1704    s->len = 0;
     1705}
     1706
     1707static int dyn_buf_resize(DynBuf *s, int size)
     1708{
     1709    int new_size;
     1710    uint8_t *new_buf;
     1711
     1712    if (size <= s->size)
     1713        return 0;
     1714    new_size = (s->size * 3) / 2;
     1715    if (new_size < size)
     1716        new_size = size;
     1717    new_buf = realloc(s->buf, new_size);
     1718    if (!new_buf)
     1719        return -1;
     1720    s->buf = new_buf;
     1721    s->size = new_size;
     1722    return 0;
     1723}
     1724
     1725/* suppress the VPS NAL and keep only the useful part of the SPS
     1726   header. The decoder can rebuild a valid HEVC stream if needed. */
     1727static int build_modified_sps(uint8_t **pout_buf, int *pout_buf_len,
     1728                              const uint8_t *buf, int buf_len)
     1729{
     1730    int nal_unit_type, nal_len, idx, i, ret, msps_buf_len;
     1731    int out_buf_len, out_buf_len_max;
     1732    uint8_t *nal_buf, *msps_buf, *out_buf;
     1733    GetBitState gb_s, *gb = &gb_s;
     1734    PutBitState pb_s, *pb = &pb_s;
     1735    uint8_t *p;
     1736
     1737    idx = extract_nal(&nal_buf, &nal_len, buf, buf_len);
     1738    if (idx < 0)
     1739        return -1;
     1740    if (nal_len < 2) {
     1741        free(nal_buf);
     1742        return -1;
     1743    }
     1744    nal_unit_type = (nal_buf[0] >> 1) & 0x3f;
     1745    free(nal_buf);
     1746    if (nal_unit_type != 32)  {
     1747        fprintf(stderr, "expecting VPS nal (%d)\n", nal_unit_type);
     1748        return -1; /* expect VPS nal */
     1749    }
     1750
     1751    ret = extract_nal(&nal_buf, &nal_len, buf + idx, buf_len);
     1752    if (ret < 0)
     1753        return -1;
     1754    idx += ret;
     1755    if (nal_len < 2)
     1756        return -1;
     1757    nal_unit_type = (nal_buf[0] >> 1) & 0x3f;
     1758    if (nal_unit_type != 33) {
     1759        fprintf(stderr, "expecting SPS nal (%d)\n", nal_unit_type);
     1760        return -1; /* expect SPS nal */
     1761    }
     1762
     1763    /* skip the initial part of the SPS up to and including
     1764       log2_min_cb_size */
     1765    {
     1766        int vps_id, max_sub_layers, profile_idc, sps_id;
     1767        int chroma_format_idc, width, height, bit_depth_luma, bit_depth_chroma;
     1768        int log2_max_poc_lsb, sublayer_ordering_info, log2_min_cb_size;
     1769        int log2_diff_max_min_coding_block_size, log2_min_tb_size;
     1770        int log2_diff_max_min_transform_block_size;
     1771        int max_transform_hierarchy_depth_inter;
     1772        int max_transform_hierarchy_depth_intra;
     1773        int scaling_list_enable_flag, amp_enabled_flag, sao_enabled;
     1774        int pcm_enabled_flag, nb_st_rps;
     1775        int long_term_ref_pics_present_flag, sps_strong_intra_smoothing_enable_flag, vui_present;
     1776        int sps_temporal_mvp_enabled_flag;
     1777        int pcm_sample_bit_depth_luma_minus1;
     1778        int pcm_sample_bit_depth_chroma_minus1;
     1779        int log2_min_pcm_luma_coding_block_size_minus3;
     1780        int log2_diff_max_min_pcm_luma_coding_block_size;
     1781        int pcm_loop_filter_disabled_flag;
     1782        int sps_extension_flag, sps_range_extension_flag, sps_extension_7bits;
     1783        int sps_range_extension_flags;
     1784
     1785        init_get_bits(gb, nal_buf, nal_len);
     1786        skip_bits(gb, 16); /* nal header */
     1787        vps_id = get_bits(gb, 4);
     1788        if (vps_id != 0) {
     1789            fprintf(stderr, "VPS id 0 expected\n");
     1790            return -1;
     1791        }
     1792        max_sub_layers = get_bits(gb, 3);
     1793        if (max_sub_layers != 0) {
     1794            fprintf(stderr, "max_sub_layers == 0 expected\n");
     1795            return -1;
     1796        }
     1797        skip_bits(gb, 1); /* temporal_id_nesting_flag */
     1798        /* profile tier level */
     1799        skip_bits(gb, 2); /* profile_space */
     1800        skip_bits(gb, 1); /* tier_flag */
     1801        profile_idc = get_bits(gb, 5);
     1802        for(i = 0; i < 32; i++) {
     1803            skip_bits(gb, 1); /* profile_compatibility_flag */
     1804        }
     1805        skip_bits(gb, 1); /* progressive_source_flag */
     1806        skip_bits(gb, 1); /* interlaced_source_flag */
     1807        skip_bits(gb, 1); /* non_packed_constraint_flag */
     1808        skip_bits(gb, 1); /* frame_only_constraint_flag */
     1809        skip_bits(gb, 44); /*  XXX_reserved_zero_44 */
     1810        skip_bits(gb, 8); /* level_idc */
     1811
     1812        sps_id = get_ue_golomb(gb);
     1813        if (sps_id != 0) {
     1814            fprintf(stderr, "SPS id 0 expected (%d)\n", sps_id);
     1815            return -1;
     1816        }
     1817        chroma_format_idc = get_ue_golomb(gb);
     1818        if (chroma_format_idc == 3) {
     1819            get_bits(gb, 1); /* separate_colour_plane_flag */
     1820        }
     1821        width = get_ue_golomb(gb);
     1822        height = get_ue_golomb(gb);
     1823        /* pic conformance_flag */
     1824        if (get_bits(gb, 1)) {
     1825            get_ue_golomb(gb); /* left_offset */
     1826            get_ue_golomb(gb); /* right_offset */
     1827            get_ue_golomb(gb); /* top_offset */
     1828            get_ue_golomb(gb); /* bottom_offset */
     1829        }
     1830        bit_depth_luma = get_ue_golomb(gb) + 8;
     1831        bit_depth_chroma = get_ue_golomb(gb) + 8;
     1832        log2_max_poc_lsb = get_ue_golomb(gb) + 4;
     1833        if (log2_max_poc_lsb != 8) {
     1834            fprintf(stderr, "log2_max_poc_lsb must be 8 (%d)\n", log2_max_poc_lsb);
     1835            return -1;
     1836        }
     1837        sublayer_ordering_info = get_bits(gb, 1);
     1838        get_ue_golomb(gb); /* max_dec_pic_buffering */
     1839        get_ue_golomb(gb); /* num_reorder_pics */
     1840        get_ue_golomb(gb); /* max_latency_increase */
     1841       
     1842        log2_min_cb_size = get_ue_golomb(gb) + 3;
     1843        log2_diff_max_min_coding_block_size = get_ue_golomb(gb);
     1844        log2_min_tb_size = get_ue_golomb(gb) + 2;
     1845        log2_diff_max_min_transform_block_size = get_ue_golomb(gb);
     1846               
     1847        max_transform_hierarchy_depth_inter = get_ue_golomb(gb);
     1848        max_transform_hierarchy_depth_intra = get_ue_golomb(gb);
     1849        if (max_transform_hierarchy_depth_inter != max_transform_hierarchy_depth_intra) {
     1850            fprintf(stderr, "max_transform_hierarchy_depth_inter must be the same as max_transform_hierarchy_depth_intra (%d %d)\n", max_transform_hierarchy_depth_inter, max_transform_hierarchy_depth_intra);
     1851            return -1;
     1852        }
     1853
     1854        scaling_list_enable_flag = get_bits(gb, 1);
     1855        if (scaling_list_enable_flag != 0) {
     1856            fprintf(stderr, "scaling_list_enable_flag must be 0\n");
     1857            return -1;
     1858        }
     1859        amp_enabled_flag = get_bits(gb, 1);
     1860        if (!amp_enabled_flag) {
     1861            fprintf(stderr, "amp_enabled_flag must be set\n");
     1862            return -1;
     1863        }
     1864        sao_enabled = get_bits(gb, 1);
     1865        pcm_enabled_flag = get_bits(gb, 1);
     1866        if (pcm_enabled_flag) {
     1867            pcm_sample_bit_depth_luma_minus1 = get_bits(gb, 4);
     1868            pcm_sample_bit_depth_chroma_minus1 = get_bits(gb, 4);
     1869            log2_min_pcm_luma_coding_block_size_minus3 = get_ue_golomb(gb);
     1870            log2_diff_max_min_pcm_luma_coding_block_size = get_ue_golomb(gb);
     1871            pcm_loop_filter_disabled_flag = get_bits(gb, 1);
     1872        }
     1873        nb_st_rps = get_ue_golomb(gb);
     1874        if (nb_st_rps != 0) {
     1875            fprintf(stderr, "nb_st_rps must be 0 (%d)\n", nb_st_rps);
     1876            return -1;
     1877        }
     1878        long_term_ref_pics_present_flag = get_bits(gb, 1);
     1879        if (long_term_ref_pics_present_flag) {
     1880            fprintf(stderr, "nlong_term_ref_pics_present_flag must be 0 (%d)\n", nb_st_rps);
     1881            return -1;
     1882        }
     1883        sps_temporal_mvp_enabled_flag = get_bits(gb, 1);
     1884        if (!sps_temporal_mvp_enabled_flag) {
     1885            fprintf(stderr, "sps_temporal_mvp_enabled_flag must be set\n");
     1886            return -1;
     1887        }
     1888        sps_strong_intra_smoothing_enable_flag = get_bits(gb, 1);
     1889        vui_present = get_bits(gb, 1);
     1890        if (vui_present) {
     1891            int sar_present, sar_idx, overscan_info_present_flag;
     1892            int video_signal_type_present_flag, chroma_loc_info_present_flag;
     1893            int default_display_window_flag, vui_timing_info_present_flag;
     1894            int vui_poc_proportional_to_timing_flag;
     1895            int vui_hrd_parameters_present_flag, bitstream_restriction_flag;
     1896
     1897            sar_present = get_bits(gb, 1);
     1898            sar_idx = get_bits(gb, 8);
     1899            if (sar_idx == 255) {
     1900                skip_bits(gb, 16); /* sar_num */
     1901                skip_bits(gb, 16); /* sar_den */
     1902            }
     1903           
     1904            overscan_info_present_flag = get_bits(gb, 1);
     1905            if (overscan_info_present_flag) {
     1906                skip_bits(gb, 1); /* overscan_appropriate_flag */
     1907            }
     1908
     1909            video_signal_type_present_flag = get_bits(gb, 1);
     1910            if (video_signal_type_present_flag) {
     1911                fprintf(stderr, "video_signal_type_present_flag must be 0\n");
     1912                return -1;
     1913            }
     1914            chroma_loc_info_present_flag = get_bits(gb, 1);
     1915            if (chroma_loc_info_present_flag) {
     1916                get_ue_golomb(gb);
     1917                get_ue_golomb(gb);
     1918            }
     1919            skip_bits(gb, 1); /* neutra_chroma_indication_flag */
     1920            skip_bits(gb, 1);
     1921            skip_bits(gb, 1);
     1922            default_display_window_flag = get_bits(gb, 1);
     1923            if (default_display_window_flag) {
     1924                fprintf(stderr, "default_display_window_flag must be 0\n");
     1925                return -1;
     1926            }
     1927            vui_timing_info_present_flag = get_bits(gb, 1);
     1928            if (vui_timing_info_present_flag) {
     1929                skip_bits(gb, 32);
     1930                skip_bits(gb, 32);
     1931                vui_poc_proportional_to_timing_flag = get_bits(gb, 1);
     1932                if (vui_poc_proportional_to_timing_flag) {
     1933                    get_ue_golomb(gb);
     1934                }
     1935                vui_hrd_parameters_present_flag = get_bits(gb, 1);
     1936                if (vui_hrd_parameters_present_flag) {
     1937                    fprintf(stderr, "vui_hrd_parameters_present_flag must be 0\n");
     1938                    return -1;
     1939                }
     1940            }
     1941            bitstream_restriction_flag = get_bits(gb, 1);
     1942            if (bitstream_restriction_flag) {
     1943                skip_bits(gb, 1);
     1944                skip_bits(gb, 1);
     1945                skip_bits(gb, 1);
     1946                get_ue_golomb(gb);
     1947                get_ue_golomb(gb);
     1948                get_ue_golomb(gb);
     1949                get_ue_golomb(gb);
     1950                get_ue_golomb(gb);
     1951            }
     1952        }
     1953        sps_extension_flag = get_bits(gb, 1);
     1954        sps_range_extension_flag = 0;
     1955        sps_range_extension_flags = 0;
     1956        if (sps_extension_flag) {
     1957            sps_range_extension_flag = get_bits(gb, 1);
     1958            sps_extension_7bits = get_bits(gb, 7);
     1959            if (sps_extension_7bits != 0) {
     1960                fprintf(stderr, "sps_extension_7bits must be 0\n");
     1961                return -1;
     1962            }
     1963            if (sps_range_extension_flag) {
     1964                sps_range_extension_flags = get_bits(gb, 9);
     1965                if (sps_range_extension_flags & ((1 << (8 - 3)) |
     1966                                                 (1 << (8 - 4)) |
     1967                                                 (1 << (8 - 6)) |
     1968                                                 (1 << (8 - 8)))) {
     1969                    fprintf(stderr, "unsupported range extensions (0x%x)\n",
     1970                            sps_range_extension_flags);
     1971                    return -1;
     1972                }
     1973            }
     1974        }
     1975
     1976        /* build the modified SPS */
     1977        msps_buf = malloc(nal_len + 32);
     1978        memset(msps_buf, 0, nal_len + 16);
     1979       
     1980        init_put_bits(pb, msps_buf);
     1981        put_ue_golomb(pb, log2_min_cb_size - 3);
     1982        put_ue_golomb(pb, log2_diff_max_min_coding_block_size);
     1983        put_ue_golomb(pb, log2_min_tb_size - 2);
     1984        put_ue_golomb(pb, log2_diff_max_min_transform_block_size);
     1985        put_ue_golomb(pb, max_transform_hierarchy_depth_intra);
     1986        put_bits(pb, 1, sao_enabled);
     1987        put_bits(pb, 1, pcm_enabled_flag);
     1988        if (pcm_enabled_flag) {
     1989            put_bits(pb, 4, pcm_sample_bit_depth_luma_minus1);
     1990            put_bits(pb, 4, pcm_sample_bit_depth_chroma_minus1);
     1991            put_ue_golomb(pb, log2_min_pcm_luma_coding_block_size_minus3);
     1992            put_ue_golomb(pb, log2_diff_max_min_pcm_luma_coding_block_size);
     1993            put_bits(pb, 1, pcm_loop_filter_disabled_flag);
     1994        }
     1995        put_bits(pb, 1, sps_strong_intra_smoothing_enable_flag);
     1996        put_bits(pb, 1, sps_extension_flag);
     1997        if (sps_extension_flag) {
     1998            put_bits(pb, 1, sps_range_extension_flag);
     1999            put_bits(pb, 7, 0);
     2000            if (sps_range_extension_flag) {
     2001                put_bits(pb, 9, sps_range_extension_flags);
     2002            }
     2003        }
     2004        msps_buf_len = (pb->idx + 7) >> 3;
     2005
     2006        out_buf_len_max = 5 + msps_buf_len;
     2007        out_buf = malloc(out_buf_len_max);
     2008
     2009        //        printf("msps_n_bits=%d\n", pb->idx);
     2010        p = out_buf;
     2011        put_ue(&p, msps_buf_len); /* header length */
     2012
     2013        memcpy(p, msps_buf, msps_buf_len);
     2014        p += msps_buf_len;
     2015       
     2016        out_buf_len = p - out_buf;
     2017        free(msps_buf);
     2018        free(nal_buf);
     2019    }
     2020    *pout_buf = out_buf;
     2021    *pout_buf_len = out_buf_len;
     2022    return idx;
     2023}
     2024
     2025static int add_frame_duration_sei(DynBuf *out_buf, uint16_t frame_ticks)
     2026{
     2027    uint8_t nal_buf[128], *q;
     2028    int nut, nal_len;
     2029
     2030    q = nal_buf;
     2031    *q++ = 0x00;
     2032    *q++ = 0x00;
     2033    *q++ = 0x01;
     2034    nut = 39; /* prefix SEI NUT */
     2035    *q++ = (nut << 1);
     2036    *q++ = 1;
     2037    *q++ = 0xff;  /* payload_type = 257 */
     2038    *q++ = 0x02;
     2039    *q++ = 2; /* payload_size = 2 */
     2040    *q++ = frame_ticks >> 8;
     2041    *q++ = frame_ticks;
     2042    *q++ = 0x80; /* extra '1' bit and align to byte */
     2043    /* Note: the 0x00 0x00 b pattern with b <= 3 cannot happen, so no
     2044       need to escape */
     2045    nal_len = q - nal_buf;
     2046    if (dyn_buf_resize(out_buf, out_buf->len + nal_len) < 0)
     2047        return -1;
     2048    memcpy(out_buf->buf + out_buf->len, nal_buf, nal_len);
     2049    out_buf->len += nal_len;
     2050    return 0;
     2051}
     2052
     2053static int build_modified_hevc(uint8_t **pout_buf,
     2054                               const uint8_t *cbuf, int cbuf_len,
     2055                               const uint8_t *abuf, int abuf_len,
     2056                               const uint16_t *frame_duration_tab,
     2057                               int frame_count)
     2058{
     2059    DynBuf out_buf_s, *out_buf = &out_buf_s;
     2060    uint8_t *msps;
     2061    const uint8_t *nal_buf;
     2062    int msps_len, cidx, aidx, is_alpha, nal_len, first_nal, start, l, frame_num;
     2063   
     2064    dyn_buf_init(out_buf);
     2065   
     2066    /* add alpha MSPS */
     2067    aidx = 0; /* avoids warning */
     2068    if (abuf) {
     2069        aidx = build_modified_sps(&msps, &msps_len, abuf, abuf_len);
     2070        if (aidx < 0)
     2071            goto fail;
     2072        if (dyn_buf_resize(out_buf, out_buf->len + msps_len) < 0)
     2073            goto fail;
     2074        memcpy(out_buf->buf + out_buf->len, msps, msps_len);
     2075        out_buf->len += msps_len;
     2076        free(msps);
     2077    }
     2078   
     2079    /* add color MSPS */
     2080    cidx = build_modified_sps(&msps, &msps_len, cbuf, cbuf_len);
     2081    if (cidx < 0)
     2082        goto fail;
     2083    if (dyn_buf_resize(out_buf, out_buf->len + msps_len) < 0)
     2084        goto fail;
     2085    memcpy(out_buf->buf + out_buf->len, msps, msps_len);
     2086    out_buf->len += msps_len;
     2087    free(msps);
     2088
     2089    /* add the remaining NALs, alternating between alpha (if present)
     2090       and color. */
     2091    is_alpha = (abuf != NULL);
     2092    first_nal = 1;
     2093    frame_num = 0;
     2094    for(;;) {
     2095        if (!is_alpha) {
     2096            if (cidx >= cbuf_len) {
     2097                if (abuf) {
     2098                    fprintf(stderr, "Incorrect number of alpha NALs\n");
     2099                    goto fail;
     2100                }
     2101                break;
     2102            }
     2103            nal_buf = cbuf + cidx;
     2104            nal_len = find_nal_end(nal_buf, cbuf_len - cidx);
     2105            //            printf("cidx=%d/%d nal_len=%d\n", cidx, cbuf_len, nal_len);
     2106            if (nal_len < 0)
     2107                goto fail;
     2108            cidx += nal_len;
     2109        } else {
     2110            if (aidx >= abuf_len)
     2111                break;
     2112            nal_buf = abuf + aidx;
     2113            nal_len = find_nal_end(nal_buf, abuf_len - aidx);
     2114            //            printf("aidx=%d/%d nal_len=%d\n", aidx, abuf_len, nal_len);
     2115            if (nal_len < 0)
     2116                goto fail;
     2117            aidx += nal_len;
     2118        }
     2119        start = 3 + (nal_buf[2] == 0);
     2120        if (!is_alpha) {
     2121            int nut;
     2122            /* add SEI NAL for the frame duration (animation case) */
     2123            nut = (nal_buf[start] >> 1) & 0x3f;
     2124            if ((nut <= 9 || (nut >= 16 && nut <= 21)) && 
     2125                start + 2 < nal_len && (nal_buf[start + 2] & 0x80)) {
     2126                int frame_ticks;
     2127                assert(frame_num < frame_count);
     2128                frame_ticks = frame_duration_tab[frame_num];
     2129                if (frame_ticks > 1) {
     2130                    add_frame_duration_sei(out_buf, frame_ticks);
     2131                }
     2132                frame_num++;
     2133            }
     2134        }
     2135        if (first_nal) {
     2136            /* skip first start code */
     2137            l = start;
     2138        } else {
     2139            l = 0;
     2140        }
     2141        if (dyn_buf_resize(out_buf, out_buf->len + nal_len - l) < 0)
     2142            goto fail;
     2143        //        printf("add nal len=%d\n", nal_len - l);
     2144        memcpy(out_buf->buf + out_buf->len, nal_buf + l, nal_len - l);
     2145        if (is_alpha) {
     2146            /* set nul_layer_id of alpha to '1' */
     2147            out_buf->buf[out_buf->len + (start - l) + 1] |= 1 << 3;
     2148        }
     2149        out_buf->len += nal_len - l;
     2150
     2151        if (abuf) {
     2152            is_alpha ^= 1;
     2153        }
     2154        first_nal = 0;
     2155    }
     2156    *pout_buf = out_buf->buf;
     2157    return out_buf->len;
     2158 fail:
     2159    free(out_buf->buf);
     2160    return -1;
     2161}
     2162
     2163typedef enum {
     2164#if defined(USE_JCTVC)
     2165    HEVC_ENCODER_JCTVC,
     2166#endif
     2167#if defined(USE_X265)
     2168    HEVC_ENCODER_X265,
     2169#endif
     2170
     2171    HEVC_ENCODER_COUNT,
     2172} HEVCEncoderEnum;
     2173
     2174static HEVCEncoder *hevc_encoder_tab[HEVC_ENCODER_COUNT] = {
     2175#if defined(USE_JCTVC)
     2176    &jctvc_encoder,
     2177#endif
     2178#if defined(USE_X265)
     2179    &x265_hevc_encoder,
     2180#endif
     2181};
     2182
     2183#define IMAGE_HEADER_MAGIC 0x425047fb
     2184
     2185#define DEFAULT_QP 28
     2186#define DEFAULT_BIT_DEPTH 8
     2187
     2188#ifdef RExt__HIGH_BIT_DEPTH_SUPPORT
     2189#define BIT_DEPTH_MAX 14
     2190#else
     2191#define BIT_DEPTH_MAX 12
     2192#endif
     2193#define DEFAULT_COMPRESS_LEVEL 8
     2194
     2195
     2196typedef struct BPGEncoderContext BPGEncoderContext;
     2197
     2198typedef struct BPGEncoderParameters {
     2199    int qp; /* 0 ... 51 */
     2200    int alpha_qp; /* -1 ... 51. -1 means same as qp */
     2201    int lossless; /* true if lossless compression (qp and alpha_qp are
     2202                     ignored) */
     2203    BPGImageFormatEnum preferred_chroma_format;
     2204    int sei_decoded_picture_hash; /* 0, 1 */
     2205    int compress_level; /* 1 ... 9 */
     2206    int verbose;
     2207    HEVCEncoderEnum encoder_type;
     2208    int animated; /* 0 ... 1: if true, encode as animated image */
     2209    uint16_t loop_count; /* animations: number of loops. 0=infinite */
     2210    /* animations: the frame delay is a multiple of
     2211       frame_delay_num/frame_delay_den seconds */
     2212    uint16_t frame_delay_num;
     2213    uint16_t frame_delay_den;
     2214} BPGEncoderParameters;
     2215
     2216typedef int BPGEncoderWriteFunc(void *opaque, const uint8_t *buf, int buf_len);
     2217
     2218struct BPGEncoderContext {
     2219    BPGEncoderParameters params;
     2220    BPGMetaData *first_md;
     2221    HEVCEncoder *encoder;
     2222    int frame_count;
     2223    HEVCEncoderContext *enc_ctx;
     2224    HEVCEncoderContext *alpha_enc_ctx;
     2225    int frame_ticks;
     2226    uint16_t *frame_duration_tab;
     2227    int frame_duration_tab_size;
     2228};
     2229
     2230void *mallocz(size_t size)
     2231{
     2232    void *ptr;
     2233    ptr = malloc(size);
     2234    if (!ptr)
     2235        return NULL;
     2236    memset(ptr, 0, size);
     2237    return ptr;
     2238}
     2239
     2240BPGEncoderParameters *bpg_encoder_param_alloc(void)
     2241{
     2242    BPGEncoderParameters *p;
     2243    p = mallocz(sizeof(BPGEncoderParameters));
     2244    if (!p)
     2245        return NULL;
     2246    p->qp = DEFAULT_QP;
     2247    p->alpha_qp = -1;
     2248    p->preferred_chroma_format = BPG_FORMAT_420;
     2249    p->compress_level = DEFAULT_COMPRESS_LEVEL;
     2250    p->frame_delay_num = 1;
     2251    p->frame_delay_den = 25;
     2252    p->loop_count = 0;
     2253    return p;
     2254}
     2255
     2256void bpg_encoder_param_free(BPGEncoderParameters *p)
     2257{
     2258    free(p);
     2259}
     2260
     2261BPGEncoderContext *bpg_encoder_open(BPGEncoderParameters *p)
     2262{
     2263    BPGEncoderContext *s;
     2264
     2265    s = mallocz(sizeof(BPGEncoderContext));
     2266    if (!s)
     2267        return NULL;
     2268    s->params = *p;
     2269    s->encoder = hevc_encoder_tab[s->params.encoder_type];
     2270    s->frame_ticks = 1;
     2271    return s;
     2272}
     2273
     2274void bpg_encoder_set_extension_data(BPGEncoderContext *s,
     2275                                    BPGMetaData *md)
     2276{
     2277    s->first_md = md;
     2278}
     2279
     2280static int bpg_encoder_encode_trailer(BPGEncoderContext *s,
     2281                                      BPGEncoderWriteFunc *write_func,
     2282                                      void *opaque)
     2283{
     2284    uint8_t *out_buf, *alpha_buf, *hevc_buf;
     2285    int out_buf_len, alpha_buf_len, hevc_buf_len;
     2286
     2287    out_buf_len = s->encoder->close(s->enc_ctx, &out_buf);
     2288    if (out_buf_len < 0) {
     2289        fprintf(stderr, "Error while encoding picture\n");
     2290        exit(1);
     2291    }
     2292    s->enc_ctx = NULL;
     2293   
     2294    alpha_buf = NULL;
     2295    alpha_buf_len = 0;
     2296    if (s->alpha_enc_ctx) {
     2297        alpha_buf_len = s->encoder->close(s->alpha_enc_ctx, &alpha_buf);
     2298        if (alpha_buf_len < 0) {
     2299            fprintf(stderr, "Error while encoding picture (alpha plane)\n");
     2300            exit(1);
     2301        }
     2302        s->alpha_enc_ctx = NULL;
     2303    }
     2304   
     2305    hevc_buf = NULL;
     2306    hevc_buf_len = build_modified_hevc(&hevc_buf, out_buf, out_buf_len,
     2307                                       alpha_buf, alpha_buf_len,
     2308                                       s->frame_duration_tab, s->frame_count);
     2309    if (hevc_buf_len < 0) {
     2310        fprintf(stderr, "Error while creating HEVC data\n");
     2311        exit(1);
     2312    }
     2313    free(out_buf);
     2314    free(alpha_buf);
     2315   
     2316    if (write_func(opaque, hevc_buf, hevc_buf_len) != hevc_buf_len) {
     2317        fprintf(stderr, "Error while writing HEVC data\n");
     2318        exit(1);
     2319    }
     2320    free(hevc_buf);
     2321    return 0;
     2322}
     2323
     2324int bpg_encoder_set_frame_duration(BPGEncoderContext *s, int frame_ticks)
     2325{
     2326    if (frame_ticks >= 1 && frame_ticks <= 65535) {
     2327        s->frame_ticks = frame_ticks;
     2328        return 0;
     2329    } else {
     2330        return -1;
     2331    }
     2332}
     2333
     2334/* Warning: currently 'img' is modified. When encoding animations, img
     2335   = NULL indicates the end of the stream. */
     2336int bpg_encoder_encode(BPGEncoderContext *s, Image *img,
     2337                       BPGEncoderWriteFunc *write_func,
     2338                       void *opaque)
     2339{
     2340    const BPGEncoderParameters *p = &s->params;
     2341    Image *img_alpha;
     2342    HEVCEncodeParams ep_s, *ep = &ep_s;
     2343    uint8_t *extension_buf;
     2344    int extension_buf_len;
     2345    int cb_size, width, height;
     2346
     2347    if (p->animated && !img) {
     2348        return bpg_encoder_encode_trailer(s, write_func, opaque);
     2349    }
     2350
     2351    /* extract the alpha plane */
     2352    if (img->has_alpha) {
     2353        int c_idx;
     2354
     2355        img_alpha = malloc(sizeof(Image));
     2356        memset(img_alpha, 0, sizeof(*img_alpha));
     2357        if (img->format == BPG_FORMAT_GRAY)
     2358            c_idx = 1;
     2359        else
     2360            c_idx = 3;
     2361
     2362        img_alpha->w = img->w;
     2363        img_alpha->h = img->h;
     2364        img_alpha->format = BPG_FORMAT_GRAY;
     2365        img_alpha->has_alpha = 0;
     2366        img_alpha->color_space = BPG_CS_YCbCr;
     2367        img_alpha->bit_depth = img->bit_depth;
     2368        img_alpha->pixel_shift = img->pixel_shift;
     2369        img_alpha->data[0] = img->data[c_idx];
     2370        img_alpha->linesize[0] = img->linesize[c_idx];
     2371       
     2372        img->data[c_idx] = NULL;
     2373        img->has_alpha = 0;
     2374    } else {
     2375        img_alpha = NULL;
     2376    }
     2377
     2378    if (img->format == BPG_FORMAT_444 && img->color_space != BPG_CS_RGB) {
     2379        if (p->preferred_chroma_format == BPG_FORMAT_420 ||
     2380            p->preferred_chroma_format == BPG_FORMAT_420_VIDEO) {
     2381            int c_h_phase = (p->preferred_chroma_format == BPG_FORMAT_420);
     2382            if (image_ycc444_to_ycc420(img, c_h_phase) != 0)
     2383                goto error_convert;
     2384        } else if (p->preferred_chroma_format == BPG_FORMAT_422 ||
     2385                   p->preferred_chroma_format == BPG_FORMAT_422_VIDEO) {
     2386            int c_h_phase = (p->preferred_chroma_format == BPG_FORMAT_422);
     2387            if (image_ycc444_to_ycc422(img, c_h_phase) != 0)  {
     2388            error_convert:
     2389                fprintf(stderr, "Cannot convert image\n");
     2390                exit(1);
     2391            }
     2392        }
     2393    }
     2394
     2395    cb_size = 8; /* XXX: should make it configurable. We assume the
     2396                    HEVC encoder uses the same value */
     2397    width = img->w;
     2398    height = img->h;
     2399    image_pad(img, cb_size);
     2400    if (img_alpha)
     2401        image_pad(img_alpha, cb_size);
     2402
     2403    /* convert to the allocated pixel width to 8 bit if needed by the
     2404       HEVC encoder */
     2405    if (img->bit_depth == 8) {
     2406        image_convert16to8(img);
     2407        if (img_alpha)
     2408            image_convert16to8(img_alpha);
     2409    }
     2410       
     2411    if (s->frame_count == 0) {
     2412        memset(ep, 0, sizeof(*ep));
     2413        ep->qp = p->qp;
     2414        ep->width = img->w;
     2415        ep->height = img->h;
     2416        ep->chroma_format = img->format;
     2417        ep->bit_depth = img->bit_depth;
     2418        ep->intra_only = !p->animated;
     2419        ep->lossless = p->lossless;
     2420        ep->sei_decoded_picture_hash = p->sei_decoded_picture_hash;
     2421        ep->compress_level = p->compress_level;
     2422        ep->verbose = p->verbose;
     2423
     2424        s->enc_ctx = s->encoder->open(ep);
     2425        if (!s->enc_ctx) {
     2426            fprintf(stderr, "Error while opening encoder\n");
     2427            exit(1);
     2428        }
     2429
     2430        if (img_alpha) {
     2431            if (p->alpha_qp < 0)
     2432                ep->qp = p->qp;
     2433            else
     2434                ep->qp = p->alpha_qp;
     2435            ep->chroma_format = 0;
     2436           
     2437            s->alpha_enc_ctx = s->encoder->open(ep);
     2438            if (!s->alpha_enc_ctx) {
     2439                fprintf(stderr, "Error while opening alpha encoder\n");
     2440                exit(1);
     2441            }
     2442        }
     2443
     2444        /* prepare the extension data */
     2445        if (p->animated) {
     2446            BPGMetaData *md;
     2447            uint8_t buf[15], *q;
     2448
     2449            md = bpg_md_alloc(BPG_EXTENSION_TAG_ANIM_CONTROL);
     2450            q = buf;
     2451            put_ue(&q, p->loop_count);
     2452            put_ue(&q, p->frame_delay_num);
     2453            put_ue(&q, p->frame_delay_den);
     2454            md->buf_len = q - buf;
     2455            md->buf = malloc(md->buf_len);
     2456            memcpy(md->buf, buf, md->buf_len);
     2457            md->next = s->first_md;
     2458            s->first_md = md;
     2459        }
     2460
     2461        extension_buf = NULL;
     2462        extension_buf_len = 0;
     2463        if (s->first_md) {
     2464            BPGMetaData *md1;
     2465            int max_len;
     2466            uint8_t *q;
     2467           
     2468            max_len = 0;
     2469            for(md1 = s->first_md; md1 != NULL; md1 = md1->next) {
     2470                max_len += md1->buf_len + 5 * 2;
     2471            }
     2472            extension_buf = malloc(max_len);
     2473            q = extension_buf;
     2474            for(md1 = s->first_md; md1 != NULL; md1 = md1->next) {
     2475                put_ue(&q, md1->tag);
     2476                put_ue(&q, md1->buf_len);
     2477                memcpy(q, md1->buf, md1->buf_len);
     2478                q += md1->buf_len;
     2479            }
     2480            extension_buf_len = q - extension_buf;
     2481           
     2482            bpg_md_free(s->first_md);
     2483            s->first_md = NULL;
     2484        }
     2485   
     2486        {
     2487            uint8_t img_header[128], *q;
     2488            int v, has_alpha, has_extension, alpha2_flag, alpha1_flag, format;
     2489           
     2490            has_alpha = (img_alpha != NULL);
     2491            has_extension = (extension_buf_len > 0);
     2492           
     2493           
     2494            if (has_alpha) {
     2495                if (img->has_w_plane) {
     2496                    alpha1_flag = 0;
     2497                    alpha2_flag = 1;
     2498                } else {
     2499                    alpha1_flag = 1;
     2500                    alpha2_flag = img->premultiplied_alpha;
     2501                }
     2502            } else {
     2503                alpha1_flag = 0;
     2504                alpha2_flag = 0;
     2505            }
     2506           
     2507            q = img_header;
     2508            *q++ = (IMAGE_HEADER_MAGIC >> 24) & 0xff;
     2509            *q++ = (IMAGE_HEADER_MAGIC >> 16) & 0xff;
     2510            *q++ = (IMAGE_HEADER_MAGIC >> 8) & 0xff;
     2511            *q++ = (IMAGE_HEADER_MAGIC >> 0) & 0xff;
     2512
     2513            if (img->c_h_phase == 0 && img->format == BPG_FORMAT_420)
     2514                format = BPG_FORMAT_420_VIDEO;
     2515            else if (img->c_h_phase == 0 && img->format == BPG_FORMAT_422)
     2516                format = BPG_FORMAT_422_VIDEO;
     2517            else
     2518                format = img->format;
     2519            v = (format << 5) | (alpha1_flag << 4) | (img->bit_depth - 8);
     2520            *q++ = v;
     2521            v = (img->color_space << 4) | (has_extension << 3) |
     2522                (alpha2_flag << 2) | (img->limited_range << 1) |
     2523                p->animated;
     2524            *q++ = v;
     2525            put_ue(&q, width);
     2526            put_ue(&q, height);
     2527           
     2528            put_ue(&q, 0); /* zero length means up to the end of the file */
     2529            if (has_extension) {
     2530                put_ue(&q, extension_buf_len); /* extension data length */
     2531            }
     2532           
     2533            write_func(opaque, img_header, q - img_header);
     2534           
     2535            if (has_extension) {
     2536                if (write_func(opaque, extension_buf, extension_buf_len) != extension_buf_len) {
     2537                    fprintf(stderr, "Error while writing extension data\n");
     2538                    exit(1);
     2539                }
     2540                free(extension_buf);
     2541            }
     2542        }
     2543    }
     2544
     2545    /* store the frame duration */
     2546    if ((s->frame_count + 1) > s->frame_duration_tab_size) {
     2547        s->frame_duration_tab_size = (s->frame_duration_tab_size * 3) / 2;
     2548        if (s->frame_duration_tab_size < (s->frame_count + 1))
     2549            s->frame_duration_tab_size = (s->frame_count + 1);
     2550        s->frame_duration_tab = realloc(s->frame_duration_tab,
     2551                                        sizeof(s->frame_duration_tab) * s->frame_duration_tab_size);
     2552    }
     2553    s->frame_duration_tab[s->frame_count] = s->frame_ticks;
     2554
     2555    s->encoder->encode(s->enc_ctx, img);
     2556   
     2557    if (img_alpha) {
     2558        s->encoder->encode(s->alpha_enc_ctx, img_alpha);
     2559        image_free(img_alpha);
     2560    }
     2561   
     2562    s->frame_count++;
     2563
     2564    if (!p->animated)
     2565        bpg_encoder_encode_trailer(s, write_func, opaque);
     2566
     2567    return 0;
     2568}
     2569
     2570void bpg_encoder_close(BPGEncoderContext *s)
     2571{
     2572    free(s->frame_duration_tab);
     2573    bpg_md_free(s->first_md);
     2574    free(s);
     2575}
  • xpra/codecs/bpg/bpgenc.h

     
     1/*
     2 * BPG encoder
     3 *
     4 * Copyright (c) 2014 Fabrice Bellard
     5 *
     6 * Permission is hereby granted, free of charge, to any person obtaining a copy
     7 * of this software and associated documentation files (the "Software"), to deal
     8 * in the Software without restriction, including without limitation the rights
     9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     10 * copies of the Software, and to permit persons to whom the Software is
     11 * furnished to do so, subject to the following conditions:
     12 *
     13 * The above copyright notice and this permission notice shall be included in
     14 * all copies or substantial portions of the Software.
     15 *
     16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     22 * THE SOFTWARE.
     23 */
     24#ifdef __cplusplus
     25extern "C" {
     26#endif
     27
     28#include "libbpg.h"
     29
     30typedef struct {
     31    int w, h;
     32    BPGImageFormatEnum format; /* x_VIDEO values are forbidden here */
     33    uint8_t c_h_phase; /* 4:2:2 or 4:2:0 : give the horizontal chroma
     34                          position. 0=MPEG2, 1=JPEG. */
     35    uint8_t has_alpha;
     36    uint8_t has_w_plane;
     37    uint8_t limited_range;
     38    uint8_t premultiplied_alpha;
     39    BPGColorSpaceEnum color_space;
     40    uint8_t bit_depth;
     41    uint8_t pixel_shift; /* (1 << pixel_shift) bytes per pixel */
     42    uint8_t *data[4];
     43    int linesize[4];
     44} Image;
     45
     46typedef struct {
     47    int width;
     48    int height;
     49    int chroma_format; /* 0-3 */
     50    int bit_depth; /* 8-14 */
     51    int intra_only; /* 0-1 */
     52
     53    int qp; /* quantizer 0-51 */
     54    int lossless; /* 0-1 lossless mode */
     55    int sei_decoded_picture_hash; /* 0=no hash, 1=MD5 hash */
     56    int compress_level; /* 1-9 */
     57    int verbose;
     58} HEVCEncodeParams;
     59
     60typedef struct HEVCEncoderContext HEVCEncoderContext;
     61
     62typedef struct {
     63    HEVCEncoderContext *(*open)(const HEVCEncodeParams *params);
     64    int (*encode)(HEVCEncoderContext *s, Image *img);
     65    int (*close)(HEVCEncoderContext *s, uint8_t **pbuf);
     66} HEVCEncoder;
     67
     68extern HEVCEncoder jctvc_encoder;
     69extern HEVCEncoder x265_hevc_encoder;
     70
     71int x265_encode_picture(uint8_t **pbuf, Image *img,
     72                        const HEVCEncodeParams *params);
     73void save_yuv1(Image *img, FILE *f);
     74void save_yuv(Image *img, const char *filename);
     75
     76#ifdef __cplusplus
     77}
     78#endif
     79
  • xpra/codecs/bpg/decode.pyx

     
     1# This file is part of Xpra.
     2# Copyright (C) 2015 Antoine Martin <antoine@devloop.org.uk>
     3# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
     4# later version. See the file COPYING for details.
     5
     6from xpra.log import Logger
     7log = Logger("encoder", "bpg")
     8
     9
     10from libc.stdint cimport uint8_t, uint32_t
     11
     12cdef extern from *:
     13    ctypedef unsigned long size_t
     14
     15cdef extern from "stdlib.h":
     16    void free(void *ptr)
     17
     18
     19cdef extern from "../../buffers/memalign.h":
     20    void *xmemalign(size_t size)
     21
     22cdef extern from "../../buffers/buffers.h":
     23    object memory_as_pybuffer(void* ptr, Py_ssize_t buf_len, int readonly)
     24
     25
     26def get_version():
     27    return 1
     28
     29def get_encodings():
     30    return ["bpg"]
     31
     32
     33def decompress(data, has_alpha, rgb_format=None):
     34    return None
  • xpra/codecs/bpg/encode.pyx

     
     1# This file is part of Xpra.
     2# Copyright (C) 2015 Antoine Martin <antoine@devloop.org.uk>
     3# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
     4# later version. See the file COPYING for details.
     5
     6import os
     7
     8from xpra.log import Logger
     9log = Logger("encoder", "bpg")
     10
     11from libc.stdint cimport uint8_t, uint32_t
     12
     13cdef extern from "string.h":
     14    void * memset ( void * ptr, int value, size_t num )
     15
     16cdef extern from *:
     17    ctypedef unsigned long size_t
     18
     19cdef extern from "stdlib.h":
     20    void free(void *ptr)
     21
     22
     23cdef extern from "../../buffers/buffers.h":
     24    int    object_as_buffer(object obj, const void ** buffer, Py_ssize_t * buffer_len)
     25
     26
     27def get_encodings():
     28    return ["bpg"]
     29
     30def get_version():
     31    return 1
     32
     33def compress(pixels, width, height, stride=0, quality=50, speed=50, has_alpha=False):
     34    return None
  • xpra/codecs/bpg/libbpg.c

     
     1/*
     2 * libbpg
     3 *
     4 * Copyright (c) 2014 Fabrice Bellard
     5 *
     6 * Permission is hereby granted, free of charge, to any person obtaining a copy
     7 * of this software and associated documentation files (the "Software"), to deal
     8 * in the Software without restriction, including without limitation the rights
     9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     10 * copies of the Software, and to permit persons to whom the Software is
     11 * furnished to do so, subject to the following conditions:
     12 *
     13 * The above copyright notice and this permission notice shall be included in
     14 * all copies or substantial portions of the Software.
     15 *
     16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     22 * THE SOFTWARE.
     23 */
     24#include <math.h>
     25#ifdef EMSCRIPTEN
     26#include <emscripten.h>
     27#endif
     28
     29#include <libavutil/opt.h>
     30#include <libavcodec/avcodec.h>
     31#include <libavutil/common.h>
     32
     33/* The following global defines are used:
     34   - USE_VAR_BIT_DEPTH : support of bit depth > 8 bits
     35   - USE_PRED : support of animations
     36*/
     37   
     38#ifndef EMSCRIPTEN
     39#define USE_RGB48 /* support all pixel formats */
     40//#define DEBUG
     41#endif
     42
     43#if !defined(DEBUG)
     44#define NDEBUG
     45#endif
     46
     47#include <assert.h>
     48#include "libbpg.h"
     49
     50#define BPG_HEADER_MAGIC 0x425047fb
     51
     52#define ITAPS2 4
     53#define ITAPS (2 * ITAPS2) /* number of taps of the interpolation filter */
     54
     55#ifdef USE_VAR_BIT_DEPTH
     56typedef uint16_t PIXEL;
     57#else
     58typedef uint8_t PIXEL;
     59#endif
     60
     61#define MAX_DATA_SIZE ((1 << 30) - 1)
     62
     63typedef struct {
     64    int c_shift;
     65    int c_rnd;
     66    int c_one;
     67    int y_one, y_offset;
     68    int c_r_cr, c_g_cb, c_g_cr, c_b_cb;
     69    int c_center;
     70    int bit_depth;
     71    int limited_range;
     72} ColorConvertState;
     73
     74typedef void ColorConvertFunc(ColorConvertState *s,
     75                              uint8_t *dst, const PIXEL *y_ptr,
     76                              const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     77                              int n, int incr);
     78
     79struct BPGDecoderContext {
     80    AVCodecContext *dec_ctx;
     81    AVCodecContext *alpha_dec_ctx;
     82    AVFrame *frame;
     83    AVFrame *alpha_frame;
     84    int w, h;
     85    BPGImageFormatEnum format;
     86    uint8_t c_h_phase; /* only used for 422 and 420 */
     87    uint8_t has_alpha; /* true if alpha or W plane */
     88    uint8_t bit_depth;
     89    uint8_t has_w_plane;
     90    uint8_t limited_range;
     91    uint8_t premultiplied_alpha;
     92    uint8_t has_animation;
     93    BPGColorSpaceEnum color_space;
     94    uint8_t keep_extension_data; /* true if the extension data must be
     95                                    kept during parsing */
     96    uint8_t decode_animation; /* true if animation decoding is enabled */
     97    BPGExtensionData *first_md;
     98
     99    /* animation */
     100    uint16_t loop_count;
     101    uint16_t frame_delay_num;
     102    uint16_t frame_delay_den;
     103    uint8_t *input_buf;
     104    int input_buf_pos;
     105    int input_buf_len;
     106
     107    /* the following is used for format conversion */
     108    uint8_t output_inited;
     109    BPGDecoderOutputFormat out_fmt;
     110    uint8_t is_rgba;
     111    uint8_t is_16bpp;
     112    uint8_t is_cmyk;
     113    int y; /* current line */
     114    int w2, h2;
     115    const uint8_t *y_buf, *cb_buf, *cr_buf, *a_buf;
     116    int y_linesize, cb_linesize, cr_linesize, a_linesize;
     117    PIXEL *cb_buf2, *cr_buf2, *cb_buf3[ITAPS], *cr_buf3[ITAPS];
     118    int16_t *c_buf4;
     119    ColorConvertState cvt;
     120    ColorConvertFunc *cvt_func;
     121};
     122
     123/* ffmpeg utilities */
     124#ifdef USE_AV_LOG
     125void av_log(void* avcl, int level, const char *fmt, ...)
     126{
     127#ifdef DEBUG
     128    va_list ap;
     129
     130    va_start(ap, fmt);
     131    vfprintf(stderr, fmt, ap);
     132    va_end(ap);
     133#endif
     134}
     135
     136void avpriv_report_missing_feature(void *avc, const char *msg, ...)
     137{
     138#ifdef DEBUG
     139    va_list ap;
     140
     141    va_start(ap, msg);
     142    vfprintf(stderr, msg, ap);
     143    va_end(ap);
     144#endif
     145}
     146#endif /* USE_AV_LOG */
     147
     148/* return < 0 if error, otherwise the consumed length */
     149static int get_ue32(uint32_t *pv, const uint8_t *buf, int len)
     150{
     151    const uint8_t *p;
     152    uint32_t v;
     153    int a;
     154
     155    if (len <= 0)
     156        return -1;
     157    p = buf;
     158    a = *p++;
     159    len--;
     160    if (a < 0x80) {
     161        *pv = a;
     162        return 1;
     163    } else if (a == 0x80) {
     164        /* we don't accept non canonical encodings */
     165        return -1;
     166    }
     167    v = a & 0x7f;
     168    for(;;) {
     169        if (len <= 0)
     170            return -1;
     171        a = *p++;
     172        len--;
     173        v = (v << 7) | (a & 0x7f);
     174        if (!(a & 0x80))
     175            break;
     176    }
     177    *pv = v;
     178    return p - buf;
     179}
     180
     181static int get_ue(uint32_t *pv, const uint8_t *buf, int len)
     182{
     183    int ret;
     184    ret = get_ue32(pv, buf, len);
     185    if (ret < 0)
     186        return ret;
     187    /* limit the maximum size to avoid overflows in buffer
     188       computations */
     189    if (*pv > MAX_DATA_SIZE)
     190        return -1;
     191    return ret;
     192}
     193
     194static int build_msps(uint8_t **pbuf, int *pbuf_len,
     195                      const uint8_t *input_data, int input_data_len1,
     196                      int width, int height, int chroma_format_idc,
     197                      int bit_depth)
     198{
     199    int input_data_len = input_data_len1;
     200    int idx, msps_len, ret, buf_len, i;
     201    uint32_t len;
     202    uint8_t *buf, *msps_buf;
     203
     204    *pbuf = NULL;
     205
     206    /* build the modified SPS header to please libavcodec */
     207    ret = get_ue(&len, input_data, input_data_len);
     208    if (ret < 0)
     209        return -1;
     210    input_data += ret;
     211    input_data_len -= ret;
     212   
     213    if (len > input_data_len)
     214        return -1;
     215
     216    msps_len = 1 + 4 + 4 + 1 + len;
     217    msps_buf = av_malloc(msps_len);
     218    idx = 0;
     219    msps_buf[idx++] = chroma_format_idc;
     220    msps_buf[idx++] = (width >> 24);
     221    msps_buf[idx++] = (width >> 16);
     222    msps_buf[idx++] = (width >> 8);
     223    msps_buf[idx++] = (width >> 0);
     224    msps_buf[idx++] = (height >> 24);
     225    msps_buf[idx++] = (height >> 16);
     226    msps_buf[idx++] = (height >> 8);
     227    msps_buf[idx++] = (height >> 0);
     228    msps_buf[idx++] = bit_depth - 8;
     229    memcpy(msps_buf + idx, input_data, len);
     230    idx += len;
     231    assert(idx == msps_len);
     232    input_data += len;
     233    input_data_len -= len;
     234   
     235    buf_len = 4 + 2 + msps_len * 2 + 4 + (input_data_len - len);
     236    buf = av_malloc(buf_len);
     237
     238    idx = 0;
     239    /* NAL header */
     240    buf[idx++] = 0x00;
     241    buf[idx++] = 0x00;
     242    buf[idx++] = 0x00;
     243    buf[idx++] = 0x01;
     244    buf[idx++] = (48 << 1); /* application specific NAL unit type */
     245    buf[idx++] = 1;
     246
     247    /* add the modified SPS with the correct escape codes */
     248    i = 0;
     249    while (i < msps_len) {
     250        if ((i + 1) < msps_len && msps_buf[i] == 0 && msps_buf[i + 1] == 0) {
     251            buf[idx++] = 0x00;
     252            buf[idx++] = 0x00;
     253            buf[idx++] = 0x03;
     254            i += 2;
     255        } else {
     256            buf[idx++] = msps_buf[i++];
     257        }
     258    }
     259    /* the last byte cannot be 0 */
     260    if (idx == 0 || buf[idx - 1] == 0x00)
     261        buf[idx++] = 0x80;
     262    av_free(msps_buf);
     263   
     264    *pbuf_len = idx;
     265    *pbuf = buf;
     266    return input_data_len1 - input_data_len;
     267}
     268
     269/* return the position of the end of the NAL or -1 if error */
     270static int find_nal_end(const uint8_t *buf, int buf_len, int has_startcode)
     271{
     272    int idx;
     273
     274    idx = 0;
     275    if (has_startcode) {
     276        if (buf_len >= 4 &&
     277            buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 1) {
     278            idx = 4;
     279        } else if (buf_len >= 3 &&
     280                   buf[0] == 0 && buf[1] == 0 && buf[2] == 1) {
     281            idx = 3;
     282        } else {
     283            return -1;
     284        }
     285    }
     286    /* NAL header */
     287    if (idx + 2 > buf_len)
     288        return -1;
     289    /* find the last byte */
     290    for(;;) {
     291        if (idx + 2 >= buf_len) {
     292            idx = buf_len;
     293            break;
     294        }
     295        if (buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 1)
     296            break;
     297        if (idx + 3 < buf_len &&
     298            buf[idx] == 0 && buf[idx + 1] == 0 && buf[idx + 2] == 0 && buf[idx + 3] == 1)
     299            break;
     300        idx++;
     301    }
     302    return idx;
     303}
     304
     305typedef struct {
     306    uint8_t *buf;
     307    int size;
     308    int len;
     309} DynBuf;
     310
     311static void dyn_buf_init(DynBuf *s)
     312{
     313    s->buf = NULL;
     314    s->size = 0;
     315    s->len = 0;
     316}
     317
     318static int dyn_buf_resize(DynBuf *s, int size)
     319{
     320    int new_size;
     321    uint8_t *new_buf;
     322
     323    if (size <= s->size)
     324        return 0;
     325    new_size = (s->size * 3) / 2;
     326    if (new_size < size)
     327        new_size = size;
     328    new_buf = av_realloc(s->buf, new_size);
     329    if (!new_buf)
     330        return -1;
     331    s->buf = new_buf;
     332    s->size = new_size;
     333    return 0;
     334}
     335
     336static int dyn_buf_push(DynBuf *s, const uint8_t *data, int len)
     337{
     338    if (dyn_buf_resize(s, s->len + len) < 0)
     339        return -1;
     340    memcpy(s->buf + s->len, data, len);
     341    s->len += len;
     342    return 0;
     343}
     344
     345extern AVCodec ff_hevc_decoder;
     346
     347static int hevc_decode_init1(DynBuf *pbuf, AVFrame **pframe,
     348                             AVCodecContext **pc,
     349                             const uint8_t *buf, int buf_len,
     350                             int width, int height, int chroma_format_idc,
     351                             int bit_depth)
     352{
     353    AVCodec *codec;
     354    AVCodecContext *c;
     355    AVFrame *frame;
     356    uint8_t *nal_buf;
     357    int nal_len, ret, ret1;
     358
     359    ret = build_msps(&nal_buf, &nal_len, buf, buf_len,
     360                     width, height, chroma_format_idc, bit_depth);
     361    if (ret < 0)
     362        return -1;
     363    ret1 = dyn_buf_push(pbuf, nal_buf, nal_len);
     364    av_free(nal_buf);
     365    if (ret1 < 0)
     366        return -1;
     367   
     368    codec = &ff_hevc_decoder;
     369
     370    c = avcodec_alloc_context3(codec);
     371    if (!c)
     372        return -1;
     373    frame = av_frame_alloc();
     374    if (!frame)
     375        return -1;
     376    /* for testing: use the MD5 or CRC in SEI to check the decoded bit
     377       stream. */
     378    c->err_recognition |= AV_EF_CRCCHECK;
     379    /* open it */
     380    if (avcodec_open2(c, codec, NULL) < 0) {
     381        av_frame_free(&frame);
     382        return -1;
     383    }
     384    *pc = c;
     385    *pframe = frame;
     386    return ret;
     387}
     388
     389static int hevc_write_frame(AVCodecContext *avctx,
     390                            AVFrame *frame,
     391                            uint8_t *buf, int buf_len)
     392{
     393    AVPacket avpkt;
     394    int len, got_frame;
     395
     396    av_init_packet(&avpkt);
     397    avpkt.data = (uint8_t *)buf;
     398    avpkt.size = buf_len;
     399    /* avoid using uninitialized data */
     400    memset(buf + buf_len, 0, FF_INPUT_BUFFER_PADDING_SIZE);
     401    len = avcodec_decode_video2(avctx, frame, &got_frame, &avpkt);
     402    if (len < 0 || !got_frame)
     403        return -1;
     404    else
     405        return 0;
     406}
     407
     408static int hevc_decode_frame_internal(BPGDecoderContext *s,
     409                                      DynBuf *abuf, DynBuf *cbuf,
     410                                      const uint8_t *buf, int buf_len1,
     411                                      int first_nal)
     412{
     413    int nal_len, start, nal_buf_len, ret, nuh_layer_id, buf_len, has_alpha;
     414    int nut, frame_start_found[2];
     415    DynBuf *pbuf;
     416    uint8_t *nal_buf;
     417
     418    has_alpha = (s->alpha_dec_ctx != NULL);
     419    buf_len = buf_len1;
     420    frame_start_found[0] = 0;
     421    frame_start_found[1] = 0;
     422    while (buf_len > 0) {
     423        if (buf_len < (first_nal ? 3 : 0) + 2)
     424            goto fail;
     425        if (first_nal)
     426            start = 0;
     427        else
     428            start = 3 + (buf[2] == 0);
     429        if (buf_len < start + 3)
     430            goto fail;
     431        nuh_layer_id = ((buf[start] & 1) << 5) | (buf[start + 1] >> 3);
     432        nut = (buf[start] >> 1) & 0x3f;
     433#if 0
     434        printf("nal: type=%d layer_id=%d fs=%d %d\n",
     435               nut, nuh_layer_id, frame_start_found[0], frame_start_found[1]);
     436#endif
     437        /* Note: we assume the alpha and color data are correctly
     438           interleaved */
     439        if ((nut >= 32 && nut <= 35) || nut == 39 || nut >= 41) {
     440            if (frame_start_found[0] && frame_start_found[has_alpha])
     441                break;
     442        } else if ((nut <= 9 || (nut >= 16 && nut <= 21)) && 
     443                   start + 2 < buf_len && (buf[start + 2] & 0x80)) {
     444            /* first slice segment */
     445            if (frame_start_found[0] && frame_start_found[has_alpha])
     446                break;
     447            if (has_alpha && nuh_layer_id == 1)
     448                frame_start_found[1] = 1;
     449            else
     450                frame_start_found[0] = 1;
     451        }
     452       
     453        nal_len = find_nal_end(buf, buf_len, !first_nal);
     454        if (nal_len < 0)
     455            goto fail;
     456        nal_buf_len = nal_len - start + 3;
     457        if (has_alpha && nuh_layer_id == 1)
     458            pbuf = abuf;
     459        else
     460            pbuf = cbuf;
     461        if (dyn_buf_resize(pbuf, pbuf->len + nal_buf_len) < 0)
     462            goto fail;
     463        nal_buf = pbuf->buf + pbuf->len;
     464        nal_buf[0] = 0x00;
     465        nal_buf[1] = 0x00;
     466        nal_buf[2] = 0x01;
     467        memcpy(nal_buf + 3, buf + start, nal_len - start);
     468        if (has_alpha && nuh_layer_id == 1)
     469            nal_buf[4] &= 0x7;
     470        pbuf->len += nal_buf_len;
     471        buf += nal_len;
     472        buf_len -= nal_len;
     473        first_nal = 0;
     474    }
     475   
     476    if (s->alpha_dec_ctx) {
     477        if (dyn_buf_resize(abuf, abuf->len + FF_INPUT_BUFFER_PADDING_SIZE) < 0)
     478            goto fail;
     479        ret = hevc_write_frame(s->alpha_dec_ctx, s->alpha_frame, abuf->buf, abuf->len);
     480        if (ret < 0)
     481            goto fail;
     482    }
     483
     484    if (dyn_buf_resize(cbuf, cbuf->len + FF_INPUT_BUFFER_PADDING_SIZE) < 0)
     485        goto fail;
     486    ret = hevc_write_frame(s->dec_ctx, s->frame, cbuf->buf, cbuf->len);
     487    if (ret < 0)
     488        goto fail;
     489    ret = buf_len1 - buf_len;
     490 done:
     491    return ret;
     492 fail:
     493    ret = -1;
     494    goto done;
     495}
     496
     497/* decode the first frame */
     498static int hevc_decode_start(BPGDecoderContext *s,
     499                             const uint8_t *buf, int buf_len1,
     500                             int width, int height, int chroma_format_idc,
     501                             int bit_depth, int has_alpha)
     502{
     503    int ret, buf_len;
     504    DynBuf abuf_s, *abuf = &abuf_s;
     505    DynBuf cbuf_s, *cbuf = &cbuf_s;
     506
     507    dyn_buf_init(abuf);
     508    dyn_buf_init(cbuf);
     509
     510    buf_len = buf_len1;
     511    if (has_alpha) {
     512        ret = hevc_decode_init1(abuf, &s->alpha_frame, &s->alpha_dec_ctx,
     513                                buf, buf_len, width, height, 0, bit_depth);
     514        if (ret < 0)
     515            goto fail;
     516        buf += ret;
     517        buf_len -= ret;
     518    }
     519   
     520    ret = hevc_decode_init1(cbuf, &s->frame, &s->dec_ctx,
     521                            buf, buf_len, width, height, chroma_format_idc,
     522                            bit_depth);
     523    if (ret < 0)
     524        goto fail;
     525    buf += ret;
     526    buf_len -= ret;
     527   
     528    ret = hevc_decode_frame_internal(s, abuf, cbuf, buf, buf_len, 1);
     529    av_free(abuf->buf);
     530    av_free(cbuf->buf);
     531    if (ret < 0)
     532        goto fail;
     533    buf_len -= ret;
     534    return buf_len1 - buf_len;
     535 fail:
     536    return -1;
     537}
     538
     539#ifdef USE_PRED
     540static int hevc_decode_frame(BPGDecoderContext *s,
     541                             const uint8_t *buf, int buf_len)
     542{
     543    int ret;
     544    DynBuf abuf_s, *abuf = &abuf_s;
     545    DynBuf cbuf_s, *cbuf = &cbuf_s;
     546
     547    dyn_buf_init(abuf);
     548    dyn_buf_init(cbuf);
     549    ret = hevc_decode_frame_internal(s, abuf, cbuf, buf, buf_len, 0);
     550    av_free(abuf->buf);
     551    av_free(cbuf->buf);
     552    return ret;
     553}
     554#endif
     555
     556static void hevc_decode_end(BPGDecoderContext *s)
     557{
     558    if (s->alpha_dec_ctx) {
     559        avcodec_close(s->alpha_dec_ctx);
     560        av_free(s->alpha_dec_ctx);
     561        s->alpha_dec_ctx = NULL;
     562    }
     563    if (s->dec_ctx) {
     564        avcodec_close(s->dec_ctx);
     565        av_free(s->dec_ctx);
     566        s->dec_ctx = NULL;
     567    }
     568}
     569
     570uint8_t *bpg_decoder_get_data(BPGDecoderContext *img, int *pline_size, int plane)
     571{
     572    int c_count;
     573    if (img->format == BPG_FORMAT_GRAY)
     574        c_count = 1;
     575    else
     576        c_count = 3;
     577    if (plane < c_count) {
     578        *pline_size = img->frame->linesize[plane];
     579        return img->frame->data[plane];
     580    } else if (img->has_alpha && plane == c_count) {
     581        *pline_size = img->alpha_frame->linesize[0];
     582        return img->alpha_frame->data[0];
     583    } else {
     584        *pline_size = 0;
     585        return NULL;
     586    }
     587}
     588
     589int bpg_decoder_get_info(BPGDecoderContext *img, BPGImageInfo *p)
     590{
     591    if (!img->frame)
     592        return -1;
     593    p->width = img->w;
     594    p->height = img->h;
     595    p->format = img->format;
     596    p->has_alpha = img->has_alpha && !img->has_w_plane;
     597    p->premultiplied_alpha = img->premultiplied_alpha;
     598    p->has_w_plane = img->has_w_plane;
     599    p->limited_range = img->limited_range;
     600    p->color_space = img->color_space;
     601    p->bit_depth = img->bit_depth;
     602    p->has_animation = img->has_animation;
     603    p->loop_count = img->loop_count;
     604    return 0;
     605}
     606
     607static inline int clamp_pix(int a, int pixel_max)
     608{
     609    if (a < 0)
     610        return 0;
     611    else if (a > pixel_max)
     612        return pixel_max;
     613    else
     614        return a;
     615}
     616
     617static inline int clamp8(int a)
     618{
     619    if (a < 0)
     620        return 0;
     621    else if (a > 255)
     622        return 255;
     623    else
     624        return a;
     625}
     626
     627/* 8 tap Lanczos interpolator (phase=0, symmetric) */
     628#define IP0C0 40
     629#define IP0C1 (-11)
     630#define IP0C2 4
     631#define IP0C3 (-1)
     632
     633/* 7 tap Lanczos interpolator (phase=0.5) */
     634#define IP1C0 (-1)
     635#define IP1C1 4
     636#define IP1C2 (-10)
     637#define IP1C3 57
     638#define IP1C4 18
     639#define IP1C5 (-6)
     640#define IP1C6 2
     641
     642/* interpolate by a factor of two assuming chroma is aligned with the
     643   luma samples. */
     644static void interp2p0_simple(PIXEL *dst, const PIXEL *src, int n, int bit_depth)
     645{
     646    int pixel_max;
     647
     648    pixel_max = (1 << bit_depth) - 1;
     649    while (n >= 2) {
     650        dst[0] = src[0];
     651        dst[1] = clamp_pix(((src[-3] + src[4]) * IP0C3 +
     652                            (src[-2] + src[3]) * IP0C2 +
     653                            (src[-1] + src[2]) * IP0C1 +
     654                            (src[0] + src[1]) * IP0C0 + 32) >> 6, pixel_max);
     655        dst += 2;
     656        src++;
     657        n -= 2;
     658    }
     659    if (n) {
     660        dst[0] = src[0];
     661    }
     662}
     663
     664static void interp2p0_simple16(PIXEL *dst, const int16_t *src, int n, int bit_depth)
     665{
     666    int shift1, offset1, shift0, offset0, pixel_max;
     667
     668    pixel_max = (1 << bit_depth) - 1;
     669    shift0 = 14 - bit_depth;
     670    offset0 = (1 << shift0) >> 1;
     671    shift1 = 20 - bit_depth;
     672    offset1 = 1 << (shift1 - 1);
     673
     674    while (n >= 2) {
     675        dst[0] = clamp_pix((src[0] + offset0) >> shift0, pixel_max);
     676        dst[1] = clamp_pix(((src[-3] + src[4]) * IP0C3 +
     677                            (src[-2] + src[3]) * IP0C2 +
     678                            (src[-1] + src[2]) * IP0C1 +
     679                            (src[0] + src[1]) * IP0C0 + offset1) >> shift1,
     680                           pixel_max);
     681        dst += 2;
     682        src++;
     683        n -= 2;
     684    }
     685    if (n) {
     686        dst[0] = clamp_pix((src[0] + offset0) >> shift0, pixel_max);
     687    }
     688}
     689
     690/* interpolate by a factor of two assuming chroma is between the luma
     691   samples. */
     692static void interp2p1_simple(PIXEL *dst, const PIXEL *src, int n, int bit_depth)
     693{
     694    int pixel_max, a0, a1, a2, a3, a4, a5, a6;
     695
     696    pixel_max = (1 << bit_depth) - 1;
     697
     698    a1 = src[-3];
     699    a2 = src[-2];
     700    a3 = src[-1];
     701    a4 = src[0];
     702    a5 = src[1];
     703    a6 = src[2];
     704
     705    while (n >= 2) {
     706        a0 = a1;
     707        a1 = a2;
     708        a2 = a3;
     709        a3 = a4;
     710        a4 = a5;
     711        a5 = a6;
     712        a6 = src[3];
     713        dst[0] = clamp_pix((a0 * IP1C6 + a1 * IP1C5 + a2 * IP1C4 + a3 * IP1C3 +
     714                            a4 * IP1C2 + a5 * IP1C1 + a6 * IP1C0 + 32) >> 6,
     715                           pixel_max);
     716        dst[1] = clamp_pix((a0 * IP1C0 + a1 * IP1C1 + a2 * IP1C2 + a3 * IP1C3 +
     717                            a4 * IP1C4 + a5 * IP1C5 + a6 * IP1C6 + 32) >> 6,
     718                           pixel_max);
     719        dst += 2;
     720        src++;
     721        n -= 2;
     722    }
     723    if (n) {
     724        a0 = a1;
     725        a1 = a2;
     726        a2 = a3;
     727        a3 = a4;
     728        a4 = a5;
     729        a5 = a6;
     730        a6 = src[3];
     731        dst[0] = clamp_pix((a0 * IP1C6 + a1 * IP1C5 + a2 * IP1C4 + a3 * IP1C3 +
     732                            a4 * IP1C2 + a5 * IP1C1 + a6 * IP1C0 + 32) >> 6,
     733                           pixel_max);
     734    }
     735}
     736
     737static void interp2p1_simple16(PIXEL *dst, const int16_t *src, int n,
     738                               int bit_depth)
     739{
     740    int shift, offset, pixel_max, a0, a1, a2, a3, a4, a5, a6;
     741
     742    pixel_max = (1 << bit_depth) - 1;
     743    shift = 20 - bit_depth;
     744    offset = 1 << (shift - 1);
     745
     746    a1 = src[-3];
     747    a2 = src[-2];
     748    a3 = src[-1];
     749    a4 = src[0];
     750    a5 = src[1];
     751    a6 = src[2];
     752
     753    while (n >= 2) {
     754        a0 = a1;
     755        a1 = a2;
     756        a2 = a3;
     757        a3 = a4;
     758        a4 = a5;
     759        a5 = a6;
     760        a6 = src[3];
     761        dst[0] = clamp_pix((a0 * IP1C6 + a1 * IP1C5 + a2 * IP1C4 + a3 * IP1C3 +
     762                            a4 * IP1C2 + a5 * IP1C1 + a6 * IP1C0 + offset) >> shift,
     763                           pixel_max);
     764        dst[1] = clamp_pix((a0 * IP1C0 + a1 * IP1C1 + a2 * IP1C2 + a3 * IP1C3 +
     765                            a4 * IP1C4 + a5 * IP1C5 + a6 * IP1C6 + offset) >> shift,
     766                           pixel_max);
     767        dst += 2;
     768        src++;
     769        n -= 2;
     770    }
     771    if (n) {
     772        a0 = a1;
     773        a1 = a2;
     774        a2 = a3;
     775        a3 = a4;
     776        a4 = a5;
     777        a5 = a6;
     778        a6 = src[3];
     779        dst[0] = clamp_pix((a0 * IP1C6 + a1 * IP1C5 + a2 * IP1C4 + a3 * IP1C3 +
     780                            a4 * IP1C2 + a5 * IP1C1 + a6 * IP1C0 + offset) >> shift,
     781                           pixel_max);
     782    }
     783}
     784
     785/* tmp_buf is a temporary buffer of length (n2 + 2 * ITAPS2 - 1) */
     786static void interp2_h(PIXEL *dst, const PIXEL *src, int n, int bit_depth,
     787                      int phase, PIXEL *tmp_buf)
     788{
     789    PIXEL *src1 = tmp_buf, v;
     790    int i, n2;
     791
     792    /* add extra pixels and do the interpolation (XXX: could go faster) */
     793    n2 = (n + 1) / 2;
     794    memcpy(src1 + ITAPS2 - 1, src, n2 * sizeof(PIXEL));
     795
     796    v = src[0];
     797    for(i = 0; i < ITAPS2 - 1; i++)
     798        src1[i] = v;
     799
     800    v = src[n2 - 1];
     801    for(i = 0; i < ITAPS2; i++)
     802        src1[ITAPS2 - 1 + n2 + i] = v;
     803    if (phase == 0)
     804        interp2p0_simple(dst, src1 + ITAPS2 - 1, n, bit_depth);
     805    else
     806        interp2p1_simple(dst, src1 + ITAPS2 - 1, n, bit_depth);
     807}
     808
     809/* y_pos is the position of the sample '0' in the 'src' circular
     810   buffer. tmp_buf is a temporary buffer of length (n2 + 2 * ITAPS2 - 1) */
     811static void interp2_vh(PIXEL *dst, PIXEL **src, int n, int y_pos,
     812                       int16_t *tmp_buf, int bit_depth, int frac_pos,
     813                       int c_h_phase)
     814{
     815    const PIXEL *src0, *src1, *src2, *src3, *src4, *src5, *src6;
     816    int i, n2, shift, rnd;
     817    int16_t v;
     818
     819    src0 = src[(y_pos - 3) & 7];
     820    src1 = src[(y_pos - 2) & 7];
     821    src2 = src[(y_pos - 1) & 7];
     822    src3 = src[(y_pos + 0) & 7];
     823    src4 = src[(y_pos + 1) & 7];
     824    src5 = src[(y_pos + 2) & 7];
     825    src6 = src[(y_pos + 3) & 7];
     826
     827    /* vertical interpolation first */
     828    shift = bit_depth - 8;
     829    rnd = (1 << shift) >> 1;
     830    n2 = (n + 1) / 2;
     831    if (frac_pos == 0) {
     832        for(i = 0; i < n2; i++) {
     833            tmp_buf[ITAPS2 - 1 + i] =
     834                (src0[i] * IP1C6 + src1[i] * IP1C5 +
     835                 src2[i] * IP1C4 + src3[i] * IP1C3 +
     836                 src4[i] * IP1C2 + src5[i] * IP1C1 +
     837                 src6[i] * IP1C0 + rnd) >> shift;
     838        }
     839    } else {
     840        for(i = 0; i < n2; i++) {
     841            tmp_buf[ITAPS2 - 1 + i] =
     842                (src0[i] * IP1C0 + src1[i] * IP1C1 +
     843                 src2[i] * IP1C2 + src3[i] * IP1C3 +
     844                 src4[i] * IP1C4 + src5[i] * IP1C5 +
     845                 src6[i] * IP1C6 + rnd) >> shift;
     846        }
     847    }
     848
     849    /* then horizontal interpolation */
     850    v = tmp_buf[ITAPS2 - 1];
     851    for(i = 0; i < ITAPS2 - 1; i++)
     852        tmp_buf[i] = v;
     853    v = tmp_buf[ITAPS2 - 1 + n2 - 1];
     854    for(i = 0; i < ITAPS2; i++)
     855        tmp_buf[ITAPS2 - 1 + n2 + i] = v;
     856    if (c_h_phase == 0)
     857        interp2p0_simple16(dst, tmp_buf + ITAPS2 - 1, n, bit_depth);
     858    else
     859        interp2p1_simple16(dst, tmp_buf + ITAPS2 - 1, n, bit_depth);
     860}
     861
     862static void ycc_to_rgb24(ColorConvertState *s, uint8_t *dst, const PIXEL *y_ptr,
     863                         const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     864                         int n, int incr)
     865{
     866    uint8_t *q = dst;
     867    int y_val, cb_val, cr_val, x;
     868    int c_r_cr, c_g_cb, c_g_cr, c_b_cb, rnd, shift, center, c_one;
     869
     870    c_r_cr = s->c_r_cr;
     871    c_g_cb = s->c_g_cb;
     872    c_g_cr = s->c_g_cr;
     873    c_b_cb = s->c_b_cb;
     874    c_one = s->y_one;
     875    rnd = s->y_offset;
     876    shift = s->c_shift;
     877    center = s->c_center;
     878    for(x = 0; x < n; x++) {
     879        y_val = y_ptr[x] * c_one;
     880        cb_val = cb_ptr[x] - center;
     881        cr_val = cr_ptr[x] - center;
     882        q[0] = clamp8((y_val + c_r_cr * cr_val + rnd) >> shift);
     883        q[1] = clamp8((y_val - c_g_cb * cb_val - c_g_cr * cr_val + rnd) >> shift);
     884        q[2] = clamp8((y_val + c_b_cb * cb_val + rnd) >> shift);
     885        q += incr;
     886    }
     887}
     888
     889static void ycgco_to_rgb24(ColorConvertState *s,
     890                           uint8_t *dst, const PIXEL *y_ptr,
     891                           const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     892                           int n, int incr)
     893{
     894    uint8_t *q = dst;
     895    int y_val, cb_val, cr_val, x;
     896    int rnd, shift, center, c_one;
     897
     898    c_one = s->y_one;
     899    rnd = s->y_offset;
     900    shift = s->c_shift;
     901    center = s->c_center;
     902    for(x = 0; x < n; x++) {
     903        y_val = y_ptr[x];
     904        cb_val = cb_ptr[x] - center;
     905        cr_val = cr_ptr[x] - center;
     906        q[0] = clamp8(((y_val - cb_val + cr_val) * c_one + rnd) >> shift);
     907        q[1] = clamp8(((y_val + cb_val) * c_one + rnd) >> shift);
     908        q[2] = clamp8(((y_val - cb_val - cr_val) * c_one + rnd) >> shift);
     909        q += incr;
     910    }
     911}
     912
     913/* c = c * alpha */
     914static void alpha_combine8(ColorConvertState *s,
     915                           uint8_t *dst, const PIXEL *a_ptr, int n, int incr)
     916{
     917    uint8_t *q = dst;
     918    int x, a_val, shift, rnd;
     919
     920    shift = s->bit_depth;
     921    rnd = 1 << (shift - 1);
     922    for(x = 0; x < n; x++) {
     923        a_val = a_ptr[x];
     924        /* XXX: not accurate enough */
     925        q[0] = (q[0] * a_val + rnd) >> shift;
     926        q[1] = (q[1] * a_val + rnd) >> shift;
     927        q[2] = (q[2] * a_val + rnd) >> shift;
     928        q += incr;
     929    }
     930}
     931
     932static uint32_t divide8_table[256];
     933
     934#define DIV8_BITS 16
     935
     936static void alpha_divide8_init(void)
     937{
     938    int i;
     939    for(i = 1; i < 256; i++) {
     940        /* Note: the 128 is added to have 100% correct results for all
     941           the values */
     942        divide8_table[i] = ((255 << DIV8_BITS) + (i / 2) + 128) / i;
     943    }
     944}
     945
     946static inline unsigned int comp_divide8(unsigned int val, unsigned int alpha,
     947                                        unsigned int alpha_inv)
     948{
     949    if (val >= alpha)
     950        return 255;
     951    return (val * alpha_inv + (1 << (DIV8_BITS - 1))) >> DIV8_BITS;
     952}
     953
     954/* c = c / alpha */
     955static void alpha_divide8(uint8_t *dst, int n)
     956{
     957    static int inited;
     958    uint8_t *q = dst;
     959    int x;
     960    unsigned int a_val, a_inv;
     961
     962    if (!inited) {
     963        inited = 1;
     964        alpha_divide8_init();
     965    }
     966
     967    for(x = 0; x < n; x++) {
     968        a_val = q[3];
     969        if (a_val == 0) {
     970            q[0] = 255;
     971            q[1] = 255;
     972            q[2] = 255;
     973        } else {
     974            a_inv = divide8_table[a_val];
     975            q[0] = comp_divide8(q[0], a_val, a_inv);
     976            q[1] = comp_divide8(q[1], a_val, a_inv);
     977            q[2] = comp_divide8(q[2], a_val, a_inv);
     978        }
     979        q += 4;
     980    }
     981}
     982
     983static void gray_to_rgb24(ColorConvertState *s,
     984                          uint8_t *dst, const PIXEL *y_ptr,
     985                          const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     986                          int n, int incr)
     987{
     988    uint8_t *q = dst;
     989    int x, y_val, c, rnd, shift;
     990
     991    if (s->bit_depth == 8 && !s->limited_range) {
     992        for(x = 0; x < n; x++) {
     993            y_val = y_ptr[x];
     994            q[0] = y_val;
     995            q[1] = y_val;
     996            q[2] = y_val;
     997            q += incr;
     998        }
     999    } else {
     1000        c = s->y_one;
     1001        rnd = s->y_offset;
     1002        shift = s->c_shift;
     1003        for(x = 0; x < n; x++) {
     1004            y_val = clamp8((y_ptr[x] * c + rnd) >> shift);
     1005            q[0] = y_val;
     1006            q[1] = y_val;
     1007            q[2] = y_val;
     1008            q += incr;
     1009        }
     1010    }
     1011}
     1012
     1013static void rgb_to_rgb24(ColorConvertState *s, uint8_t *dst, const PIXEL *y_ptr,
     1014                         const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     1015                         int n, int incr)
     1016{
     1017    uint8_t *q = dst;
     1018    int x, c, rnd, shift;
     1019
     1020    if (s->bit_depth == 8 && !s->limited_range) {
     1021        for(x = 0; x < n; x++) {
     1022            q[0] = cr_ptr[x];
     1023            q[1] = y_ptr[x];
     1024            q[2] = cb_ptr[x];
     1025            q += incr;
     1026        }
     1027    } else {
     1028        c = s->y_one;
     1029        rnd = s->y_offset;
     1030        shift = s->c_shift;
     1031        for(x = 0; x < n; x++) {
     1032            q[0] = clamp8((cr_ptr[x] * c + rnd) >> shift);
     1033            q[1] = clamp8((y_ptr[x] * c + rnd) >> shift);
     1034            q[2] = clamp8((cb_ptr[x] * c + rnd) >> shift);
     1035            q += incr;
     1036        }
     1037    }
     1038}
     1039
     1040static void put_dummy_gray8(uint8_t *dst, int n, int incr)
     1041{
     1042    int x;
     1043    for(x = 0; x < n; x++) {
     1044        dst[0] = 0xff;
     1045        dst += incr;
     1046    }
     1047}
     1048
     1049static void gray_to_gray8(ColorConvertState *s,
     1050                          uint8_t *dst, const PIXEL *y_ptr,
     1051                          int n, int incr)
     1052{
     1053    uint8_t *q = dst;
     1054    int x, y_val, c, rnd, shift;
     1055
     1056    if (s->bit_depth == 8) {
     1057        for(x = 0; x < n; x++) {
     1058            y_val = y_ptr[x];
     1059            q[0] = y_val;
     1060            q += incr;
     1061        }
     1062    } else {
     1063        c = s->c_one;
     1064        rnd = s->c_rnd;
     1065        shift = s->c_shift;
     1066        for(x = 0; x < n; x++) {
     1067            y_val = (y_ptr[x] * c + rnd) >> shift;
     1068            q[0] = y_val;
     1069            q += incr;
     1070        }
     1071    }
     1072}
     1073
     1074static ColorConvertFunc *cs_to_rgb24[BPG_CS_COUNT] = {
     1075    ycc_to_rgb24,
     1076    rgb_to_rgb24,
     1077    ycgco_to_rgb24,
     1078    ycc_to_rgb24,
     1079    ycc_to_rgb24,
     1080};
     1081
     1082#ifdef USE_RGB48
     1083
     1084/* 16 bit output */
     1085
     1086static inline int clamp16(int a)
     1087{
     1088    if (a < 0)
     1089        return 0;
     1090    else if (a > 65535)
     1091        return 65535;
     1092    else
     1093        return a;
     1094}
     1095
     1096static void ycc_to_rgb48(ColorConvertState *s, uint8_t *dst, const PIXEL *y_ptr,
     1097                         const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     1098                         int n, int incr)
     1099{
     1100    uint16_t *q = (uint16_t *)dst;
     1101    int y_val, cb_val, cr_val, x;
     1102    int c_r_cr, c_g_cb, c_g_cr, c_b_cb, rnd, shift, center, c_one;
     1103
     1104    c_r_cr = s->c_r_cr;
     1105    c_g_cb = s->c_g_cb;
     1106    c_g_cr = s->c_g_cr;
     1107    c_b_cb = s->c_b_cb;
     1108    c_one = s->y_one;
     1109    rnd = s->y_offset;
     1110    shift = s->c_shift;
     1111    center = s->c_center;
     1112    for(x = 0; x < n; x++) {
     1113        y_val = y_ptr[x] * c_one;
     1114        cb_val = cb_ptr[x] - center;
     1115        cr_val = cr_ptr[x] - center;
     1116        q[0] = clamp16((y_val + c_r_cr * cr_val + rnd) >> shift);
     1117        q[1] = clamp16((y_val - c_g_cb * cb_val - c_g_cr * cr_val + rnd) >> shift);
     1118        q[2] = clamp16((y_val + c_b_cb * cb_val + rnd) >> shift);
     1119        q += incr;
     1120    }
     1121}
     1122
     1123static void ycgco_to_rgb48(ColorConvertState *s,
     1124                           uint8_t *dst, const PIXEL *y_ptr,
     1125                           const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     1126                           int n, int incr)
     1127{
     1128    uint16_t *q = (uint16_t *)dst;
     1129    int y_val, cb_val, cr_val, x;
     1130    int rnd, shift, center, c_one;
     1131
     1132    c_one = s->y_one;
     1133    rnd = s->y_offset;
     1134    shift = s->c_shift;
     1135    center = s->c_center;
     1136    for(x = 0; x < n; x++) {
     1137        y_val = y_ptr[x];
     1138        cb_val = cb_ptr[x] - center;
     1139        cr_val = cr_ptr[x] - center;
     1140        q[0] = clamp16(((y_val - cb_val + cr_val) * c_one + rnd) >> shift);
     1141        q[1] = clamp16(((y_val + cb_val) * c_one + rnd) >> shift);
     1142        q[2] = clamp16(((y_val - cb_val - cr_val) * c_one + rnd) >> shift);
     1143        q += incr;
     1144    }
     1145}
     1146
     1147static void gray_to_rgb48(ColorConvertState *s,
     1148                          uint8_t *dst, const PIXEL *y_ptr,
     1149                          const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     1150                          int n, int incr)
     1151{
     1152    uint16_t *q = (uint16_t *)dst;
     1153    int x, y_val, c, rnd, shift;
     1154
     1155    c = s->y_one;
     1156    rnd = s->y_offset;
     1157    shift = s->c_shift;
     1158    for(x = 0; x < n; x++) {
     1159        y_val = clamp16((y_ptr[x] * c + rnd) >> shift);
     1160        q[0] = y_val;
     1161        q[1] = y_val;
     1162        q[2] = y_val;
     1163        q += incr;
     1164    }
     1165}
     1166
     1167static void gray_to_gray16(ColorConvertState *s,
     1168                           uint16_t *dst, const PIXEL *y_ptr,
     1169                           int n, int incr)
     1170{
     1171    uint16_t *q = dst;
     1172    int x, y_val, c, rnd, shift;
     1173
     1174    c = s->c_one;
     1175    rnd = s->c_rnd;
     1176    shift = s->c_shift;
     1177    for(x = 0; x < n; x++) {
     1178        y_val = (y_ptr[x] * c + rnd) >> shift;
     1179        q[0] = y_val;
     1180        q += incr;
     1181    }
     1182}
     1183
     1184static void luma_to_gray16(ColorConvertState *s,
     1185                           uint16_t *dst, const PIXEL *y_ptr,
     1186                           int n, int incr)
     1187{
     1188    uint16_t *q = dst;
     1189    int x, y_val, c, rnd, shift;
     1190
     1191    c = s->y_one;
     1192    rnd = s->y_offset;
     1193    shift = s->c_shift;
     1194    for(x = 0; x < n; x++) {
     1195        y_val = clamp16((y_ptr[x] * c + rnd) >> shift);
     1196        q[0] = y_val;
     1197        q += incr;
     1198    }
     1199}
     1200
     1201static void rgb_to_rgb48(ColorConvertState *s,
     1202                         uint8_t *dst, const PIXEL *y_ptr,
     1203                         const PIXEL *cb_ptr, const PIXEL *cr_ptr,
     1204                         int n, int incr)
     1205{
     1206    luma_to_gray16(s, (uint16_t *)dst + 1, y_ptr, n, incr);
     1207    luma_to_gray16(s, (uint16_t *)dst + 2, cb_ptr, n, incr);
     1208    luma_to_gray16(s, (uint16_t *)dst + 0, cr_ptr, n, incr);
     1209}
     1210
     1211static void put_dummy_gray16(uint16_t *dst, int n, int incr)
     1212{
     1213    int x;
     1214    for(x = 0; x < n; x++) {
     1215        dst[0] = 0xffff;
     1216        dst += incr;
     1217    }
     1218}
     1219
     1220/* c = c * alpha */
     1221static void alpha_combine16(ColorConvertState *s,
     1222                            uint16_t *dst, const PIXEL *a_ptr, int n, int incr)
     1223{
     1224    uint16_t *q = dst;
     1225    int x, a_val, shift, rnd;
     1226
     1227    shift = s->bit_depth;
     1228    rnd = 1 << (shift - 1);
     1229    for(x = 0; x < n; x++) {
     1230        a_val = a_ptr[x];
     1231        /* XXX: not accurate enough */
     1232        q[0] = (q[0] * a_val + rnd) >> shift;
     1233        q[1] = (q[1] * a_val + rnd) >> shift;
     1234        q[2] = (q[2] * a_val + rnd) >> shift;
     1235        q += incr;
     1236    }
     1237}
     1238
     1239#define DIV16_BITS 15
     1240
     1241static unsigned int comp_divide16(unsigned int val, unsigned int alpha,
     1242                                  unsigned int alpha_inv)
     1243{
     1244    if (val >= alpha)
     1245        return 65535;
     1246    return (val * alpha_inv + (1 << (DIV16_BITS - 1))) >> DIV16_BITS;
     1247}
     1248
     1249/* c = c / alpha */
     1250static void alpha_divide16(uint16_t *dst, int n)
     1251{
     1252    uint16_t *q = dst;
     1253    int x;
     1254    unsigned int a_val, a_inv;
     1255
     1256    for(x = 0; x < n; x++) {
     1257        a_val = q[3];
     1258        if (a_val == 0) {
     1259            q[0] = 65535;
     1260            q[1] = 65535;
     1261            q[2] = 65535;
     1262        } else {
     1263            a_inv = ((65535 << DIV16_BITS) + (a_val / 2)) / a_val;
     1264            q[0] = comp_divide16(q[0], a_val, a_inv);
     1265            q[1] = comp_divide16(q[1], a_val, a_inv);
     1266            q[2] = comp_divide16(q[2], a_val, a_inv);
     1267        }
     1268        q += 4;
     1269    }
     1270}
     1271
     1272static void gray_one_minus8(uint8_t *dst, int n, int incr)
     1273{
     1274    int x;
     1275    for(x = 0; x < n; x++) {
     1276        dst[0] = 255 - dst[0];
     1277        dst += incr;
     1278    }
     1279}
     1280
     1281static void gray_one_minus16(uint16_t *dst, int n, int incr)
     1282{
     1283    int x;
     1284    for(x = 0; x < n; x++) {
     1285        dst[0] = 65535 - dst[0];
     1286        dst += incr;
     1287    }
     1288}
     1289
     1290static ColorConvertFunc *cs_to_rgb48[BPG_CS_COUNT] = {
     1291    ycc_to_rgb48,
     1292    rgb_to_rgb48,
     1293    ycgco_to_rgb48,
     1294    ycc_to_rgb48,
     1295    ycc_to_rgb48,
     1296};
     1297#endif
     1298
     1299static void convert_init(ColorConvertState *s,
     1300                         int in_bit_depth, int out_bit_depth,
     1301                         BPGColorSpaceEnum color_space,
     1302                         int limited_range)
     1303{
     1304    int c_shift, in_pixel_max, out_pixel_max;
     1305    double mult, k_r, k_b, mult_y, mult_c;
     1306
     1307    c_shift = 30 - out_bit_depth;
     1308    in_pixel_max = (1 << in_bit_depth) - 1;
     1309    out_pixel_max = (1 << out_bit_depth) - 1;
     1310    mult = (double)out_pixel_max * (1 << c_shift) / (double)in_pixel_max;
     1311    if (limited_range) {
     1312        mult_y = (double)out_pixel_max * (1 << c_shift) /
     1313            (double)(219 << (in_bit_depth - 8));
     1314        mult_c = (double)out_pixel_max * (1 << c_shift) /
     1315            (double)(224 << (in_bit_depth - 8));
     1316    } else {
     1317        mult_y = mult;
     1318        mult_c = mult;
     1319    }
     1320    switch(color_space) {
     1321    case BPG_CS_YCbCr:
     1322        k_r = 0.299;
     1323        k_b = 0.114;
     1324        goto convert_ycc;
     1325    case BPG_CS_YCbCr_BT709:
     1326        k_r = 0.2126;
     1327        k_b = 0.0722;
     1328        goto convert_ycc;
     1329    case BPG_CS_YCbCr_BT2020:
     1330        k_r = 0.2627;
     1331        k_b = 0.0593;
     1332    convert_ycc:
     1333        s->c_r_cr = lrint(2*(1-k_r) * mult_c);
     1334        s->c_g_cb = lrint(2*k_b*(1-k_b)/(1-k_b-k_r) * mult_c);
     1335        s->c_g_cr = lrint(2*k_r*(1-k_r)/(1-k_b-k_r) * mult_c);
     1336        s->c_b_cb = lrint(2*(1-k_b) * mult_c);
     1337        break;
     1338    default:
     1339        break;
     1340    }
     1341    s->c_one = lrint(mult);
     1342    s->c_shift = c_shift;
     1343    s->c_rnd = (1 << (c_shift - 1));
     1344    s->c_center = 1 << (in_bit_depth - 1);
     1345    if (limited_range) {
     1346        s->y_one = lrint(mult_y);
     1347        s->y_offset = -(16 << (in_bit_depth - 8)) * s->y_one + s->c_rnd;
     1348    } else {
     1349        s->y_one = s->c_one;
     1350        s->y_offset = s->c_rnd;
     1351    }
     1352    s->bit_depth = in_bit_depth;
     1353    s->limited_range = limited_range;
     1354}
     1355
     1356static int bpg_decoder_output_init(BPGDecoderContext *s,
     1357                                   BPGDecoderOutputFormat out_fmt)
     1358{
     1359    int i;
     1360
     1361#ifdef USE_RGB48
     1362    if ((unsigned)out_fmt > BPG_OUTPUT_FORMAT_CMYK64)
     1363        return -1;
     1364#else
     1365    if ((unsigned)out_fmt > BPG_OUTPUT_FORMAT_RGBA32)
     1366        return -1;
     1367#endif
     1368    s->is_rgba = (out_fmt == BPG_OUTPUT_FORMAT_RGBA32 ||
     1369                    out_fmt == BPG_OUTPUT_FORMAT_RGBA64);
     1370    s->is_16bpp = (out_fmt == BPG_OUTPUT_FORMAT_RGB48 ||
     1371                   out_fmt == BPG_OUTPUT_FORMAT_RGBA64 ||
     1372                   out_fmt == BPG_OUTPUT_FORMAT_CMYK64);
     1373    s->is_cmyk = (out_fmt == BPG_OUTPUT_FORMAT_CMYK32 ||
     1374                  out_fmt == BPG_OUTPUT_FORMAT_CMYK64);
     1375   
     1376    if (s->format == BPG_FORMAT_420 || s->format == BPG_FORMAT_422) {
     1377        s->w2 = (s->w + 1) / 2;
     1378        s->h2 = (s->h + 1) / 2;
     1379        s->cb_buf2 = av_malloc(s->w * sizeof(PIXEL));
     1380        s->cr_buf2 = av_malloc(s->w * sizeof(PIXEL));
     1381        /* Note: too large if 422 and sizeof(PIXEL) = 1 */
     1382        s->c_buf4 = av_malloc((s->w2 + 2 * ITAPS2 - 1) * sizeof(int16_t));
     1383
     1384        if (s->format == BPG_FORMAT_420) {
     1385            for(i = 0; i < ITAPS; i++) {
     1386                s->cb_buf3[i] = av_malloc(s->w2 * sizeof(PIXEL));
     1387                s->cr_buf3[i] = av_malloc(s->w2 * sizeof(PIXEL));
     1388            }
     1389        }
     1390    }
     1391    convert_init(&s->cvt, s->bit_depth, s->is_16bpp ? 16 : 8,
     1392                 s->color_space, s->limited_range);
     1393
     1394    if (s->format == BPG_FORMAT_GRAY) {
     1395#ifdef USE_RGB48
     1396        if (s->is_16bpp) {
     1397            s->cvt_func = gray_to_rgb48;
     1398        } else
     1399#endif
     1400        {
     1401            s->cvt_func = gray_to_rgb24;
     1402        }
     1403    } else {
     1404#ifdef USE_RGB48
     1405        if (s->is_16bpp) {
     1406            s->cvt_func = cs_to_rgb48[s->color_space];
     1407        } else
     1408#endif
     1409        {
     1410            s->cvt_func = cs_to_rgb24[s->color_space];
     1411        }
     1412    }
     1413    return 0;
     1414}
     1415
     1416static void bpg_decoder_output_end(BPGDecoderContext *s)
     1417{
     1418    int i;
     1419
     1420    av_free(s->cb_buf2);
     1421    av_free(s->cr_buf2);
     1422    for(i = 0; i < ITAPS; i++) {
     1423        av_free(s->cb_buf3[i]);
     1424        av_free(s->cr_buf3[i]);
     1425    }
     1426    av_free(s->c_buf4);
     1427}
     1428
     1429int bpg_decoder_start(BPGDecoderContext *s, BPGDecoderOutputFormat out_fmt)
     1430{
     1431    int ret, c_idx;
     1432
     1433    if (!s->frame)
     1434        return -1;
     1435   
     1436    if (!s->output_inited) {
     1437        /* first frame is already decoded */
     1438        ret = bpg_decoder_output_init(s, out_fmt);
     1439        if (ret)
     1440            return ret;
     1441        s->output_inited = 1;
     1442        s->out_fmt = out_fmt;
     1443    } else {
     1444#ifdef USE_PRED
     1445        if (s->has_animation && s->decode_animation) {
     1446            if (out_fmt != s->out_fmt)
     1447                return -1;
     1448            if (s->input_buf_pos >= s->input_buf_len) {
     1449                return -1;
     1450            } else {
     1451                ret = hevc_decode_frame(s, s->input_buf + s->input_buf_pos,
     1452                                        s->input_buf_len - s->input_buf_pos);
     1453                if (ret < 0)
     1454                    return -1;
     1455                s->input_buf_pos += ret;
     1456            }
     1457        } else
     1458#endif
     1459        {
     1460            return -1;
     1461        }
     1462    }
     1463    s->y_buf = bpg_decoder_get_data(s, &s->y_linesize, 0);
     1464    if (s->format != BPG_FORMAT_GRAY) {
     1465        s->cb_buf = bpg_decoder_get_data(s, &s->cb_linesize, 1);
     1466        s->cr_buf = bpg_decoder_get_data(s, &s->cr_linesize, 2);
     1467        c_idx = 3;
     1468    } else {
     1469        c_idx = 1;
     1470    }
     1471    if (s->has_alpha)
     1472        s->a_buf = bpg_decoder_get_data(s, &s->a_linesize, c_idx);
     1473    else
     1474        s->a_buf = NULL;
     1475    s->y = 0;
     1476    return 0;
     1477}
     1478
     1479void bpg_decoder_get_frame_duration(BPGDecoderContext *s, int *pnum, int *pden)
     1480{
     1481#ifdef USE_PRED
     1482    if (s->frame && s->has_animation) {
     1483        *pnum = s->frame_delay_num * (s->frame->pts);
     1484        *pden = s->frame_delay_den;
     1485    } else
     1486#endif
     1487    {
     1488        *pnum = 0;
     1489        *pden = 1;
     1490    }
     1491}
     1492
     1493int bpg_decoder_get_line(BPGDecoderContext *s, void *rgb_line1)
     1494{
     1495    uint8_t *rgb_line = rgb_line1;
     1496    int w, y, pos, y2, y1, incr, y_frac;
     1497    PIXEL *y_ptr, *cb_ptr, *cr_ptr, *a_ptr;
     1498
     1499    y = s->y;
     1500    if ((unsigned)y >= s->h)
     1501        return -1;
     1502    w = s->w;
     1503   
     1504    y_ptr = (PIXEL *)(s->y_buf + y * s->y_linesize);
     1505    incr = 3 + (s->is_rgba || s->is_cmyk);
     1506    switch(s->format) {
     1507    case BPG_FORMAT_GRAY:
     1508        s->cvt_func(&s->cvt, rgb_line, y_ptr, NULL, NULL, w, incr);
     1509        break;
     1510    case BPG_FORMAT_420:
     1511        if (y == 0) {
     1512            int i;
     1513            /* init the vertical interpolation buffer */
     1514            for(i = 0; i < ITAPS; i++) {
     1515                y1 = i;
     1516                if (y1 > ITAPS2)
     1517                    y1 -= ITAPS;
     1518                if (y1 < 0)
     1519                    y1 = 0;
     1520                else if (y1 >= s->h2)
     1521                    y1 = s->h2 - 1;
     1522                cb_ptr = (PIXEL *)(s->cb_buf + y1 * s->cb_linesize);
     1523                cr_ptr = (PIXEL *)(s->cr_buf + y1 * s->cr_linesize);
     1524                memcpy(s->cb_buf3[i], cb_ptr, s->w2 * sizeof(PIXEL));
     1525                memcpy(s->cr_buf3[i], cr_ptr, s->w2 * sizeof(PIXEL));
     1526            }
     1527        }
     1528        y2 = y >> 1;
     1529        pos = y2 % ITAPS;
     1530        y_frac = y & 1;
     1531        interp2_vh(s->cb_buf2, s->cb_buf3, w, pos, s->c_buf4,
     1532                   s->bit_depth, y_frac, s->c_h_phase);
     1533        interp2_vh(s->cr_buf2, s->cr_buf3, w, pos, s->c_buf4,
     1534                   s->bit_depth, y_frac, s->c_h_phase);
     1535        if (y_frac) {
     1536            /* add a new line in the circular buffer */
     1537            pos = (pos + ITAPS2 + 1) % ITAPS;
     1538            y1 = y2 + ITAPS2 + 1;
     1539            if (y1 >= s->h2)
     1540                y1 = s->h2 - 1;
     1541            cb_ptr = (PIXEL *)(s->cb_buf + y1 * s->cb_linesize);
     1542            cr_ptr = (PIXEL *)(s->cr_buf + y1 * s->cr_linesize);
     1543            memcpy(s->cb_buf3[pos], cb_ptr, s->w2 * sizeof(PIXEL));
     1544            memcpy(s->cr_buf3[pos], cr_ptr, s->w2 * sizeof(PIXEL));
     1545        }
     1546        s->cvt_func(&s->cvt, rgb_line, y_ptr, s->cb_buf2, s->cr_buf2, w, incr);
     1547        break;
     1548    case BPG_FORMAT_422:
     1549        cb_ptr = (PIXEL *)(s->cb_buf + y * s->cb_linesize);
     1550        cr_ptr = (PIXEL *)(s->cr_buf + y * s->cr_linesize);
     1551        interp2_h(s->cb_buf2, cb_ptr, w, s->bit_depth, s->c_h_phase,
     1552                  (PIXEL *)s->c_buf4);
     1553        interp2_h(s->cr_buf2, cr_ptr, w, s->bit_depth, s->c_h_phase,
     1554                  (PIXEL *)s->c_buf4);
     1555        s->cvt_func(&s->cvt, rgb_line, y_ptr, s->cb_buf2, s->cr_buf2, w, incr);
     1556        break;
     1557    case BPG_FORMAT_444:
     1558        cb_ptr = (PIXEL *)(s->cb_buf + y * s->cb_linesize);
     1559        cr_ptr = (PIXEL *)(s->cr_buf + y * s->cr_linesize);
     1560        s->cvt_func(&s->cvt, rgb_line, y_ptr, cb_ptr, cr_ptr, w, incr);
     1561        break;
     1562    default:
     1563        return -1;
     1564    }
     1565
     1566    /* alpha output or CMYK handling */
     1567#ifdef USE_RGB48
     1568    if (s->is_cmyk) {
     1569        int i;
     1570        /* convert RGBW to CMYK */
     1571        if (s->is_16bpp) {
     1572            if (!s->has_w_plane)
     1573                put_dummy_gray16((uint16_t *)rgb_line + 3, w, 4);
     1574            for(i = 0; i < 4; i++)
     1575                gray_one_minus16((uint16_t *)rgb_line + i, w, 4);
     1576        } else {
     1577            if (!s->has_w_plane)
     1578                put_dummy_gray8(rgb_line + 3, w, 4);
     1579            for(i = 0; i < 4; i++)
     1580                gray_one_minus8(rgb_line + i, w, 4);
     1581        }
     1582    } else
     1583#endif
     1584    if (s->has_w_plane) {
     1585        a_ptr = (PIXEL *)(s->a_buf + y * s->a_linesize);
     1586#ifdef USE_RGB48
     1587        if (s->is_16bpp) {
     1588            alpha_combine16(&s->cvt, (uint16_t *)rgb_line, a_ptr, w, incr);
     1589            if (s->is_rgba)
     1590                put_dummy_gray16((uint16_t *)rgb_line + 3, w, 4);
     1591        } else
     1592#endif
     1593        {
     1594            alpha_combine8(&s->cvt, rgb_line, a_ptr, w, incr);
     1595            if (s->is_rgba)
     1596                put_dummy_gray8(rgb_line + 3, w, 4);
     1597        }
     1598    } else if (s->is_rgba) {
     1599#ifdef USE_RGB48
     1600        if (s->is_16bpp) {
     1601            if (s->has_alpha) {
     1602                a_ptr = (PIXEL *)(s->a_buf + y * s->a_linesize);
     1603                gray_to_gray16(&s->cvt,
     1604                               (uint16_t *)rgb_line + 3, a_ptr, w, 4);
     1605                if (s->premultiplied_alpha)
     1606                    alpha_divide16((uint16_t *)rgb_line, w);
     1607            } else {
     1608                put_dummy_gray16((uint16_t *)rgb_line + 3, w, 4);
     1609            }
     1610        } else
     1611#endif
     1612        {
     1613            if (s->has_alpha) {
     1614                a_ptr = (PIXEL *)(s->a_buf + y * s->a_linesize);
     1615                gray_to_gray8(&s->cvt, rgb_line + 3, a_ptr, w, 4);
     1616                if (s->premultiplied_alpha)
     1617                    alpha_divide8((uint8_t *)rgb_line, w);
     1618            } else {
     1619                put_dummy_gray8(rgb_line + 3, w, 4);
     1620            }
     1621            }
     1622    }
     1623
     1624    /* go to next line */
     1625    s->y++;
     1626    return 0;
     1627}
     1628
     1629BPGDecoderContext *bpg_decoder_open(void)
     1630{
     1631    BPGDecoderContext *s;
     1632
     1633    s = av_mallocz(sizeof(BPGDecoderContext));
     1634    if (!s)
     1635        return NULL;
     1636    return s;
     1637}
     1638
     1639typedef struct {
     1640    uint32_t width, height;
     1641    BPGImageFormatEnum format;
     1642    uint8_t has_alpha;
     1643    uint8_t bit_depth;
     1644    uint8_t has_w_plane;
     1645    uint8_t premultiplied_alpha;
     1646    uint8_t limited_range;
     1647    uint8_t has_animation;
     1648    uint16_t loop_count;
     1649    uint16_t frame_delay_num;
     1650    uint16_t frame_delay_den;
     1651    BPGColorSpaceEnum color_space;
     1652    uint32_t hevc_data_len;
     1653    BPGExtensionData *first_md;
     1654} BPGHeaderData;
     1655
     1656static int bpg_decode_header(BPGHeaderData *h,
     1657                             const uint8_t *buf, int buf_len,
     1658                             int header_only, int load_extensions)
     1659{
     1660    int idx, flags1, flags2, has_extension, ret, alpha1_flag, alpha2_flag;
     1661    uint32_t extension_data_len;
     1662
     1663    if (buf_len < 6)
     1664        return -1;
     1665    /* check magic */
     1666    if (buf[0] != ((BPG_HEADER_MAGIC >> 24) & 0xff) ||
     1667        buf[1] != ((BPG_HEADER_MAGIC >> 16) & 0xff) ||
     1668        buf[2] != ((BPG_HEADER_MAGIC >> 8) & 0xff) ||
     1669        buf[3] != ((BPG_HEADER_MAGIC >> 0) & 0xff))
     1670        return -1;
     1671    idx = 4;
     1672    flags1 = buf[idx++];
     1673    h->format = flags1 >> 5;
     1674    if (h->format > 5)
     1675        return -1;
     1676    alpha1_flag = (flags1 >> 4) & 1;
     1677    h->bit_depth = (flags1 & 0xf) + 8;
     1678    if (h->bit_depth > 14)
     1679        return -1;
     1680    flags2 = buf[idx++];
     1681    h->color_space = (flags2 >> 4) & 0xf;
     1682    has_extension = (flags2 >> 3) & 1;
     1683    alpha2_flag = (flags2 >> 2) & 1;
     1684    h->limited_range = (flags2 >> 1) & 1;
     1685    h->has_animation = flags2 & 1;
     1686    h->loop_count = 0;
     1687    h->frame_delay_num = 0;
     1688    h->frame_delay_den = 0;
     1689    h->has_alpha = 0;
     1690    h->has_w_plane = 0;
     1691    h->premultiplied_alpha = 0;
     1692   
     1693    if (alpha1_flag) {
     1694        h->has_alpha = 1;
     1695        h->premultiplied_alpha = alpha2_flag;
     1696    } else if (alpha2_flag) {
     1697        h->has_alpha = 1;
     1698        h->has_w_plane = 1;
     1699    }
     1700
     1701    if (h->color_space >= BPG_CS_COUNT ||
     1702        (h->format == BPG_FORMAT_GRAY && h->color_space != 0) ||
     1703        (h->has_w_plane && h->format == BPG_FORMAT_GRAY))
     1704        return -1;
     1705    ret = get_ue(&h->width, buf + idx, buf_len - idx);
     1706    if (ret < 0)
     1707        return -1;
     1708    idx += ret;
     1709    ret = get_ue(&h->height, buf + idx, buf_len - idx);
     1710    if (ret < 0)
     1711        return -1;
     1712    idx += ret;
     1713    if (h->width == 0 || h->height == 0)
     1714        return -1;
     1715    if (header_only)
     1716        return idx;
     1717
     1718    ret = get_ue(&h->hevc_data_len, buf + idx, buf_len - idx);
     1719    if (ret < 0)
     1720        return -1;
     1721    idx += ret;
     1722           
     1723    extension_data_len = 0;
     1724    if (has_extension) {
     1725        ret = get_ue(&extension_data_len, buf + idx, buf_len - idx);
     1726        if (ret < 0)
     1727            return -1;
     1728        idx += ret;
     1729    }
     1730
     1731    h->first_md = NULL;
     1732    if (has_extension) {
     1733        int ext_end;
     1734
     1735        ext_end = idx + extension_data_len;
     1736        if (ext_end > buf_len)
     1737            return -1;
     1738        if (load_extensions || h->has_animation) {
     1739            BPGExtensionData *md, **plast_md;
     1740            uint32_t tag, buf_len;
     1741
     1742            plast_md = &h->first_md;
     1743            while (idx < ext_end) {
     1744                ret = get_ue32(&tag, buf + idx, ext_end - idx);
     1745                if (ret < 0)
     1746                    goto fail;
     1747                idx += ret;
     1748
     1749                ret = get_ue(&buf_len, buf + idx, ext_end - idx);
     1750                if (ret < 0)
     1751                    goto fail;
     1752                idx += ret;
     1753               
     1754                if (idx + buf_len > ext_end) {
     1755                fail:
     1756                    bpg_decoder_free_extension_data(h->first_md);
     1757                    return -1;
     1758                }
     1759                if (h->has_animation && tag == BPG_EXTENSION_TAG_ANIM_CONTROL) {
     1760                    int idx1;
     1761                    uint32_t loop_count, frame_delay_num, frame_delay_den;
     1762
     1763                    idx1 = idx;
     1764                    ret = get_ue(&loop_count, buf + idx1, ext_end - idx1);
     1765                    if (ret < 0)
     1766                        goto fail;
     1767                    idx1 += ret;
     1768                    ret = get_ue(&frame_delay_num, buf + idx1, ext_end - idx1);
     1769                    if (ret < 0)
     1770                        goto fail;
     1771                    idx1 += ret;
     1772                    ret = get_ue(&frame_delay_den, buf + idx1, ext_end - idx1);
     1773                    if (ret < 0)
     1774                        goto fail;
     1775                    idx1 += ret;
     1776                    if (frame_delay_num == 0 || frame_delay_den == 0 ||
     1777                        (uint16_t)frame_delay_num != frame_delay_num ||
     1778                        (uint16_t)frame_delay_den != frame_delay_den ||
     1779                        (uint16_t)loop_count != loop_count)
     1780                        goto fail;
     1781                    h->loop_count = loop_count;
     1782                    h->frame_delay_num = frame_delay_num;
     1783                    h->frame_delay_den = frame_delay_den;
     1784                }
     1785                if (load_extensions) {
     1786                    md = av_malloc(sizeof(BPGExtensionData));
     1787                    md->tag = tag;
     1788                    md->buf_len = buf_len;
     1789                    *plast_md = md;
     1790                    plast_md = &md->next;
     1791                   
     1792                    md->buf = av_malloc(md->buf_len);
     1793                    memcpy(md->buf, buf + idx, md->buf_len);
     1794                }
     1795                idx += buf_len;
     1796            }
     1797        } else
     1798        {
     1799            /* skip extension data */
     1800            idx += extension_data_len;
     1801        }
     1802    }
     1803
     1804    /* must have animation control extension for animations */
     1805    if (h->has_animation && h->frame_delay_num == 0)
     1806        goto fail;
     1807
     1808    if (h->hevc_data_len == 0)
     1809        h->hevc_data_len = buf_len - idx;
     1810   
     1811    return idx;
     1812}
     1813
     1814int bpg_decoder_decode(BPGDecoderContext *img, const uint8_t *buf, int buf_len)
     1815{
     1816    int idx, has_alpha, bit_depth, color_space, ret;
     1817    uint32_t width, height;
     1818    BPGHeaderData h_s, *h = &h_s;
     1819
     1820    idx = bpg_decode_header(h, buf, buf_len, 0, img->keep_extension_data);
     1821    if (idx < 0)
     1822        return idx;
     1823    width = h->width;
     1824    height = h->height;
     1825    has_alpha = h->has_alpha;
     1826    color_space = h->color_space;
     1827    bit_depth = h->bit_depth;
     1828   
     1829    img->w = width;
     1830    img->h = height;
     1831    img->format = h->format;
     1832    if (h->format == BPG_FORMAT_422_VIDEO) {
     1833        img->format = BPG_FORMAT_422;
     1834        img->c_h_phase = 0;
     1835    } else if (h->format == BPG_FORMAT_420_VIDEO) {
     1836        img->format = BPG_FORMAT_420;
     1837        img->c_h_phase = 0;
     1838    } else {
     1839        img->format = h->format;
     1840        img->c_h_phase = 1;
     1841    }
     1842    img->has_alpha = has_alpha;
     1843    img->premultiplied_alpha = h->premultiplied_alpha;
     1844    img->has_w_plane = h->has_w_plane;
     1845    img->limited_range = h->limited_range;
     1846    img->color_space = color_space;
     1847    img->bit_depth = bit_depth;
     1848    img->has_animation = h->has_animation;
     1849    img->loop_count = h->loop_count;
     1850    img->frame_delay_num = h->frame_delay_num;
     1851    img->frame_delay_den = h->frame_delay_den;
     1852
     1853    img->first_md = h->first_md;
     1854
     1855    if (idx + h->hevc_data_len > buf_len)
     1856        goto fail;
     1857
     1858    /* decode the first frame */
     1859    ret = hevc_decode_start(img, buf + idx, buf_len - idx,
     1860                            width, height, img->format, bit_depth, has_alpha);
     1861    if (ret < 0)
     1862        goto fail;
     1863    idx += ret;
     1864
     1865#ifdef USE_PRED
     1866    /* XXX: add an option to avoid decoding animations ? */
     1867    img->decode_animation = 1;
     1868    if (img->has_animation && img->decode_animation) {
     1869        int len;
     1870        /* keep trailing bitstream to decode the next frames */
     1871        len = buf_len - idx;
     1872        img->input_buf = av_malloc(len);
     1873        if (!img->input_buf)
     1874            goto fail;
     1875        memcpy(img->input_buf, buf + idx, len);
     1876        img->input_buf_len = len;
     1877        img->input_buf_pos = 0;
     1878    } else
     1879#endif
     1880    {
     1881        hevc_decode_end(img);
     1882    }
     1883    if (img->frame->width < img->w || img->frame->height < img->h)
     1884        goto fail;
     1885    img->y = -1;
     1886    return 0;
     1887
     1888 fail:
     1889    av_frame_free(&img->frame);
     1890    av_frame_free(&img->alpha_frame);
     1891    bpg_decoder_free_extension_data(img->first_md);
     1892    img->first_md = NULL;
     1893    return -1;
     1894}
     1895
     1896void bpg_decoder_close(BPGDecoderContext *s)
     1897{
     1898    bpg_decoder_output_end(s);
     1899    av_free(s->input_buf);
     1900    hevc_decode_end(s);
     1901    av_frame_free(&s->frame);
     1902    av_frame_free(&s->alpha_frame);
     1903    bpg_decoder_free_extension_data(s->first_md);
     1904    av_free(s);
     1905}
     1906
     1907void bpg_decoder_free_extension_data(BPGExtensionData *first_md)
     1908{
     1909#ifndef EMSCRIPTEN
     1910    BPGExtensionData *md, *md_next;
     1911   
     1912    for(md = first_md; md != NULL; md = md_next) {
     1913        md_next = md->next;
     1914        av_free(md->buf);
     1915        av_free(md);
     1916    }
     1917#endif
     1918}
     1919
     1920#ifndef EMSCRIPTEN
     1921void bpg_decoder_keep_extension_data(BPGDecoderContext *s, int enable)
     1922{
     1923    s->keep_extension_data = enable;
     1924}
     1925
     1926BPGExtensionData *bpg_decoder_get_extension_data(BPGDecoderContext *s)
     1927{
     1928    return s->first_md;
     1929}
     1930
     1931int bpg_decoder_get_info_from_buf(BPGImageInfo *p,
     1932                                  BPGExtensionData **pfirst_md,
     1933                                  const uint8_t *buf, int buf_len)
     1934{
     1935    BPGHeaderData h_s, *h = &h_s;
     1936    int parse_extension;
     1937
     1938    parse_extension = (pfirst_md != NULL);
     1939    if (bpg_decode_header(h, buf, buf_len,
     1940                          !parse_extension, parse_extension) < 0)
     1941        return -1;
     1942    p->width = h->width;
     1943    p->height = h->height;
     1944    p->format = h->format;
     1945    p->has_alpha = h->has_alpha && !h->has_w_plane;
     1946    p->premultiplied_alpha = h->premultiplied_alpha;
     1947    p->has_w_plane = h->has_w_plane;
     1948    p->limited_range = h->limited_range;
     1949    p->color_space = h->color_space;
     1950    p->bit_depth = h->bit_depth;
     1951    p->has_animation = h->has_animation;
     1952    p->loop_count = h->loop_count;
     1953    if (pfirst_md)
     1954        *pfirst_md = h->first_md;
     1955    return 0;
     1956}
     1957#endif
  • xpra/codecs/bpg/libbpg.h

     
     1/*
     2 * BPG decoder
     3 *
     4 * Copyright (c) 2014 Fabrice Bellard
     5 *
     6 * Permission is hereby granted, free of charge, to any person obtaining a copy
     7 * of this software and associated documentation files (the "Software"), to deal
     8 * in the Software without restriction, including without limitation the rights
     9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     10 * copies of the Software, and to permit persons to whom the Software is
     11 * furnished to do so, subject to the following conditions:
     12 *
     13 * The above copyright notice and this permission notice shall be included in
     14 * all copies or substantial portions of the Software.
     15 *
     16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
     19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     22 * THE SOFTWARE.
     23 */
     24#ifndef _LIBBPG_H
     25#define _LIBBPG_H
     26
     27typedef struct BPGDecoderContext BPGDecoderContext;
     28
     29typedef enum {
     30    BPG_FORMAT_GRAY,
     31    BPG_FORMAT_420, /* chroma at offset (0.5, 0.5) (JPEG) */
     32    BPG_FORMAT_422, /* chroma at offset (0.5, 0) (JPEG) */
     33    BPG_FORMAT_444,
     34    BPG_FORMAT_420_VIDEO, /* chroma at offset (0, 0.5) (MPEG2) */
     35    BPG_FORMAT_422_VIDEO, /* chroma at offset (0, 0) (MPEG2) */
     36} BPGImageFormatEnum;
     37
     38typedef enum {
     39    BPG_CS_YCbCr,
     40    BPG_CS_RGB,
     41    BPG_CS_YCgCo,
     42    BPG_CS_YCbCr_BT709,
     43    BPG_CS_YCbCr_BT2020,
     44
     45    BPG_CS_COUNT,
     46} BPGColorSpaceEnum;
     47
     48typedef struct {
     49    uint32_t width;
     50    uint32_t height;
     51    uint8_t format; /* see BPGImageFormatEnum */
     52    uint8_t has_alpha; /* TRUE if an alpha plane is present */
     53    uint8_t color_space; /* see BPGColorSpaceEnum */
     54    uint8_t bit_depth;
     55    uint8_t premultiplied_alpha; /* TRUE if the color is alpha premultiplied */
     56    uint8_t has_w_plane; /* TRUE if a W plane is present (for CMYK encoding) */
     57    uint8_t limited_range; /* TRUE if limited range for the color */
     58    uint8_t has_animation; /* TRUE if the image contains animations */
     59    uint16_t loop_count; /* animations: number of loop, 0 = infinity */
     60} BPGImageInfo;
     61
     62typedef enum {
     63    BPG_EXTENSION_TAG_EXIF = 1,
     64    BPG_EXTENSION_TAG_ICCP = 2,
     65    BPG_EXTENSION_TAG_XMP = 3,
     66    BPG_EXTENSION_TAG_THUMBNAIL = 4,
     67    BPG_EXTENSION_TAG_ANIM_CONTROL = 5,
     68} BPGExtensionTagEnum;
     69
     70typedef struct BPGExtensionData {
     71    BPGExtensionTagEnum tag;
     72    uint32_t buf_len;
     73    uint8_t *buf;
     74    struct BPGExtensionData *next;
     75} BPGExtensionData;
     76
     77typedef enum {
     78    BPG_OUTPUT_FORMAT_RGB24,
     79    BPG_OUTPUT_FORMAT_RGBA32, /* not premultiplied alpha */
     80    BPG_OUTPUT_FORMAT_RGB48,
     81    BPG_OUTPUT_FORMAT_RGBA64, /* not premultiplied alpha */
     82    BPG_OUTPUT_FORMAT_CMYK32,
     83    BPG_OUTPUT_FORMAT_CMYK64,
     84} BPGDecoderOutputFormat;
     85
     86#define BPG_DECODER_INFO_BUF_SIZE 16
     87
     88BPGDecoderContext *bpg_decoder_open(void);
     89
     90/* If enable is true, extension data are kept during the image
     91   decoding and can be accessed after bpg_decoder_decode() with
     92   bpg_decoder_get_extension(). By default, the extension data are
     93   discarded. */
     94void bpg_decoder_keep_extension_data(BPGDecoderContext *s, int enable);
     95
     96/* return 0 if 0K, < 0 if error */
     97int bpg_decoder_decode(BPGDecoderContext *s, const uint8_t *buf, int buf_len);
     98
     99/* Return the first element of the extension data list */
     100BPGExtensionData *bpg_decoder_get_extension_data(BPGDecoderContext *s);
     101
     102/* return 0 if 0K, < 0 if error */
     103int bpg_decoder_get_info(BPGDecoderContext *s, BPGImageInfo *p);
     104
     105/* return 0 if 0K, < 0 if error */
     106int bpg_decoder_start(BPGDecoderContext *s, BPGDecoderOutputFormat out_fmt);
     107
     108/* return the frame delay for animations as a fraction (*pnum) / (*pden)
     109   in seconds. In case there is no animation, 0 / 1 is returned. */
     110void bpg_decoder_get_frame_duration(BPGDecoderContext *s, int *pnum, int *pden);
     111
     112/* return 0 if 0K, < 0 if error */
     113int bpg_decoder_get_line(BPGDecoderContext *s, void *buf);
     114
     115void bpg_decoder_close(BPGDecoderContext *s);
     116
     117/* only useful for low level access to the image data */
     118uint8_t *bpg_decoder_get_data(BPGDecoderContext *s, int *pline_size, int plane);
     119
     120/* Get information from the start of the image data in 'buf' (at least
     121   min(BPG_DECODER_INFO_BUF_SIZE, file_size) bytes must be given).
     122
     123   If pfirst_md != NULL, the extension data are also parsed and the
     124   first element of the list is returned in *pfirst_md. The list must
     125   be freed with bpg_decoder_free_extension_data().
     126
     127   BPGImageInfo.loop_count is only set if extension data are parsed.
     128
     129   Return 0 if OK, < 0 if unrecognized data. */
     130int bpg_decoder_get_info_from_buf(BPGImageInfo *p,
     131                                  BPGExtensionData **pfirst_md,
     132                                  const uint8_t *buf, int buf_len);
     133/* Free the extension data returned by bpg_decoder_get_info_from_buf() */
     134void bpg_decoder_free_extension_data(BPGExtensionData *first_md);
     135
     136#endif /* _LIBBPG_H */