GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/jpeglsdec.c Lines: 140 300 46.7 %
Date: 2019-11-18 18:00:01 Branches: 94 224 42.0 %

Line Branch Exec Source
1
/*
2
 * JPEG-LS decoder
3
 * Copyright (c) 2003 Michael Niedermayer
4
 * Copyright (c) 2006 Konstantin Shishkov
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * JPEG-LS decoder.
26
 */
27
28
#include "avcodec.h"
29
#include "get_bits.h"
30
#include "golomb.h"
31
#include "internal.h"
32
#include "mathops.h"
33
#include "mjpeg.h"
34
#include "mjpegdec.h"
35
#include "jpegls.h"
36
#include "jpeglsdec.h"
37
38
/*
39
 * Uncomment this to significantly speed up decoding of broken JPEG-LS
40
 * (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit.
41
 *
42
 * There is no Golomb code with length >= 32 bits possible, so check and
43
 * avoid situation of 32 zeros, FFmpeg Golomb decoder is painfully slow
44
 * on this errors.
45
 */
46
//#define JLS_BROKEN
47
48
/**
49
 * Decode LSE block with initialization parameters
50
 */
51
int ff_jpegls_decode_lse(MJpegDecodeContext *s)
52
{
53
    int id;
54
    int tid, wt, maxtab, i, j;
55
56
    int len = get_bits(&s->gb, 16);
57
    id = get_bits(&s->gb, 8);
58
59
    switch (id) {
60
    case 1:
61
        if (len < 13)
62
            return AVERROR_INVALIDDATA;
63
64
        s->maxval = get_bits(&s->gb, 16);
65
        s->t1     = get_bits(&s->gb, 16);
66
        s->t2     = get_bits(&s->gb, 16);
67
        s->t3     = get_bits(&s->gb, 16);
68
        s->reset  = get_bits(&s->gb, 16);
69
70
        if(s->avctx->debug & FF_DEBUG_PICT_INFO) {
71
            av_log(s->avctx, AV_LOG_DEBUG, "Coding parameters maxval:%d T1:%d T2:%d T3:%d reset:%d\n",
72
                   s->maxval, s->t1, s->t2, s->t3, s->reset);
73
        }
74
75
//        ff_jpegls_reset_coding_parameters(s, 0);
76
        //FIXME quant table?
77
        break;
78
    case 2:
79
        s->palette_index = 0;
80
    case 3:
81
        tid= get_bits(&s->gb, 8);
82
        wt = get_bits(&s->gb, 8);
83
84
        if (len < 5)
85
            return AVERROR_INVALIDDATA;
86
87
        if (wt < 1 || wt > MAX_COMPONENTS) {
88
            avpriv_request_sample(s->avctx, "wt %d", wt);
89
            return AVERROR_PATCHWELCOME;
90
        }
91
92
        if (!s->maxval)
93
            maxtab = 255;
94
        else if ((5 + wt*(s->maxval+1)) < 65535)
95
            maxtab = s->maxval;
96
        else
97
            maxtab = 65530/wt - 1;
98
99
        if(s->avctx->debug & FF_DEBUG_PICT_INFO) {
100
            av_log(s->avctx, AV_LOG_DEBUG, "LSE palette %d tid:%d wt:%d maxtab:%d\n", id, tid, wt, maxtab);
101
        }
102
        if (maxtab >= 256) {
103
            avpriv_request_sample(s->avctx, ">8bit palette");
104
            return AVERROR_PATCHWELCOME;
105
        }
106
        maxtab = FFMIN(maxtab, (len - 5) / wt + s->palette_index);
107
108
        if (s->palette_index > maxtab)
109
            return AVERROR_INVALIDDATA;
110
111
        if ((s->avctx->pix_fmt == AV_PIX_FMT_GRAY8 || s->avctx->pix_fmt == AV_PIX_FMT_PAL8) &&
112
            (s->picture_ptr->format == AV_PIX_FMT_GRAY8 || s->picture_ptr->format == AV_PIX_FMT_PAL8)) {
113
            uint32_t *pal = (uint32_t *)s->picture_ptr->data[1];
114
            int shift = 0;
115
116
            if (s->avctx->bits_per_raw_sample > 0 && s->avctx->bits_per_raw_sample < 8) {
117
                maxtab = FFMIN(maxtab, (1<<s->avctx->bits_per_raw_sample)-1);
118
                shift = 8 - s->avctx->bits_per_raw_sample;
119
            }
120
121
            s->picture_ptr->format =
122
            s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
123
            for (i=s->palette_index; i<=maxtab; i++) {
124
                uint8_t k = i << shift;
125
                pal[k] = 0;
126
                for (j=0; j<wt; j++) {
127
                    pal[k] |= get_bits(&s->gb, 8) << (8*(wt-j-1));
128
                }
129
            }
130
            s->palette_index = i;
131
        }
132
        break;
133
    case 4:
134
        avpriv_request_sample(s->avctx, "oversize image");
135
        return AVERROR(ENOSYS);
136
    default:
137
        av_log(s->avctx, AV_LOG_ERROR, "invalid id %d\n", id);
138
        return AVERROR_INVALIDDATA;
139
    }
140
    ff_dlog(s->avctx, "ID=%i, T=%i,%i,%i\n", id, s->t1, s->t2, s->t3);
141
142
    return 0;
143
}
144
145
/**
146
 * Get context-dependent Golomb code, decode it and update context
147
 */
