← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty-proposed

« back to all changes in this revision

Viewing changes to libavcodec/mjpegdec.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/mjpegdec.c
37
37
#include "libavutil/opt.h"
38
38
#include "avcodec.h"
39
39
#include "dsputil.h"
 
40
#include "internal.h"
40
41
#include "mjpeg.h"
41
42
#include "mjpegdec.h"
42
43
#include "jpeglsdec.h"
46
47
                     const uint8_t *val_table, int nb_codes,
47
48
                     int use_static, int is_ac)
48
49
{
49
 
    uint8_t huff_size[256];
 
50
    uint8_t huff_size[256] = { 0 };
50
51
    uint16_t huff_code[256];
51
52
    uint16_t huff_sym[256];
52
53
    int i;
53
54
 
54
55
    assert(nb_codes <= 256);
55
56
 
56
 
    memset(huff_size, 0, sizeof(huff_size));
57
57
    ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
58
58
 
59
59
    for (i = 0; i < 256; i++)
68
68
 
69
69
static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
70
70
{
71
 
    build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance,
72
 
              ff_mjpeg_val_dc, 12, 0, 0);
73
 
    build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
74
 
              ff_mjpeg_val_dc, 12, 0, 0);
75
 
    build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance,
76
 
              ff_mjpeg_val_ac_luminance, 251, 0, 1);
77
 
    build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance,
78
 
              ff_mjpeg_val_ac_chrominance, 251, 0, 1);
79
 
    build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance,
80
 
              ff_mjpeg_val_ac_luminance, 251, 0, 0);
81
 
    build_vlc(&s->vlcs[2][1], ff_mjpeg_bits_ac_chrominance,
82
 
              ff_mjpeg_val_ac_chrominance, 251, 0, 0);
 
71
    build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
 
72
              avpriv_mjpeg_val_dc, 12, 0, 0);
 
73
    build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
 
74
              avpriv_mjpeg_val_dc, 12, 0, 0);
 
75
    build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
 
76
              avpriv_mjpeg_val_ac_luminance, 251, 0, 1);
 
77
    build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
 
78
              avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);
 
79
    build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
 
80
              avpriv_mjpeg_val_ac_luminance, 251, 0, 0);
 
81
    build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
 
82
              avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);
83
83
}
84
84
 
85
85
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
90
90
        s->picture_ptr = &s->picture;
91
91
 
92
92
    s->avctx = avctx;
93
 
    dsputil_init(&s->dsp, avctx);
 
93
    ff_dsputil_init(&s->dsp, avctx);
94
94
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
95
95
    s->buffer_size   = 0;
96
96
    s->buffer        = NULL;
101
101
 
102
102
    build_basic_mjpeg_vlc(s);
103
103
 
104
 
#if FF_API_MJPEG_GLOBAL_OPTS
105
 
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
106
 
        s->extern_huff = 1;
107
 
#endif
108
104
    if (s->extern_huff) {
 
105
        int ret;
109
106
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
110
107
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
111
 
        if (ff_mjpeg_decode_dht(s)) {
 
108
        if ((ret = ff_mjpeg_decode_dht(s))) {
112
109
            av_log(avctx, AV_LOG_ERROR,
113
110
                   "mjpeg: error using external huffman table\n");
114
 
            return AVERROR_INVALIDDATA;
 
111
            return ret;
115
112
        }
116
113
    }
117
114
    if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
118
115
        s->interlace_polarity = 1;           /* bottom field first */
119
116
        av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
120
117
    }
121
 
    if (avctx->codec->id == CODEC_ID_AMV)
 
118
    if (avctx->codec->id == AV_CODEC_ID_AMV)
122
119
        s->flipped = 1;
123
120
 
124
121
    return 0;
164
161
    int len, index, i, class, n, v, code_max;
165
162
    uint8_t bits_table[17];
166
163
    uint8_t val_table[256];
 
164
    int ret = 0;
167
165
 
168
166
    len = get_bits(&s->gb, 16) - 2;
169
167
 
