← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/zmbv.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20081226001006-wd8cuqn8d81smkdp
Tags: upstream-1.1.7
Import upstream version 1.1.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/zmbv.c
17
17
 * You should have received a copy of the GNU Lesser General Public
18
18
 * License along with FFmpeg; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 
 *
21
20
 */
22
21
 
23
22
/**
28
27
#include <stdio.h>
29
28
#include <stdlib.h>
30
29
 
31
 
#include "common.h"
32
30
#include "avcodec.h"
33
31
 
34
 
#ifdef CONFIG_ZLIB
35
32
#include <zlib.h>
36
 
#endif
37
33
 
38
34
#define ZMBV_KEYFRAME 1
39
35
#define ZMBV_DELTAPAL 2
68
64
    int flags;
69
65
    int bw, bh, bx, by;
70
66
    int decomp_len;
71
 
#ifdef CONFIG_ZLIB
72
67
    z_stream zstream;
73
 
#endif
74
68
    int (*decode_intra)(struct ZmbvContext *c);
75
69
    int (*decode_xor)(struct ZmbvContext *c);
76
70
} ZmbvContext;
147
141
        prev += c->width * c->bh;
148
142
    }
149
143
    if(src - c->decomp_buf != c->decomp_len)
150
 
        av_log(c->avctx, AV_LOG_ERROR, "Used %i of %i bytes\n", src-c->decomp_buf, c->decomp_len);
 
144
        av_log(c->avctx, AV_LOG_ERROR, "Used %ti of %i bytes\n", src-c->decomp_buf, c->decomp_len);
151
145
    return 0;
152
146
}
153
147
 
220
214
        prev += c->width * c->bh;
221
215
    }
222
216
    if(src - c->decomp_buf != c->decomp_len)
223
 
        av_log(c->avctx, AV_LOG_ERROR, "Used %i of %i bytes\n", src-c->decomp_buf, c->decomp_len);
 
217
        av_log(c->avctx, AV_LOG_ERROR, "Used %ti of %i bytes\n", src-c->decomp_buf, c->decomp_len);
224
218
    return 0;
225
219
}
226
220
 
376
370
        prev += c->width * c->bh;
377
371
    }
378
372
    if(src - c->decomp_buf != c->decomp_len)
379
 
        av_log(c->avctx, AV_LOG_ERROR, "Used %i of %i bytes\n", src-c->decomp_buf, c->decomp_len);
 
373
        av_log(c->avctx, AV_LOG_ERROR, "Used %ti of %i bytes\n", src-c->decomp_buf, c->decomp_len);
380
374
    return 0;
381
375
}
382
376
 
397
391
    return 0;
398
392
}
399
393
 
400
 
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size)
 
394
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size)
401
395
{
402
 
    ZmbvContext * const c = (ZmbvContext *)avctx->priv_data;
 
396
    ZmbvContext * const c = avctx->priv_data;
403
397
    uint8_t *outptr;
404
 
#ifdef CONFIG_ZLIB
405
398
    int zret = Z_OK; // Zlib return code
406
 
#endif
407
399
    int len = buf_size;
408
400
    int hi_ver, lo_ver;
409
401
 
475
467
            av_log(avctx, AV_LOG_ERROR, "Unsupported (for now) format %i\n", c->fmt);
476
468
            return -1;
477
469
        }
478
 
#ifdef CONFIG_ZLIB
 
470
 
479
471
        zret = inflateReset(&c->zstream);
480
472
        if (zret != Z_OK) {
481
473
            av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
482
474
            return -1;
483
475
        }
484
 
#else
485
 
        av_log(avctx, AV_LOG_ERROR, "BUG! Zlib support not compiled in frame decoder.\n");
486
 
        return -1;
487
 
#endif  /* CONFIG_ZLIB */
 
476
 
488
477
        c->cur = av_realloc(c->cur, avctx->width * avctx->height * (c->bpp / 8));
489
478
        c->prev = av_realloc(c->prev, avctx->width * avctx->height * (c->bpp / 8));
490
479
        c->bx = (c->width + c->bw - 1) / c->bw;
500
489
        memcpy(c->decomp_buf, buf, len);
501
490
        c->decomp_size = 1;