148
44233354
static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q)
149
{
150
    int k, ret;
151
152
161401088
    for (k = 0; (state->N[Q] << k) < state->A[Q]; k++)
153
        ;
154
155
#ifdef JLS_BROKEN
156
    if (!show_bits_long(gb, 32))
157
        return -1;
158
#endif
159
44233354
    ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp);
160
161
    /* decode mapped error */
162
44233354
    if (ret & 1)
163
22858672
        ret = -(ret + 1 >> 1);
164
    else
165
21374682
        ret >>= 1;
166
167
    /* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */
168

44233354
    if (!state->near && !k && (2 * state->B[Q] <= -state->N[Q]))
169
661600
        ret = -(ret + 1);
170
171
44233354
    ret = ff_jpegls_update_state_regular(state, Q, ret);
172
173
44233354
    return ret;
174
}
175
176
/**
177
 * Get Golomb code, decode it and update state for run termination
178
 */
179
523199
static inline int ls_get_code_runterm(GetBitContext *gb, JLSState *state,
180
                                      int RItype, int limit_add)
181
{
182
    int k, ret, temp, map;
183
523199
    int Q = 365 + RItype;
184
185
523199
    temp = state->A[Q];
186
523199
    if (RItype)
187
293114
        temp += state->N[Q] >> 1;
188
189
2157212
    for (k = 0; (state->N[Q] << k) < temp; k++)
190
        ;
191
192
#ifdef JLS_BROKEN
193
    if (!show_bits_long(gb, 32))
194
        return -1;
195
#endif
196
523199
    ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1,
197
                               state->qbpp);
198
199
    /* decode mapped error */
200
523199
    map = 0;
201


523199
    if (!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q]))
202
4044
        map = 1;
203
523199
    ret += RItype + map;
204
205
523199
    if (ret & 1) {
206
229976
        ret = map - (ret + 1 >> 1);
207
229976
        state->B[Q]++;
208
    } else {
209
293223
        ret = ret >> 1;
210
    }
211
212
523199
    if(FFABS(ret) > 0xFFFF)
213
        return -0x10000;
214
    /* update state */
215
523199
    state->A[Q] += FFABS(ret) - RItype;
216
523199
    ret         *= state->twonear;
217
523199
    ff_jpegls_downscale_state(state, Q);
218
219
523199
    return ret;
220
}
221
222
/**
223
 * Decode one line of image
224
 */
225
138258
static inline int ls_decode_line(JLSState *state, MJpegDecodeContext *s,
226
                                  void *last, void *dst, int last2, int w,
227
                                  int stride, int comp, int bits)