170
168
    while (len > 0) {
171
169
        if (len < 17)
172
 
            return -1;
 
170
            return AVERROR_INVALIDDATA;
173
171
        class = get_bits(&s->gb, 4);
174
172
        if (class >= 2)
175
 
            return -1;
 
173
            return AVERROR_INVALIDDATA;
176
174
        index = get_bits(&s->gb, 4);
177
175
        if (index >= 4)
178
 
            return -1;
 
176
            return AVERROR_INVALIDDATA;
179
177
        n = 0;
180
178
        for (i = 1; i <= 16; i++) {
181
179
            bits_table[i] = get_bits(&s->gb, 8);
183
181
        }
184
182
        len -= 17;
185
183
        if (len < n || n > 256)
186
 
            return -1;
 
184
            return AVERROR_INVALIDDATA;
187
185
 
188
186
        code_max = 0;
189
187
        for (i = 0; i < n; i++) {
198
196
        ff_free_vlc(&s->vlcs[class][index]);
199
197
        av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
200
198
               class, index, code_max + 1);
201
 
        if (build_vlc(&s->vlcs[class][index], bits_table, val_table,
202
 
                      code_max + 1, 0, class > 0) < 0)
203
 
            return -1;
 
199
        if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
 
200
                             code_max + 1, 0, class > 0)) < 0)
 
201
            return ret;
204
202
 
205
203
        if (class > 0) {
206
204
            ff_free_vlc(&s->vlcs[2][index]);
207
 
            if (build_vlc(&s->vlcs[2][index], bits_table, val_table,
208
 
                          code_max + 1, 0, 0) < 0)
209
 
                return -1;
 
205
            if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
 
206
                                 code_max + 1, 0, 0)) < 0)
 
207
                return ret;
210
208
        }
211
209
    }
212
210
    return 0;
239
237
 
240
238
    av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
241
239
    if (av_image_check_size(width, height, 0, s->avctx))
242
 
        return -1;
 
240
        return AVERROR_INVALIDDATA;
243
241
 
244
242
    nb_components = get_bits(&s->gb, 8);
245
243
    if (nb_components <= 0 ||
246
244
        nb_components > MAX_COMPONENTS)
247
245
        return -1;
 
246
    if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
 
247
        if (nb_components != s->nb_components) {
 
248
            av_log(s->avctx, AV_LOG_ERROR,
 
249
                   "nb_components changing in interlaced picture\n");
 
250
            return AVERROR_INVALIDDATA;
 
251
        }
 
252
    }
248
253
    if (s->ls && !(s->bits <= 8 || nb_components == 1)) {
249
 
        av_log(s->avctx, AV_LOG_ERROR,
250
 
               "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
251
 
        return -1;
 
254
        av_log_missing_feature(s->avctx,
 
255
                               "For JPEG-LS anything except <= 8 bits/component"
 
256
                               " or 16-bit gray", 0);
 
257
        return AVERROR_PATCHWELCOME;
252
258
    }
253
259
    s->nb_components = nb_components;
254
260
    s->h_max         = 1;
265
271
            s->v_max = s->v_count[i];
266
272
        s->quant_index[i] = get_bits(&s->gb, 8);
267
273
        if (s->quant_index[i] >= 4)
268
 
            return -1;
 
274
            return AVERROR_INVALIDDATA;
 
275
        if (!s->h_count[i] || !s->v_count[i]) {
 
276
            av_log(s->avctx, AV_LOG_ERROR,
 
277
                   "Invalid sampling factor in component %d %d:%d\n",
 
278
                   i, s->h_count[i], s->v_count[i]);
 
279
            return AVERROR_INVALIDDATA;
 
280
        }
 
281
 
269
282
        av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
270
283
               i, s->h_count[i], s->v_count[i],
271
284
               s->component_id[i], s->quant_index[i]);
272
285
    }
273
286
 
274
287
    if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
275
 
        av_log(s->avctx, AV_LOG_ERROR,
276
 
               "Subsampling in JPEG-LS is not supported.\n");
277
 
        return -1;
 
288
        av_log_missing_feature(s->avctx, "Subsampling in JPEG-LS", 0);
 
289
        return AVERROR_PATCHWELCOME;
278
290
    }
279
291
 
280
292
    if (s->v_max == 1 && s->h_max == 1 && s->lossless == 1)
323
335
    switch (pix_fmt_id) {
324
336
    case 0x11111100:
325
337
        if (s->rgb)
326
 
            s->avctx->pix_fmt = PIX_FMT_BGRA;
 
338
            s->avctx->pix_fmt = AV_PIX_FMT_BGRA;
327
339
        else
328
 
            s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
 
340
            s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
329
341
        assert(s->nb_components == 3);
330
342
        break;
331
343
    case 0x11000000:
332
 
        s->avctx->pix_fmt = PIX_FMT_GRAY8;
 
344
        s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
333
345
        break;
334
346
    case 0x12111100:
335
 
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV440P : PIX_FMT_YUVJ440P;
 
347
        s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
336
348
        break;
337
349
    case 0x21111100:
338
 
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
 
350
        s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
339
351
        break;
340
352
    case 0x22111100:
341
 
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
 
353
        s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
342
354
        break;
343
355
    default:
344
356
        av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);
