← Back to branch summary

~siretart/libav/merge.raring.libav-0.8.6

« back to all changes in this revision

Viewing changes to libavcodec/flicvideo.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:30:00 UTC
  • mfrom: (1.4.1)
  • mto: (1.3.11 sid) (26.1.1 quantal-security)
  • mto: This revision was merged to the branch mainline in revision 15.
  • Revision ID: package-import@ubuntu.com-20120112223000-s1reiy1e28hnix42
Tags: upstream-0.8~beta2
Import upstream version 0.8~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/flicvideo.c
41
41
 
42
42
#include "libavutil/intreadwrite.h"
43
43
#include "avcodec.h"
 
44
#include "bytestream.h"
 
45
#include "mathops.h"
44
46
 
45
47
#define FLI_256_COLOR 4
46
48
#define FLI_DELTA     7
81
83
    unsigned char *fli_header = (unsigned char *)avctx->extradata;
82
84
    int depth;
83
85
 
 
86
    if (avctx->extradata_size != 12 &&
 
87
        avctx->extradata_size != 128) {
 
88
        av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n");
 
89
        return AVERROR_INVALIDDATA;
 
90
    }
 
91
 
84
92
    s->avctx = avctx;
85
93
 
86
94
    s->fli_type = AV_RL16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */
90
98
        /* special case for magic carpet FLIs */
91
99
        s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE;
92
100
        depth = 8;
93
 
    } else if (s->avctx->extradata_size != 128) {
94
 
        av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n");
95
 
        return -1;
96
101
    } else {
97
102
        depth = AV_RL16(&fli_header[12]);
98
103
    }
112
117
        case 24 : avctx->pix_fmt = PIX_FMT_BGR24; /* Supposedly BGR, but havent any files to test with */
113
118
                  av_log(avctx, AV_LOG_ERROR, "24Bpp FLC/FLX is unsupported due to no test files.\n");
114
119
                  return -1;
115
 
                  break;
116
120
        default :
117
121
                  av_log(avctx, AV_LOG_ERROR, "Unknown FLC/FLX depth of %d Bpp is unsupported.\n",depth);
118
122
                  return -1;