228
{
229
138258
    int i, x = 0;
230
    int Ra, Rb, Rc, Rd;
231
    int D0, D1, D2;
232
233
44894811
    while (x < w) {
234
        int err, pred;
235
236
44762072
        if (get_bits_left(&s->gb) <= 0)
237
            return AVERROR_INVALIDDATA;
238
239
        /* compute gradients */
240

44762072
        Ra = x ? R(dst, x - stride) : R(last, x);
241
44762072
        Rb = R(last, x);
242

44762072
        Rc = x ? R(last, x - stride) : last2;
243

44762072
        Rd = (x >= w - stride) ? R(last, x) : R(last, x + stride);
244
44762072
        D0 = Rd - Rb;
245
44762072
        D1 = Rb - Rc;
246
44762072
        D2 = Rc - Ra;
247
        /* run mode */
248
44762072
        if ((FFABS(D0) <= state->near) &&
249
4774536
            (FFABS(D1) <= state->near) &&
250
2186809
            (FFABS(D2) <= state->near)) {
251
            int r;
252
            int RItype;
253
254
            /* decode full runs while available */
255
1005208
            while (get_bits1(&s->gb)) {
256
                int r;
257
482009
                r = 1 << ff_log2_run[state->run_index[comp]];
258
482009
                if (x + r * stride > w)
259
4290
                    r = (w - x) / stride;
260
2099605
                for (i = 0; i < r; i++) {
261
1617596
                    W(dst, x, Ra);
262
1617596
                    x += stride;
263
                }
264
                /* if EOL reached, we stop decoding */
265
482009
                if (r != 1 << ff_log2_run[state->run_index[comp]])
266
4290
                    return 0;
267
477719
                if (state->run_index[comp] < 31)
268
477719
                    state->run_index[comp]++;
269
477719
                if (x + stride > w)
270
1229
                    return 0;
271
            }
272
            /* decode aborted run */
273
523199
            r = ff_log2_run[state->run_index[comp]];
274
523199
            if (r)
275
423893
                r = get_bits_long(&s->gb, r);
276
523199
            if (x + r * stride > w) {
277
                r = (w - x) / stride;
278
            }
279
1161630
            for (i = 0; i < r; i++) {
280
638431
                W(dst, x, Ra);
281
638431
                x += stride;
282
            }
283
284
523199
            if (x >= w) {
285
                av_log(NULL, AV_LOG_ERROR, "run overflow\n");
286
                av_assert0(x <= w);
287
                return AVERROR_INVALIDDATA;
288
            }
289
290
            /* decode run termination value */
291
523199
            Rb     = R(last, x);
292
523199
            RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0;
293
523199
            err    = ls_get_code_runterm(&s->gb, state, RItype,
294
523199
                                         ff_log2_run[state->run_index[comp]]);
295
523199
            if (state->run_index[comp])
296
475644
                state->run_index[comp]--;
297
298

523199
            if (state->near && RItype) {
299
                pred = Ra + err;
300
            } else {
301
523199
                if (Rb < Ra)
302
148709
                    pred = Rb - err;
303
                else
304
374490
                    pred = Rb + err;
305
            }
306
        } else { /* regular mode */
307
            int context, sign;
308
309
44233354
            context = ff_jpegls_quantize(state, D0) * 81 +
310
44233354
                      ff_jpegls_quantize(state, D1) *  9 +
311
44233354
                      ff_jpegls_quantize(state, D2);
312
44233354
            pred    = mid_pred(Ra, Ra + Rb - Rc, Rb);
313
314
44233354
            if (context < 0) {
315
17897505
                context = -context;
316
17897505
                sign    = 1;
317
            } else {
318
26335849
                sign = 0;
319
            }
320
321
44233354
            if (sign) {
322
17897505
                pred = av_clip(pred - state->C[context], 0, state->maxval);
323
17897505
                err  = -ls_get_code_regular(&s->gb, state, context);
324
            } else {
325
26335849
                pred = av_clip(pred + state->C[context], 0, state->maxval);
326
26335849
                err  = ls_get_code_regular(&s->gb, state, context);
327
            }
328
329
            /* we have to do something more for near-lossless coding */
330
44233354
            pred += err;
331
        }
332
44756553
        if (state->near) {
333
            if (pred < -state->near)
334
                pred += state->range * state->twonear;
335
            else if (pred > state->maxval + state->near)
336
                pred -= state->range * state->twonear;
337
            pred = av_clip(pred, 0, state->maxval);
338
        }
339
340
44756553
        pred &= state->maxval;
341
44756553
        W(dst, x, pred);
342
44756553
        x += stride;
343
    }
344
345
132739
    return 0;
346
}
347
348
205
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near,
349
                             int point_transform, int ilv)