345
 
        return -1;
 
357
        return AVERROR_PATCHWELCOME;
346
358
    }
347
359
    if (s->ls) {
348
360
        if (s->nb_components > 1)
349
 
            s->avctx->pix_fmt = PIX_FMT_RGB24;
 
361
            s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
350
362
        else if (s->bits <= 8)
351
 
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
 
363
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
352
364
        else
353
 
            s->avctx->pix_fmt = PIX_FMT_GRAY16;
 
365
            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
354
366
    }
355
367
 
356
368
    if (s->picture_ptr->data[0])
357
369
        s->avctx->release_buffer(s->avctx, s->picture_ptr);
358
370
 
359
 
    if (s->avctx->get_buffer(s->avctx, s->picture_ptr) < 0) {
 
371
    if (ff_get_buffer(s->avctx, s->picture_ptr) < 0) {
360
372
        av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
361
373
        return -1;
362
374
    }
367
379
    for (i = 0; i < 3; i++)
368
380
        s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
369
381
 
370
 
//    printf("%d %d %d %d %d %d\n",
371
 
//           s->width, s->height, s->linesize[0], s->linesize[1],
372
 
//           s->interlaced, s->avctx->height);
 
382
    av_dlog(s->avctx, "%d %d %d %d %d %d\n",
 
383
            s->width, s->height, s->linesize[0], s->linesize[1],
 
384
            s->interlaced, s->avctx->height);
373
385
 
374
386
    if (len != (8 + (3 * nb_components)))
375
387
        av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
419
431
    val = mjpeg_decode_dc(s, dc_index);
420
432
    if (val == 0xffff) {
421
433
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
422
 
        return -1;
 
434
        return AVERROR_INVALIDDATA;
423
435
    }
424
436
    val = val * quant_matrix[0] + s->last_dc[component];
425
437
    s->last_dc[component] = val;
447
459
 
448
460
            if (i > 63) {
449
461
                av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
450
 
                return -1;
 
462
                return AVERROR_INVALIDDATA;
451
463
            }
452
464
            j        = s->scantable.permutated[i];
453
465
            block[j] = level * quant_matrix[j];
467
479
    val = mjpeg_decode_dc(s, dc_index);
468
480
    if (val == 0xffff) {
469
481
        av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
470
 
        return -1;
 
482
        return AVERROR_INVALIDDATA;
471
483
    }
472
484
    val = (val * quant_matrix[0] << Al) + s->last_dc[component];
473
485
    s->last_dc[component] = val;
516
528
                        break;
517
529
                    }
518
530
                    av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
519
 
                    return -1;
 
531
                    return AVERROR_INVALIDDATA;
520
532
                }
521
533
                j = s->scantable.permutated[i];
522
534
                block[j] = level * quant_matrix[j] << Al;
525
537
                    i += 15;
526
538
                    if (i >= se) {
527
539
                        av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
528
 
                        return -1;
 
540
                        return AVERROR_INVALIDDATA;
529
541
                    }
530
542
                } else {
531
543
                    val = (1 << run);
711
723
}
712
724
 
713
725
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
714
 
                                 int point_transform)
 
726
                                 int point_transform, int nb_components)
715
727
{
716
728
    int i, mb_x, mb_y;
717
 
    const int nb_components = 3;
718
729
 
719
730
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
720
731
        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
800
811
    return 0;
801
812
}
802
813
 
803
 
static av_always_inline void mjpeg_copy_block(uint8_t *dst, const uint8_t *src,
804
 
                                              int linesize, int lowres)
805
 
{
806
 
    switch (lowres) {
807
 
    case 0: copy_block8(dst, src, linesize, linesize, 8);
808
 
        break;
809
 
    case 1: copy_block4(dst, src, linesize, linesize, 4);
810
 
        break;
811
 
    case 2: copy_block2(dst, src, linesize, linesize, 2);
812
 
        break;
813
 
    case 3: *dst = *src;
814
 
        break;
815
 
    }
816
 
}
817
 
 
818
814
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
819
815
                             int Al, const uint8_t *mb_bitmask,
820
816
                             const AVFrame *reference)
860
856
            if (get_bits_left(&s->gb) < 0) {
861
857
                av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
862
858
                       -get_bits_left(&s->gb));