502
491
    } else { // ZLIB-compressed data
503
 
#ifdef CONFIG_ZLIB
504
492
        c->zstream.total_in = c->zstream.total_out = 0;
505
493
        c->zstream.next_in = buf;
506
494
        c->zstream.avail_in = len;
508
496
        c->zstream.avail_out = c->decomp_size;
509
497
        inflate(&c->zstream, Z_FINISH);
510
498
        c->decomp_len = c->zstream.total_out;
511
 
#else
512
 
        av_log(avctx, AV_LOG_ERROR, "BUG! Zlib support not compiled in frame decoder.\n");
513
 
        return -1;
514
 
#endif
515
499
    }
516
500
    if(c->flags & ZMBV_KEYFRAME) {
517
501
        c->pic.key_frame = 1;
520
504
    } else {
521
505
        c->pic.key_frame = 0;
522
506
        c->pic.pict_type = FF_P_TYPE;
523
 
        c->decode_xor(c);
 
507
        if(c->decomp_len)
 
508
            c->decode_xor(c);
524
509
    }
525
510
 
526
511
    /* update frames */
537
522
                    out[i * 3 + 0] = c->pal[(*src) * 3 + 0];
538
523
                    out[i * 3 + 1] = c->pal[(*src) * 3 + 1];
539
524
                    out[i * 3 + 2] = c->pal[(*src) * 3 + 2];
540
 
                    *src++;
 
525
                    src++;
541
526
                }
542
527
                out += c->pic.linesize[0];
543
528
            }
580
565
                for(i = 0; i < c->width; i++) {
581
566
                    uint32_t tmp = AV_RL32(src);
582
567
                    src += 4;
583
 
                    out[i * 3 + 0] = tmp >> 16;
584
 
                    out[i * 3 + 1] = tmp >> 8;
585
 
                    out[i * 3 + 2] = tmp >> 0;
 
568
                    AV_WB24(out+(i*3), tmp);
586
569
                }
587
570
                out += c->pic.linesize[0];
588
571
            }
606
589
 * Init zmbv decoder
607
590
 *
608
591
 */
609
 
static int decode_init(AVCodecContext *avctx)
 
592
static av_cold int decode_init(AVCodecContext *avctx)
610
593
{
611
 
    ZmbvContext * const c = (ZmbvContext *)avctx->priv_data;
 
594
    ZmbvContext * const c = avctx->priv_data;
612
595
    int zret; // Zlib return code
613
596
 
614
597
    c->avctx = avctx;
615
 
    avctx->has_b_frames = 0;
616
598
 
617
599
    c->pic.data[0] = NULL;
618
600
    c->width = avctx->width;
623
605
    }
624
606
    c->bpp = avctx->bits_per_sample;
625
607
 
626
 
#ifdef CONFIG_ZLIB
627
608
    // Needed if zlib unused or init aborted before inflateInit
628
609
    memset(&(c->zstream), 0, sizeof(z_stream));
629
 
#else
630
 
    av_log(avctx, AV_LOG_ERROR, "Zlib support not compiled.\n");
631
 
    return 1;
632
 
#endif
 
610
 
633
611
    avctx->pix_fmt = PIX_FMT_RGB24;
634
612
    c->decomp_size = (avctx->width + 255) * 4 * (avctx->height + 64);
635
613
 
641
619
        }
642
620
    }
643
621
 
644
 
#ifdef CONFIG_ZLIB
645
622
    c->zstream.zalloc = Z_NULL;
646
623
    c->zstream.zfree = Z_NULL;
647
624
    c->zstream.opaque = Z_NULL;
650
627
        av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
651
628
        return 1;
652
629
    }
653
 
#endif
654
630
 
655
631
    return 0;
656
632
}
662
638
 * Uninit zmbv decoder
663
639
 *
664
640
 */
665
 
static int decode_end(AVCodecContext *avctx)
 
641
static av_cold int decode_end(AVCodecContext *avctx)
666
642
{
667
 
    ZmbvContext * const c = (ZmbvContext *)avctx->priv_data;
 
643
    ZmbvContext * const c = avctx->priv_data;
668
644
 
669
645
    av_freep(&c->decomp_buf);
670
646
 
671
647
    if (c->pic.data[0])
672
648
        avctx->release_buffer(avctx, &c->pic);
673
 
#ifdef CONFIG_ZLIB
674
649
    inflateEnd(&(c->zstream));
675
 
#endif
676
650
    av_freep(&c->cur);
677
651
    av_freep(&c->prev);
678
652
 
687
661
    decode_init,
688
662
    NULL,
689
663
    decode_end,
690
 
    decode_frame
 
664
    decode_frame,
 
665
    .long_name = "Zip Motion Blocks Video",
691
666
};
692
667