350
{
351
205
    int i, t = 0;
352
    uint8_t *zero, *last, *cur;
353
    JLSState *state;
354
205
    int off = 0, stride = 1, width, shift, ret = 0;
355
205
    int decoded_height = 0;
356
357
205
    zero = av_mallocz(s->picture_ptr->linesize[0]);
358
205
    if (!zero)
359
        return AVERROR(ENOMEM);
360
205
    last = zero;
361
205
    cur  = s->picture_ptr->data[0];
362
363
205
    state = av_mallocz(sizeof(JLSState));
364
205
    if (!state) {
365
        av_free(zero);
366
        return AVERROR(ENOMEM);
367
    }
368
    /* initialize JPEG-LS state from JPEG parameters */
369
205
    state->near   = near;
370
205
    state->bpp    = (s->bits < 2) ? 2 : s->bits;
371
205
    state->maxval = s->maxval;
372
205
    state->T1     = s->t1;
373
205
    state->T2     = s->t2;
374
205
    state->T3     = s->t3;
375
205
    state->reset  = s->reset;
376
205
    ff_jpegls_reset_coding_parameters(state, 0);
377
205
    ff_jpegls_init_state(state);
378
379
205
    if (s->bits <= 8)
380
205
        shift = point_transform + (8 - s->bits);
381
    else
382
        shift = point_transform + (16 - s->bits);
383
384
205
    if (shift >= 16) {
385
        ret = AVERROR_INVALIDDATA;
386
        goto end;
387
    }
388
389
205
    if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
390
        av_log(s->avctx, AV_LOG_DEBUG,
391
               "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) "
392
               "RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",
393
                s->width, s->height, state->near, state->maxval,
394
                state->T1, state->T2, state->T3,
395
                state->reset, state->limit, state->qbpp, state->range);
396
        av_log(s->avctx, AV_LOG_DEBUG, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
397
                ilv, point_transform, s->bits, s->cur_scan);
398
    }
399
205
    if (get_bits_left(&s->gb) < s->height) {
400
        ret = AVERROR_INVALIDDATA;
401
        goto end;
402
    }
403
205
    if (ilv == 0) { /* separate planes */
404
        if (s->cur_scan > s->nb_components) {
405
            ret = AVERROR_INVALIDDATA;
406
            goto end;
407
        }
408
        stride = (s->nb_components > 1) ? 3 : 1;
409
        off    = av_clip(s->cur_scan - 1, 0, stride - 1);
410
        width  = s->width * stride;
411
        cur   += off;
412
        for (i = 0; i < s->height; i++) {
413
            int ret;
414
            if (s->bits <= 8) {
415
                ret = ls_decode_line(state, s, last, cur, t, width, stride, off, 8);
416
                t = last[0];
417
            } else {
418
                ret = ls_decode_line(state, s, last, cur, t, width, stride, off, 16);
419
                t = *((uint16_t *)last);
420
            }
421
            if (ret < 0)
422
                break;
423
            last = cur;
424
            cur += s->picture_ptr->linesize[0];
425
426
            if (s->restart_interval && !--s->restart_count) {
427
                align_get_bits(&s->gb);
428
                skip_bits(&s->gb, 16); /* skip RSTn */
429
            }
430
        }
431
        decoded_height = i;
432
205
    } else if (ilv == 1) { /* line interleaving */
433
        int j;
434
205
        int Rc[3] = { 0, 0, 0 };
435
205
        stride = (s->nb_components > 1) ? 3 : 1;
436
205
        memset(cur, 0, s->picture_ptr->linesize[0]);
437
205
        width = s->width * stride;
438
46291
        for (i = 0; i < s->height; i++) {
439
            int ret;
440
184344
            for (j = 0; j < stride; j++) {
441
138258
                ret = ls_decode_line(state, s, last + j, cur + j,
442
                               Rc[j], width, stride, j, 8);
443
138258
                if (ret < 0)
444
                    break;
445
138258
                Rc[j] = last[j];
446
447

138258
                if (s->restart_interval && !--s->restart_count) {
448
                    align_get_bits(&s->gb);
449
                    skip_bits(&s->gb, 16); /* skip RSTn */
450
                }
451
            }
452
46086
            if (ret < 0)
453
                break;
454
46086
            last = cur;
455
46086
            cur += s->picture_ptr->linesize[0];
456
        }
457
205
        decoded_height = i;
458
    } else if (ilv == 2) { /* sample interleaving */
459
        avpriv_report_missing_feature(s->avctx, "Sample interleaved images");
460
        ret = AVERROR_PATCHWELCOME;
461
        goto end;
462
    } else { /* unknown interleaving */
463
        avpriv_report_missing_feature(s->avctx, "Unknown interleaved images");
464
        ret = AVERROR_PATCHWELCOME;
465
        goto end;
466
    }