863
 
                return -1;
 
859
                return AVERROR_INVALIDDATA;
864
860
            }
865
861
            for (i = 0; i < nb_components; i++) {
866
862
                uint8_t *ptr;
873
869
                x = 0;
874
870
                y = 0;
875
871
                for (j = 0; j < n; j++) {
876
 
                    block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
877
 
                                     (h * mb_x + x) * 8) >> s->avctx->lowres);
 
872
                    block_offset = ((linesize[c] * (v * mb_y + y) * 8) +
 
873
                                    (h * mb_x + x) * 8);
878
874
 
879
875
                    if (s->interlaced && s->bottom_field)
880
876
                        block_offset += linesize[c] >> 1;
881
877
                    ptr = data[c] + block_offset;
882
878
                    if (!s->progressive) {
883
879
                        if (copy_mb)
884
 
                            mjpeg_copy_block(ptr, reference_data[c] + block_offset,
885
 
                                             linesize[c], s->avctx->lowres);
 
880
                            copy_block8(ptr, reference_data[c] + block_offset,
 
881
                                        linesize[c], linesize[c], 8);
886
882
                        else {
887
883
                            s->dsp.clear_block(s->block);
888
884
                            if (decode_block(s, s->block, i,
890
886
                                             s->quant_matrixes[s->quant_index[c]]) < 0) {
891
887
                                av_log(s->avctx, AV_LOG_ERROR,
892
888
                                       "error y=%d x=%d\n", mb_y, mb_x);
893
 
                                return -1;
 
889
                                return AVERROR_INVALIDDATA;
894
890
                            }
895
891
                            s->dsp.idct_put(ptr, linesize[c], s->block);
896
892
                        }
906
902
                                                       Al) < 0) {
907
903
                            av_log(s->avctx, AV_LOG_ERROR,
908
904
                                   "error y=%d x=%d\n", mb_y, mb_x);
909
 
                            return -1;
 
905
                            return AVERROR_INVALIDDATA;
910
906
                        }
911
907
                    }
912
 
                    // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n",
913
 
                    //        mb_y, mb_x);
914
 
                    // av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n",
915
 
                    //        mb_x, mb_y, x, y, c, s->bottom_field,
916
 
                    //        (v * mb_y + y) * 8, (h * mb_x + x) * 8);
 
908
                    av_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
 
909
                    av_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
 
910
                            mb_x, mb_y, x, y, c, s->bottom_field,
 
911
                            (v * mb_y + y) * 8, (h * mb_x + x) * 8);
917
912
                    if (++x == h) {
918
913
                        x = 0;
919
914
                        y++;
957
952
    int16_t *quant_matrix = s->quant_matrixes[s->quant_index[c]];
958
953
    GetBitContext mb_bitmask_gb;
959
954
 
 
955
    if (ss < 0  || ss >= 64 ||
 
956
        se < ss || se >= 64 ||
 
957
        Ah < 0  || Al < 0)
 
958
        return AVERROR_INVALIDDATA;
 
959
 
960
960
    if (mb_bitmask)
961
961
        init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
962
962
 
972
972
    }
973
973
 
974
974
    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
975
 
        int block_offset = (mb_y * linesize * 8 >> s->avctx->lowres);
 
975
        int block_offset = mb_y * linesize * 8;
976
976
        uint8_t *ptr     = data + block_offset;
977
977
        int block_idx    = mb_y * s->block_stride[c];
978
978
        DCTELEM (*block)[64] = &s->blocks[c][block_idx];
991
991
                if (ret < 0) {
992
992
                    av_log(s->avctx, AV_LOG_ERROR,
993
993
                           "error y=%d x=%d\n", mb_y, mb_x);
994
 
                    return -1;
 
994
                    return AVERROR_INVALIDDATA;
995
995
                }
996
996
            }
997
997
 
998
998
            if (last_scan) {
999
999
                if (copy_mb) {
1000
 
                    mjpeg_copy_block(ptr, reference_data + block_offset,
1001
 
                                     linesize, s->avctx->lowres);
 
1000
                    copy_block8(ptr, reference_data + block_offset,
 
1001
                                linesize, linesize, 8);
1002
1002
                } else {
1003
1003
                    s->dsp.idct_put(ptr, linesize, *block);
1004
 
                    ptr += 8 >> s->avctx->lowres;
 
1004
                    ptr += 8;
1005
1005
                }
1006
1006
            }
1007
1007
        }
