← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libavcodec/bytestream.h

  • 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/bytestream.h
26
26
#include "libavutil/common.h"
27
27
#include "libavutil/intreadwrite.h"
28
28
 
 
29
typedef struct {
 
30
    const uint8_t *buffer, *buffer_end, *buffer_start;
 
31
} GetByteContext;
 
32
 
29
33
#define DEF_T(type, name, bytes, read, write)                             \
30
34
static av_always_inline type bytestream_get_ ## name(const uint8_t **b){\
31
35
    (*b) += bytes;\
34
38
static av_always_inline void bytestream_put_ ##name(uint8_t **b, const type value){\
35
39
    write(*b, value);\
36
40
    (*b) += bytes;\
 
41
}\
 
42
static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g)\
 
43
{\
 
44
    return bytestream_get_ ## name(&g->buffer);\
 
45
}\
 
46
static av_always_inline type bytestream2_get_ ## name(GetByteContext *g)\
 
47
{\
 
48
    if (g->buffer_end - g->buffer < bytes)\
 
49
        return 0;\
 
50
    return bytestream2_get_ ## name ## u(g);\
 
51
}\
 
52
static av_always_inline type bytestream2_peek_ ## name(GetByteContext *g)\
 
53
{\
 
54
    if (g->buffer_end - g->buffer < bytes)\
 
55
        return 0;\
 
56
    return read(g->buffer);\
37
57
}
38
58
 
39
59
#define DEF(name, bytes, read, write) \
55
75
#undef DEF64
56
76
#undef DEF_T
57
77
 
 
78
static av_always_inline void bytestream2_init(GetByteContext *g,
 
79
                                              const uint8_t *buf, int buf_size)
 
80
{
 
81
    g->buffer =  buf;
 
82
    g->buffer_start = buf;
 
83
    g->buffer_end = buf + buf_size;
 
84
}
 
85
 
 
86
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
 
87
{
 
88
    return g->buffer_end - g->buffer;
 
89
}
 
90
 
 
91
static av_always_inline void bytestream2_skip(GetByteContext *g,
 
92
                                              unsigned int size)
 
93
{
 
94
    g->buffer += FFMIN(g->buffer_end - g->buffer, size);
 
95
}
 
96
 
 
97
static av_always_inline int bytestream2_tell(GetByteContext *g)
 
98
{
 
99
    return (int)(g->buffer - g->buffer_start);
 
100
}
 
101
 
 
102
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset,
 
103
                                             int whence)
 
104
{
 
105
    switch (whence) {
 
106
    case SEEK_CUR:
 
107
        offset = av_clip(offset, -(g->buffer - g->buffer_start),
 
108
                         g->buffer_end - g->buffer);
 
109
        g->buffer += offset;
 
110
        break;
 
111
    case SEEK_END:
 
112
        offset = av_clip(offset, -(g->buffer_end - g->buffer_start), 0);
 
113
        g->buffer = g->buffer_end + offset;
 
114
        break;
 
115
    case SEEK_SET:
 
116
        offset = av_clip(offset, 0, g->buffer_end - g->buffer_start);
 
117
        g->buffer = g->buffer_start + offset;
 
118
        break;
 
119
    default:
 
120
        return AVERROR(EINVAL);
 
121
    }
 
122
    return bytestream2_tell(g);
 
123
}
 
124
 
 
125
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
 
126
                                                            uint8_t *dst,
 
127
                                                            unsigned int size)
 
128
{
 
129
    int size2 = FFMIN(g->buffer_end - g->buffer, size);
 
130
    memcpy(dst, g->buffer, size2);
 
131
    g->buffer += size2;
 
132
    return size2;
 
133
}
 
134
 
58
135
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
59
136
{
60
137
    memcpy(dst, *b, size);