130
134
{
131
135
    FlicDecodeContext *s = avctx->priv_data;
132
136
 
133
 
    int stream_ptr = 0;
 
137
    GetByteContext g2;
134
138
    int stream_ptr_after_color_chunk;
135
139
    int pixel_ptr;
136
140
    int palette_ptr;
161
165
    unsigned char *pixels;
162
166
    unsigned int pixel_limit;
163
167
 
 
168
    bytestream2_init(&g2, buf, buf_size);
 
169
 
164
170
    s->frame.reference = 1;
165
171
    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
166
172
    if (avctx->reget_buffer(avctx, &s->frame) < 0) {
170
176
 
171
177
    pixels = s->frame.data[0];
172
178
    pixel_limit = s->avctx->height * s->frame.linesize[0];
173
 
 
174
 
    frame_size = AV_RL32(&buf[stream_ptr]);
175
 
    stream_ptr += 6;  /* skip the magic number */
176
 
    num_chunks = AV_RL16(&buf[stream_ptr]);
177
 
    stream_ptr += 10;  /* skip padding */
 
179
    frame_size = bytestream2_get_le32(&g2);
 
180
    bytestream2_skip(&g2, 2); /* skip the magic number */
 
181
    num_chunks = bytestream2_get_le16(&g2);
 
182
    bytestream2_skip(&g2, 8);  /* skip padding */
178
183
 
179
184
    frame_size -= 16;
180
185
 
181
186
    /* iterate through the chunks */
182
187
    while ((frame_size > 0) && (num_chunks > 0)) {
183
 
        chunk_size = AV_RL32(&buf[stream_ptr]);
184
 
        stream_ptr += 4;
185
 
        chunk_type = AV_RL16(&buf[stream_ptr]);
186
 
        stream_ptr += 2;
 
188
        chunk_size = bytestream2_get_le32(&g2);
 
189
        chunk_type = bytestream2_get_le16(&g2);
187
190
 
188
191
        switch (chunk_type) {
189
192
        case FLI_256_COLOR:
190
193
        case FLI_COLOR:
191
 
            stream_ptr_after_color_chunk = stream_ptr + chunk_size - 6;
 
194
            stream_ptr_after_color_chunk = bytestream2_tell(&g2) + chunk_size - 6;
192
195
 
193
196
            /* check special case: If this file is from the Magic Carpet
194
197
             * game and uses 6-bit colors even though it reports 256-color
199
202
            else
200
203
                color_shift = 2;
201
204
            /* set up the palette */
202
 
            color_packets = AV_RL16(&buf[stream_ptr]);
203
 
            stream_ptr += 2;
 
205
            color_packets = bytestream2_get_le16(&g2);
204
206
            palette_ptr = 0;
205
207
            for (i = 0; i < color_packets; i++) {
206
208
                /* first byte is how many colors to skip */
207
 
                palette_ptr += buf[stream_ptr++];
 
209
                palette_ptr += bytestream2_get_byte(&g2);
208
210
 
209
211
                /* next byte indicates how many entries to change */
210
 
                color_changes = buf[stream_ptr++];
 
212
                color_changes = bytestream2_get_byte(&g2);
211
213
 
212
214
                /* if there are 0 color changes, there are actually 256 */
213
215
                if (color_changes == 0)
220
222
                    if ((unsigned)palette_ptr >= 256)
221
223
                        palette_ptr = 0;
222
224
 
223
 
                    r = buf[stream_ptr++] << color_shift;
224
 
                    g = buf[stream_ptr++] << color_shift;
225
 
                    b = buf[stream_ptr++] << color_shift;
 
225
                    r = bytestream2_get_byte(&g2) << color_shift;
 
226
                    g = bytestream2_get_byte(&g2) << color_shift;
 
227
                    b = bytestream2_get_byte(&g2) << color_shift;
226
228
                    entry = (r << 16) | (g << 8) | b;
227
229
                    if (s->palette[palette_ptr] != entry)
228
230
                        s->new_palette = 1;
231
233
            }
232
234
 
233
235
            /* color chunks sometimes have weird 16-bit alignment issues;
234
 
             * therefore, take the hardline approach and set the stream_ptr
 
236
             * therefore, take the hardline approach and skip
235
237
             * to the value calculated w.r.t. the size specified by the color
236
238
             * chunk header */
237
 
            stream_ptr = stream_ptr_after_color_chunk;
 
239
            if (stream_ptr_after_color_chunk - bytestream2_tell(&g2) > 0)
 
240
                bytestream2_skip(&g2, stream_ptr_after_color_chunk - bytestream2_tell(&g2));
238
241
 
239
242
            break;
240
243
 
241
244
        case FLI_DELTA:
242
245
            y_ptr = 0;
243
 
            compressed_lines = AV_RL16(&buf[stream_ptr]);
244
 
            stream_ptr += 2;
 
246
            compressed_lines = bytestream2_get_le16(&g2);
245
247
            while (compressed_lines > 0) {
246
 
                line_packets = AV_RL16(&buf[stream_ptr]);
247
 
                stream_ptr += 2;
 
248
                line_packets = bytestream2_get_le16(&g2);
248
249
                if ((line_packets & 0xC000) == 0xC000) {
249
250
                    // line skip opcode
250
251
                    line_packets = -line_packets;
263
264
                    pixel_countdown = s->avctx->width;
264
265
                    for (i = 0; i < line_packets; i++) {
265
266
                        /* account for the skip bytes */
266
 
                        pixel_skip = buf[stream_ptr++];
 
267
                        pixel_skip = bytestream2_get_byte(&g2);
267
268
                        pixel_ptr += pixel_skip;
268
269
                        pixel_countdown -= pixel_skip;
269
 
                        byte_run = (signed char)(buf[stream_ptr++]);
 
270
                        byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
270
271
                        if (byte_run < 0) {
271
272
                            byte_run = -byte_run;
272
 
                            palette_idx1 = buf[stream_ptr++];
273
 
                            palette_idx2 = buf[stream_ptr++];
 
273
                            palette_idx1 = bytestream2_get_byte(&g2);
 
274
                            palette_idx2 = bytestream2_get_byte(&g2);
274
275
                            CHECK_PIXEL_PTR(byte_run * 2);
275
276
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
276
277
                                pixels[pixel_ptr++] = palette_idx1;
279
280
                        } else {
280
281
                            CHECK_PIXEL_PTR(byte_run * 2);
281
282
                            for (j = 0; j < byte_run * 2; j++, pixel_countdown--) {
282
 
                                palette_idx1 = buf[stream_ptr++];
283
 
                                pixels[pixel_ptr++] = palette_idx1;
 
283
                                pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
284
284
                            }
285
285
                        }
286
286
                    }
292
292
 
293
293
        case FLI_LC:
294
294
            /* line compressed */
295
 
            starting_line = AV_RL16(&buf[stream_ptr]);
296
 
            stream_ptr += 2;
 
295
            starting_line = bytestream2_get_le16(&g2);
297
296
            y_ptr = 0;
298
297
            y_ptr += starting_line * s->frame.linesize[0];
299
298
 
300
 
            compressed_lines = AV_RL16(&buf[stream_ptr]);
301
 
            stream_ptr += 2;
 
299
            compressed_lines = bytestream2_get_le16(&g2);
302
300
            while (compressed_lines > 0) {
303
301
                pixel_ptr = y_ptr;
304
302
                CHECK_PIXEL_PTR(0);
305
303
                pixel_countdown = s->avctx->width;
306
 
                line_packets = buf[stream_ptr++];
 
304
                line_packets = bytestream2_get_byte(&g2);
307
305
                if (line_packets > 0) {
308
306
                    for (i = 0; i < line_packets; i++) {
309
307
                        /* account for the skip bytes */
310
 
                        pixel_skip = buf[stream_ptr++];
 
308
                        pixel_skip = bytestream2_get_byte(&g2);
311
309
                        pixel_ptr += pixel_skip;
312
310
                        pixel_countdown -= pixel_skip;
313
 
                        byte_run = (signed char)(buf[stream_ptr++]);
 
311
                        byte_run = sign_extend(bytestream2_get_byte(&g2),8);
314
312
                        if (byte_run > 0) {
315
313
                            CHECK_PIXEL_PTR(byte_run);
316
314
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
317
 
                                palette_idx1 = buf[stream_ptr++];
318
 
                                pixels[pixel_ptr++] = palette_idx1;
 
315
                                pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
319
316
                            }
320
317
                        } else if (byte_run < 0) {
321
318
                            byte_run = -byte_run;
322
 
                            palette_idx1 = buf[stream_ptr++];
 
319
                            palette_idx1 = bytestream2_get_byte(&g2);
323
320
                            CHECK_PIXEL_PTR(byte_run);
324
321
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
325
322
                                pixels[pixel_ptr++] = palette_idx1;
347
344
                pixel_ptr = y_ptr;
348
345
                /* disregard the line packets; instead, iterate through all
349
346
                 * pixels on a row */
350
 
                stream_ptr++;
 
347
                 bytestream2_skip(&g2, 1);
351
348
                pixel_countdown = s->avctx->width;
352
349
                while (pixel_countdown > 0) {
353
 
                    byte_run = (signed char)(buf[stream_ptr++]);
 
350
                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
354
351
                    if (byte_run > 0) {
355
 
                        palette_idx1 = buf[stream_ptr++];
 
352
                        palette_idx1 = bytestream2_get_byte(&g2);
356
353
                        CHECK_PIXEL_PTR(byte_run);
357
354
                        for (j = 0; j < byte_run; j++) {
358
355
                            pixels[pixel_ptr++] = palette_idx1;
365
362
                        byte_run = -byte_run;
366
363
                        CHECK_PIXEL_PTR(byte_run);
367
364
                        for (j = 0; j < byte_run; j++) {
368
 
                            palette_idx1 = buf[stream_ptr++];
369
 
                            pixels[pixel_ptr++] = palette_idx1;
 
365
                            pixels[pixel_ptr++] = bytestream2_get_byte(&g2);
370
366
                            pixel_countdown--;
371
367
                            if (pixel_countdown < 0)
372
368
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
384
380
            if (chunk_size - 6 > s->avctx->width * s->avctx->height) {
385
381
                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
386
382
                       "bigger than image, skipping chunk\n", chunk_size - 6);
387
 
                stream_ptr += chunk_size - 6;
 
383
                bytestream2_skip(&g2, chunk_size - 6);
388
384
            } else {
389
385
                for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;
390
386
                     y_ptr += s->frame.linesize[0]) {
391
 
                    memcpy(&pixels[y_ptr], &buf[stream_ptr],
392
 
                        s->avctx->width);
393
 
                    stream_ptr += s->avctx->width;
 
387
                    bytestream2_get_buffer(&g2, &pixels[y_ptr],
 
388
                                           s->avctx->width);
394
389
                }
395
390
            }
396
391
            break;
397
392
 
398
393
        case FLI_MINI:
399
394
            /* some sort of a thumbnail? disregard this chunk... */
400
 
            stream_ptr += chunk_size - 6;
 
395
            bytestream2_skip(&g2, chunk_size - 6);
401
396
            break;
402
397
 
403
398
        default:
411
406
 
412
407
    /* by the end of the chunk, the stream ptr should equal the frame
413
408
     * size (minus 1, possibly); if it doesn't, issue a warning */
414
 
    if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))
 
409
    if ((bytestream2_get_bytes_left(&g2) != 0) &&
 
410
        (bytestream2_get_bytes_left(&g2) != 1))
415
411
        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
416
 
               "and final chunk ptr = %d\n", buf_size, stream_ptr);
 
412
               "and final chunk ptr = %d\n", buf_size,
 
413
               buf_size - bytestream2_get_bytes_left(&g2));
417
414
 
418
415
    /* make the palette available on the way out */
419
416
    memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);
436
433
    /* Format is the pixel format, the packets are processed the same. */
437
434
    FlicDecodeContext *s = avctx->priv_data;
438
435
 
439
 
    int stream_ptr = 0;
 
436
    GetByteContext g2;
440
437
    int pixel_ptr;
441
438
    unsigned char palette_idx1;
442
439
 
459
456
    int pixel;
460
457
    unsigned int pixel_limit;
461
458
 
 
459
    bytestream2_init(&g2, buf, buf_size);
 
460
 
462
461
    s->frame.reference = 1;
463
462
    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
464
463
    if (avctx->reget_buffer(avctx, &s->frame) < 0) {
469
468
    pixels = s->frame.data[0];
470
469
    pixel_limit = s->avctx->height * s->frame.linesize[0];
471
470
 
472
 
    frame_size = AV_RL32(&buf[stream_ptr]);
473
 
    stream_ptr += 6;  /* skip the magic number */
474
 
    num_chunks = AV_RL16(&buf[stream_ptr]);
475
 
    stream_ptr += 10;  /* skip padding */
 
471
    frame_size = bytestream2_get_le32(&g2);
 
472
    bytestream2_skip(&g2, 2);  /* skip the magic number */
 
473
    num_chunks = bytestream2_get_le16(&g2);
 
474
    bytestream2_skip(&g2, 8);  /* skip padding */
476
475
 
477
476
    frame_size -= 16;
478
477
 
479
478
    /* iterate through the chunks */
480
479
    while ((frame_size > 0) && (num_chunks > 0)) {
481
 
        chunk_size = AV_RL32(&buf[stream_ptr]);
482
 
        stream_ptr += 4;
483
 
        chunk_type = AV_RL16(&buf[stream_ptr]);
484
 
        stream_ptr += 2;
 
480
        chunk_size = bytestream2_get_le32(&g2);
 
481
        chunk_type = bytestream2_get_le16(&g2);
485
482
 
486
483
        switch (chunk_type) {
487
484
        case FLI_256_COLOR:
490
487
             * include one of these chunks in their first frame.
491
488
             * Why I do not know, it seems rather extraneous. */
492
489
/*            av_log(avctx, AV_LOG_ERROR, "Unexpected Palette chunk %d in non-paletised FLC\n",chunk_type);*/
493
 
            stream_ptr = stream_ptr + chunk_size - 6;
 
490
            bytestream2_skip(&g2, chunk_size - 6);
494
491
            break;
495
492
 
496
493
        case FLI_DELTA:
497
494
        case FLI_DTA_LC:
498
495
            y_ptr = 0;
499
 
            compressed_lines = AV_RL16(&buf[stream_ptr]);
500
 
            stream_ptr += 2;
 
496
            compressed_lines = bytestream2_get_le16(&g2);
501
497
            while (compressed_lines > 0) {
502
 
                line_packets = AV_RL16(&buf[stream_ptr]);
503
 
                stream_ptr += 2;
 
498
                line_packets = bytestream2_get_le16(&g2);
504
499
                if (line_packets < 0) {
505
500
                    line_packets = -line_packets;
506
501
                    y_ptr += line_packets * s->frame.linesize[0];
511
506
                    pixel_countdown = s->avctx->width;
512
507
                    for (i = 0; i < line_packets; i++) {
513
508
                        /* account for the skip bytes */
514
 
                        pixel_skip = buf[stream_ptr++];
 
509
                        pixel_skip = bytestream2_get_byte(&g2);
515
510
                        pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */
516
511
                        pixel_countdown -= pixel_skip;
517
 
                        byte_run = (signed char)(buf[stream_ptr++]);
 
512
                        byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
518
513
                        if (byte_run < 0) {
519
514
                            byte_run = -byte_run;
520
 
                            pixel    = AV_RL16(&buf[stream_ptr]);
521
 
                            stream_ptr += 2;
 
515
                            pixel    = bytestream2_get_le16(&g2);
522
516
                            CHECK_PIXEL_PTR(2 * byte_run);
523
517
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
524
518
                                *((signed short*)(&pixels[pixel_ptr])) = pixel;
527
521
                        } else {
528
522
                            CHECK_PIXEL_PTR(2 * byte_run);
529
523
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
530
 
                                *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
531
 
                                stream_ptr += 2;
 
524
                                *((signed short*)(&pixels[pixel_ptr])) = bytestream2_get_le16(&g2);
532
525
                                pixel_ptr += 2;
533
526
                            }
534
527
                        }
541
534
 
542
535
        case FLI_LC:
543
536
            av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-paletised FLC\n");
544
 
            stream_ptr = stream_ptr + chunk_size - 6;
 
537
            bytestream2_skip(&g2, chunk_size - 6);
545
538
            break;
546
539
 
547
540
        case FLI_BLACK:
556
549
                pixel_ptr = y_ptr;
557
550
                /* disregard the line packets; instead, iterate through all
558
551
                 * pixels on a row */
559
 
                stream_ptr++;
 
552
                bytestream2_skip(&g2, 1);
560
553
                pixel_countdown = (s->avctx->width * 2);
561
554
 
562
555
                while (pixel_countdown > 0) {
563
 
                    byte_run = (signed char)(buf[stream_ptr++]);
 
556
                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
564
557
                    if (byte_run > 0) {
565
 
                        palette_idx1 = buf[stream_ptr++];
 
558
                        palette_idx1 = bytestream2_get_byte(&g2);
566
559
                        CHECK_PIXEL_PTR(byte_run);
567
560
                        for (j = 0; j < byte_run; j++) {
568
561
                            pixels[pixel_ptr++] = palette_idx1;
575
568
                        byte_run = -byte_run;
576
569
                        CHECK_PIXEL_PTR(byte_run);
577
570
                        for (j = 0; j < byte_run; j++) {
578
 
                            palette_idx1 = buf[stream_ptr++];
 
571
                            palette_idx1 = bytestream2_get_byte(&g2);
579
572
                            pixels[pixel_ptr++] = palette_idx1;
580
573
                            pixel_countdown--;
581
574
                            if (pixel_countdown < 0)
608
601
                pixel_ptr = y_ptr;
609
602
                /* disregard the line packets; instead, iterate through all
610
603
                 * pixels on a row */
611
 
                stream_ptr++;
 
604
                bytestream2_skip(&g2, 1);
612
605
                pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */
613
606
 
614
607
                while (pixel_countdown > 0) {
615
 
                    byte_run = (signed char)(buf[stream_ptr++]);
 
608
                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
616
609
                    if (byte_run > 0) {
617
 
                        pixel    = AV_RL16(&buf[stream_ptr]);
618
 
                        stream_ptr += 2;
 
610
                        pixel    = bytestream2_get_le16(&g2);
619
611
                        CHECK_PIXEL_PTR(2 * byte_run);
620
612
                        for (j = 0; j < byte_run; j++) {
621
613
                            *((signed short*)(&pixels[pixel_ptr])) = pixel;
629
621
                        byte_run = -byte_run;
630
622
                        CHECK_PIXEL_PTR(2 * byte_run);
631
623
                        for (j = 0; j < byte_run; j++) {
632
 
                            *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
633
 
                            stream_ptr += 2;
 
624
                            *((signed short*)(&pixels[pixel_ptr])) = bytestream2_get_le16(&g2);
634
625
                            pixel_ptr  += 2;
635
626
                            pixel_countdown--;
636
627
                            if (pixel_countdown < 0)
650
641
            if (chunk_size - 6 > (unsigned int)(s->avctx->width * s->avctx->height)*2) {
651
642
                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
652
643
                       "bigger than image, skipping chunk\n", chunk_size - 6);
653
 
                stream_ptr += chunk_size - 6;
 
644
                bytestream2_skip(&g2, chunk_size - 6);
654
645
            } else {
655
646
 
656
647
                for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;
659
650
                    pixel_countdown = s->avctx->width;
660
651
                    pixel_ptr = 0;
661
652
                    while (pixel_countdown > 0) {
662
 
                      *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]);
 
653
                      *((signed short*)(&pixels[y_ptr + pixel_ptr])) = bytestream2_get_le16(&g2);
663
654
                      pixel_ptr += 2;
664
655
                      pixel_countdown--;
665
656
                    }
666
 
                    stream_ptr += s->avctx->width*2;
667
657
                }
668
658
            }
669
659
            break;
670
660
 
671
661
        case FLI_MINI:
672
662
            /* some sort of a thumbnail? disregard this chunk... */
673
 
            stream_ptr += chunk_size - 6;
 
663
            bytestream2_skip(&g2, chunk_size - 6);
674
664
            break;
675
665
 
676
666
        default:
684
674
 
685
675
    /* by the end of the chunk, the stream ptr should equal the frame
686
676
     * size (minus 1, possibly); if it doesn't, issue a warning */
687
 
    if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))
 
677
    if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1))
688
678
        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
689
 
               "and final chunk ptr = %d\n", buf_size, stream_ptr);
 
679
               "and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2));
690
680
 
691
681
 
692
682
    *data_size=sizeof(AVFrame);
743
733
}
744
734
 
745
735
AVCodec ff_flic_decoder = {
746
 
    "flic",
747
 
    AVMEDIA_TYPE_VIDEO,
748
 
    CODEC_ID_FLIC,
749
 
    sizeof(FlicDecodeContext),
750
 
    flic_decode_init,
751
 
    NULL,
752
 
    flic_decode_end,
753
 
    flic_decode_frame,
754
 
    CODEC_CAP_DR1,
755
 
    NULL,
756
 
    NULL,
757
 
    NULL,
758
 
    NULL,
 
736
    .name           = "flic",
 
737
    .type           = AVMEDIA_TYPE_VIDEO,
 
738
    .id             = CODEC_ID_FLIC,
 
739
    .priv_data_size = sizeof(FlicDecodeContext),
 
740
    .init           = flic_decode_init,
 
741
    .close          = flic_decode_end,
 
742
    .decode         = flic_decode_frame,
 
743
    .capabilities   = CODEC_CAP_DR1,
759
744
    .long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"),
760
745
};