1013
1013
                        const AVFrame *reference)
1014
1014
{
1015
1015
    int len, nb_components, i, h, v, predictor, point_transform;
1016
 
    int index, id;
 
1016
    int index, id, ret;
1017
1017
    const int block_size = s->lossless ? 1 : 8;
1018
1018
    int ilv, prev_shift;
1019
1019
 
1023
1023
    if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1024
1024
        av_log(s->avctx, AV_LOG_ERROR,
1025
1025
               "decode_sos: nb_components (%d) unsupported\n", nb_components);
1026
 
        return -1;
 
1026
        return AVERROR_PATCHWELCOME;
1027
1027
    }
1028
1028
    if (len != 6 + 2 * nb_components) {
1029
1029
        av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1030
 
        return -1;
 
1030
        return AVERROR_INVALIDDATA;
1031
1031
    }
1032
1032
    for (i = 0; i < nb_components; i++) {
1033
1033
        id = get_bits(&s->gb, 8) - 1;
1039
1039
        if (index == s->nb_components) {
1040
1040
            av_log(s->avctx, AV_LOG_ERROR,
1041
1041
                   "decode_sos: index(%d) out of components\n", index);
1042
 
            return -1;
 
1042
            return AVERROR_INVALIDDATA;
1043
1043
        }
1044
1044
        /* Metasoft MJPEG codec has Cb and Cr swapped */
1045
1045
        if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1068
1068
    prev_shift      = get_bits(&s->gb, 4); /* Ah */
1069
1069
    point_transform = get_bits(&s->gb, 4); /* Al */
1070
1070
 
1071
 
    for (i = 0; i < nb_components; i++)
1072
 
        s->last_dc[i] = 1024;
1073
 
 
1074
1071
    if (nb_components > 1) {
1075
1072
        /* interleaved stream */
1076
1073
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1096
1093
    for (i = s->mjpb_skiptosod; i > 0; i--)
1097
1094
        skip_bits(&s->gb, 8);
1098
1095
 
 
1096
next_field:
 
1097
    for (i = 0; i < nb_components; i++)
 
1098
        s->last_dc[i] = 1024;
 
1099
 
1099
1100
    if (s->lossless) {
1100
1101
        if (CONFIG_JPEGLS_DECODER && s->ls) {
1101
1102
//            for () {
1102
1103
//            reset_ls_coding_parameters(s, 0);
1103
1104
 
1104
 
            if (ff_jpegls_decode_picture(s, predictor, point_transform, ilv) < 0)
1105
 
                return -1;
 
1105
            if ((ret = ff_jpegls_decode_picture(s, predictor,
 
1106
                                                point_transform, ilv)) < 0)
 
1107
                return ret;
1106
1108
        } else {
1107
1109
            if (s->rgb) {
1108
 
                if (ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1109
 
                    return -1;
 
1110
                if ((ret = ljpeg_decode_rgb_scan(s, predictor,
 
1111
                                                 point_transform)) < 0)
 
1112
                    return ret;
1110
1113
            } else {
1111
 
                if (ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1112
 
                    return -1;
 
1114
                if ((ret = ljpeg_decode_yuv_scan(s, predictor,
 
1115
                                                 point_transform,
 
1116
                                                 nb_components)) < 0)
 
1117
                    return ret;
1113
1118
            }
1114
1119
        }
1115
1120
    } else {
1116
1121
        if (s->progressive && predictor) {
1117
 
            if (mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift,
1118
 
                                                 point_transform,
1119
 
                                                 mb_bitmask, reference) < 0)
1120
 
                return -1;
 
1122
            if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
 
1123
                                                        ilv, prev_shift,
 
1124
                                                        point_transform,
 
1125
                                                        mb_bitmask,
 
1126
                                                        reference)) < 0)
 
1127
                return ret;
1121
1128
        } else {
1122
 
            if (mjpeg_decode_scan(s, nb_components, prev_shift, point_transform,
1123
 
                                  mb_bitmask, reference) < 0)
1124
 
                return -1;
1125
 
        }
1126
 
    }
 
1129
            if ((ret = mjpeg_decode_scan(s, nb_components,
 
1130
                                         prev_shift, point_transform,
 
1131
                                         mb_bitmask, reference)) < 0)
 
1132
                return ret;
 
1133
        }
 
1134
    }
 