467
468

205
    if (s->xfrm && s->nb_components == 3) {
469
        int x, w;
470
471
        w = s->width * s->nb_components;
472
473
        if (s->bits <= 8) {
474
            uint8_t *src = s->picture_ptr->data[0];
475
476
            for (i = 0; i < s->height; i++) {
477
                switch(s->xfrm) {
478
                case 1:
479
                    for (x = off; x < w; x += 3) {
480
                        src[x  ] += src[x+1] + 128;
481
                        src[x+2] += src[x+1] + 128;
482
                    }
483
                    break;
484
                case 2:
485
                    for (x = off; x < w; x += 3) {
486
                        src[x  ] += src[x+1] + 128;
487
                        src[x+2] += ((src[x  ] + src[x+1])>>1) + 128;
488
                    }
489
                    break;
490
                case 3:
491
                    for (x = off; x < w; x += 3) {
492
                        int g = src[x+0] - ((src[x+2]+src[x+1])>>2) + 64;
493
                        src[x+0] = src[x+2] + g + 128;
494
                        src[x+2] = src[x+1] + g + 128;
495
                        src[x+1] = g;
496
                    }
497
                    break;
498
                case 4:
499
                    for (x = off; x < w; x += 3) {
500
                        int r    = src[x+0] - ((                       359 * (src[x+2]-128) + 490) >> 8);
501
                        int g    = src[x+0] - (( 88 * (src[x+1]-128) - 183 * (src[x+2]-128) +  30) >> 8);
502
                        int b    = src[x+0] + ((454 * (src[x+1]-128)                        + 574) >> 8);
503
                        src[x+0] = av_clip_uint8(r);
504
                        src[x+1] = av_clip_uint8(g);
505
                        src[x+2] = av_clip_uint8(b);
506
                    }
507
                    break;
508
                }
509
                src += s->picture_ptr->linesize[0];
510
            }
511
        }else
512
            avpriv_report_missing_feature(s->avctx, "16bit xfrm");
513
    }
514
515
205
    if (shift) { /* we need to do point transform or normalize samples */
516
        int x, w;
517
518
        w = s->width * s->nb_components;
519
520
        if (s->bits <= 8) {
521
            uint8_t *src = s->picture_ptr->data[0];
522
523
            for (i = 0; i < decoded_height; i++) {
524
                for (x = off; x < w; x += stride)
525
                    src[x] <<= shift;
526
                src += s->picture_ptr->linesize[0];
527
            }
528
        } else {
529
            uint16_t *src = (uint16_t *)s->picture_ptr->data[0];
530
531
            for (i = 0; i < decoded_height; i++) {
532
                for (x = 0; x < w; x++)
533
                    src[x] <<= shift;
534
                src += s->picture_ptr->linesize[0] / 2;
535
            }
536
        }
537
    }
538
539
205
end:
540
205
    av_free(state);
541
205
    av_free(zero);
542
543
205
    return ret;
544
}
545
546
AVCodec ff_jpegls_decoder = {
547
    .name           = "jpegls",
548
    .long_name      = NULL_IF_CONFIG_SMALL("JPEG-LS"),
549
    .type           = AVMEDIA_TYPE_VIDEO,
550
    .id             = AV_CODEC_ID_JPEGLS,
551
    .priv_data_size = sizeof(MJpegDecodeContext),
552
    .init           = ff_mjpeg_decode_init,
553
    .close          = ff_mjpeg_decode_end,
554
    .decode         = ff_mjpeg_decode_frame,
555
    .capabilities   = AV_CODEC_CAP_DR1,
556
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
557
};