1135
 
 
1136
    if (s->interlaced &&
 
1137
        get_bits_left(&s->gb) > 32 &&
 
1138
        show_bits(&s->gb, 8) == 0xFF) {
 
1139
        GetBitContext bak = s->gb;
 
1140
        align_get_bits(&bak);
 
1141
        if (show_bits(&bak, 16) == 0xFFD1) {
 
1142
            av_dlog(s->avctx, "AVRn interlaced picture marker found\n");
 
1143
            s->gb = bak;
 
1144
            skip_bits(&s->gb, 16);
 
1145
            s->bottom_field ^= 1;
 
1146
 
 
1147
            goto next_field;
 
1148
        }
 
1149
    }
 
1150
 
1127
1151
    emms_c();
1128
1152
    return 0;
1129
1153
 out_of_range:
1130
1154
    av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1131
 
    return -1;
 
1155
    return AVERROR_INVALIDDATA;
1132
1156
}
1133
1157
 
1134
1158
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1135
1159
{
1136
1160
    if (get_bits(&s->gb, 16) != 4)
1137
 
        return -1;
 
1161
        return AVERROR_INVALIDDATA;
1138
1162
    s->restart_interval = get_bits(&s->gb, 16);
1139
1163
    s->restart_count    = 0;
1140
1164
    av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1149
1173
 
1150
1174
    len = get_bits(&s->gb, 16);
1151
1175
    if (len < 5)
1152
 
        return -1;
 
1176
        return AVERROR_INVALIDDATA;
1153
1177
    if (8 * len > get_bits_left(&s->gb))
1154
 
        return -1;
 
1178
        return AVERROR_INVALIDDATA;
1155
1179
 
1156
1180
    id   = get_bits_long(&s->gb, 32);
1157
1181
    id   = av_be2ne32(id);
1172
1196
            4bytes      field_size_less_padding
1173
1197
        */
1174
1198
        s->buggy_avid = 1;
1175
 
//      if (s->first_picture)
1176
 
//          printf("mjpeg: workarounding buggy AVID\n");
1177
1199
        i = get_bits(&s->gb, 8);
1178
1200
        if (i == 2)
1179
1201
            s->bottom_field = 1;
1185
1207
        skip_bits(&s->gb, 32);
1186
1208
        len -= 10;
1187
1209
#endif
1188
 
//        if (s->interlace_polarity)
1189
 
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1190
1210
        goto out;
1191
1211
    }
1192
1212
 
1308
1328
            /* buggy avid, it puts EOI only at every 10th frame */
1309
1329
            if (!strcmp(cbuf, "AVID")) {
1310
1330
                s->buggy_avid = 1;
1311
 
                // if (s->first_picture)
1312
 
                // printf("mjpeg: workarounding buggy AVID\n");
1313
1331
            } else if (!strcmp(cbuf, "CS=ITU601"))
1314
1332
                s->cs_itu601 = 1;
1315
1333
            else if ((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) ||
1361
1379
    int start_code;
1362
1380
    start_code = find_marker(buf_ptr, buf_end);
1363
1381
 
1364
 
    if ((buf_end - *buf_ptr) > s->buffer_size) {
1365
 
        av_free(s->buffer);
1366
 
        s->buffer_size = buf_end - *buf_ptr;
1367
 
        s->buffer      = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1368
 
        av_log(s->avctx, AV_LOG_DEBUG,
1369
 
               "buffer too small, expanding to %d bytes\n", s->buffer_size);
1370
 
    }
 
1382
    av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
 
1383
    if (!s->buffer)
 
1384
        return AVERROR(ENOMEM);
1371
1385
 
1372
1386
    /* unescape buffer of SOS, use special treatment for JPEG-LS */
1373
1387
    if (start_code == SOS && !s->ls) {
1378
1392
            uint8_t x = *(src++);
1379
1393
 
1380
1394
            *(dst++) = x;
1381
 
            if (s->avctx->codec_id != CODEC_ID_THP) {
 
1395
            if (s->avctx->codec_id != AV_CODEC_ID_THP) {
1382
1396
                if (x == 0xff) {
1383
1397
                    while (src < buf_end && x == 0xff)
1384
1398
                        x = *(src++);
1392
1406
        }
1393
1407
        *unescaped_buf_ptr  = s->buffer;
1394
1408
        *unescaped_buf_size = dst - s->buffer;
 
1409
        memset(s->buffer + *unescaped_buf_size, 0,
 
1410
               FF_INPUT_BUFFER_PADDING_SIZE);
1395
1411
 
1396
1412
        av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
1397
1413
               (buf_end - *buf_ptr) - (dst - s->buffer));
1433
1449
 
1434
1450
        *unescaped_buf_ptr  = dst;
1435
1451
        *unescaped_buf_size = (bit_count + 7) >> 3;
 
1452
        memset(s->buffer + *unescaped_buf_size, 0,
 
1453
               FF_INPUT_BUFFER_PADDING_SIZE);
1436
1454
    } else {
1437
1455
        *unescaped_buf_ptr  = *buf_ptr;
1438
1456
        *unescaped_buf_size = buf_end - *buf_ptr;
1441
1459
    return start_code;
1442
1460
}
1443
1461
 
1444
 
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
1462
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1445
1463
                          AVPacket *avpkt)
1446
1464
{
1447
1465
    const uint8_t *buf = avpkt->data;
1451
1469
    const uint8_t *unescaped_buf_ptr;
1452
1470
    int unescaped_buf_size;
1453
1471
    int start_code;
 
1472
    int ret = 0;
1454
1473
    AVFrame *picture = data;
1455
1474
 
1456
1475
    s->got_picture = 0; // picture from previous image can not be reused
1464
1483
        /* EOF */
1465
1484
        if (start_code < 0) {
1466
1485
            goto the_end;
1467
 
        } else if (unescaped_buf_size > (1U<<29)) {
1468
 
            av_log(avctx, AV_LOG_ERROR, "MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",
1469
 
                   start_code, unescaped_buf_ptr, buf_size);
 
1486
        } else if (unescaped_buf_size > INT_MAX / 8) {
 
1487
            av_log(avctx, AV_LOG_ERROR,
 
1488
                   "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
 
1489
                   start_code, unescaped_buf_size, buf_size);
1470
1490
            return AVERROR_INVALIDDATA;
1471
1491
        } else {
1472
1492
            av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",
1473
1493
                   start_code, buf_end - buf_ptr);
1474
1494
 
1475
 
            init_get_bits(&s->gb, unescaped_buf_ptr, unescaped_buf_size * 8);
 
1495
            ret = init_get_bits(&s->gb, unescaped_buf_ptr,
 
1496
                                unescaped_buf_size * 8);
 
1497
 
 
1498
            if (ret < 0)
 
1499
                return ret;
1476
1500
 
1477
1501
            s->start_code = start_code;
1478
1502
            if (s->avctx->debug & FF_DEBUG_STARTCODE)
1489
1513
            else if (start_code == COM)
1490
1514
                mjpeg_decode_com(s);
1491
1515
 
 
1516
            if (!CONFIG_JPEGLS_DECODER &&
 
1517
                (start_code == SOF48 || start_code == LSE)) {
 
1518
                av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
 
1519
                return AVERROR(ENOSYS);
 
1520
            }
 
1521
 
1492
1522
            switch (start_code) {
1493
1523
            case SOI:
1494
1524
                s->restart_interval = 0;
1499
1529
                ff_mjpeg_decode_dqt(s);
1500
1530
                break;
1501
1531
            case DHT:
1502
 
                if (ff_mjpeg_decode_dht(s) < 0) {
 
1532
                if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
1503
1533
                    av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
1504
 
                    return -1;
 
1534
                    return ret;
1505
1535
                }
1506
1536
                break;
1507
1537
            case SOF0:
1509
1539
                s->lossless    = 0;
1510
1540
                s->ls          = 0;
1511
1541
                s->progressive = 0;
1512
 
                if (ff_mjpeg_decode_sof(s) < 0)
1513
 
                    return -1;
 
1542
                if ((ret = ff_mjpeg_decode_sof(s)) < 0)
 
1543
                    return ret;
1514
1544
                break;
1515
1545
            case SOF2:
1516
1546
                s->lossless    = 0;
1517
1547
                s->ls          = 0;
1518
1548
                s->progressive = 1;
1519
 
                if (ff_mjpeg_decode_sof(s) < 0)
1520
 
                    return -1;
 
1549
                if ((ret = ff_mjpeg_decode_sof(s)) < 0)
 
1550
                    return ret;
1521
1551
                break;
1522
1552
            case SOF3:
1523
1553
                s->lossless    = 1;
1524
1554
                s->ls          = 0;
1525
1555
                s->progressive = 0;
1526
 
                if (ff_mjpeg_decode_sof(s) < 0)
1527
 
                    return -1;
 
1556
                if ((ret = ff_mjpeg_decode_sof(s)) < 0)
 
1557
                    return ret;
1528
1558
                break;
1529
1559
            case SOF48:
1530
1560
                s->lossless    = 1;
1531
1561
                s->ls          = 1;
1532
1562
                s->progressive = 0;
1533
 
                if (ff_mjpeg_decode_sof(s) < 0)
1534
 
                    return -1;
 
1563
                if ((ret = ff_mjpeg_decode_sof(s)) < 0)
 
1564
                    return ret;
1535
1565
                break;
1536
1566
            case LSE:
1537
 
                if (!CONFIG_JPEGLS_DECODER || ff_jpegls_decode_lse(s) < 0)
1538
 
                    return -1;
 
1567
                if (!CONFIG_JPEGLS_DECODER ||
 
1568
                    (ret = ff_jpegls_decode_lse(s)) < 0)
 
1569
                    return ret;
1539
1570
                break;
1540
1571
            case EOI:
1541
1572
                s->cur_scan = 0;
1554
1585
                        goto not_the_end;
1555
1586
                    }
1556
1587
                    *picture   = *s->picture_ptr;
1557
 
                    *data_size = sizeof(AVFrame);
 
1588
                    *got_frame = 1;
1558
1589
 
1559
1590
                    if (!s->lossless) {
1560
1591
                        picture->quality      = FFMAX3(s->qscale[0],
1577
1608
                           "Can not process SOS before SOF, skipping\n");
1578
1609
                    break;
1579
1610
                    }
1580
 
                if (ff_mjpeg_decode_sos(s, NULL, NULL) < 0 &&
 
1611
                if ((ret = ff_mjpeg_decode_sos(s, NULL, NULL)) < 0 &&
1581
1612
                    (avctx->err_recognition & AV_EF_EXPLODE))
1582
 
                    return AVERROR_INVALIDDATA;
 
1613
                    return ret;
1583
1614
                /* buggy avid puts EOI every 10-20th frame */
1584
1615
                /* if restart period is over process EOI */
1585
1616
                if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1601
1632
                av_log(avctx, AV_LOG_ERROR,
1602
1633
                       "mjpeg: unsupported coding type (%x)\n", start_code);
1603
1634
                break;
1604
 
//              default:
1605
 
//              printf("mjpeg: unsupported marker (%x)\n", start_code);
1606
 
//              break;
1607
1635
            }
1608
1636
 
1609
1637
not_the_end:
1619
1647
        goto eoi_parser;
1620
1648
    }
1621
1649
    av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
1622
 
    return -1;
 
1650
    return AVERROR_INVALIDDATA;
1623
1651
the_end:
1624
1652
    av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n",
1625
1653
           buf_end - buf_ptr);
1655
1683
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1656
1684
static const AVOption options[] = {
1657
1685
    { "extern_huff", "Use external huffman table.",
1658
 
      OFFSET(extern_huff), AV_OPT_TYPE_INT, { 0 }, 0, 1, VD },
 
1686
      OFFSET(extern_huff), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
1659
1687
    { NULL },
1660
1688
};
1661
1689
 
1669
1697
AVCodec ff_mjpeg_decoder = {
1670
1698
    .name           = "mjpeg",
1671
1699
    .type           = AVMEDIA_TYPE_VIDEO,
1672
 
    .id             = CODEC_ID_MJPEG,
 
1700
    .id             = AV_CODEC_ID_MJPEG,
1673
1701
    .priv_data_size = sizeof(MJpegDecodeContext),
1674
1702
    .init           = ff_mjpeg_decode_init,
1675
1703
    .close          = ff_mjpeg_decode_end,
1676
1704
    .decode         = ff_mjpeg_decode_frame,
1677
1705
    .capabilities   = CODEC_CAP_DR1,
1678
 
    .max_lowres     = 3,
1679
1706
    .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
1680
1707
    .priv_class     = &mjpegdec_class,
1681
1708
};
1683
1710
AVCodec ff_thp_decoder = {
1684
1711
    .name           = "thp",
1685
1712
    .type           = AVMEDIA_TYPE_VIDEO,
1686
 
    .id             = CODEC_ID_THP,
 
1713
    .id             = AV_CODEC_ID_THP,
1687
1714
    .priv_data_size = sizeof(MJpegDecodeContext),
1688
1715
    .init           = ff_mjpeg_decode_init,
1689
1716
    .close          = ff_mjpeg_decode_end,
1690
1717
    .decode         = ff_mjpeg_decode_frame,
1691
1718
    .capabilities   = CODEC_CAP_DR1,
1692
 
    .max_lowres     = 3,
1693
1719
    .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
1694
1720
};