← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libavcodec/avpacket.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/avpacket.c
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
21
21
 
 
22
#include <string.h>
 
23
 
 
24
#include "libavutil/avassert.h"
 
25
#include "libavutil/mem.h"
22
26
#include "avcodec.h"
23
 
#include "libavutil/avassert.h"
24
 
 
25
 
 
26
 
void av_destruct_packet_nofree(AVPacket *pkt)
27
 
{
28
 
    pkt->data = NULL; pkt->size = 0;
29
 
    pkt->side_data       = NULL;
30
 
    pkt->side_data_elems = 0;
31
 
}
32
27
 
33
28
void av_destruct_packet(AVPacket *pkt)
34
29
{
35
30
    int i;
36
31
 
37
32
    av_free(pkt->data);
38
 
    pkt->data = NULL; pkt->size = 0;
 
33
    pkt->data = NULL;
 
34
    pkt->size = 0;
39
35
 
40
36
    for (i = 0; i < pkt->side_data_elems; i++)
41
37
        av_free(pkt->side_data[i].data);
45
41
 
46
42
void av_init_packet(AVPacket *pkt)
47
43
{
48
 
    pkt->pts   = AV_NOPTS_VALUE;
49
 
    pkt->dts   = AV_NOPTS_VALUE;
50
 
    pkt->pos   = -1;
51
 
    pkt->duration = 0;
 
44
    pkt->pts                  = AV_NOPTS_VALUE;
 
45
    pkt->dts                  = AV_NOPTS_VALUE;
 
46
    pkt->pos                  = -1;
 
47
    pkt->duration             = 0;
52
48
    pkt->convergence_duration = 0;
53
 
    pkt->flags = 0;
54
 
    pkt->stream_index = 0;
55
 
    pkt->destruct= NULL;
56
 
    pkt->side_data       = NULL;
57
 
    pkt->side_data_elems = 0;
 
49
    pkt->flags                = 0;
 
50
    pkt->stream_index         = 0;
 
51
    pkt->destruct             = NULL;
 
52
    pkt->side_data            = NULL;
 
53
    pkt->side_data_elems      = 0;
58
54
}
59
55
 
60
56
int av_new_packet(AVPacket *pkt, int size)
61
57
{
62
 
    uint8_t *data= NULL;
63
 
    if((unsigned)size < (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
 
58
    uint8_t *data = NULL;
 
59
    if ((unsigned)size < (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
64
60
        data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
65
 
    if (data){
 
61
    if (data) {
66
62
        memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
67
 
    }else
68
 
        size=0;
 
63
    } else
 
64
        size = 0;
69
65
 
70
66
    av_init_packet(pkt);
71
 
    pkt->data = data;
72
 
    pkt->size = size;
 
67
    pkt->data     = data;
 
68
    pkt->size     = size;
73
69
    pkt->destruct = av_destruct_packet;
74
 
    if(!data)
 
70
    if (!data)
75
71
        return AVERROR(ENOMEM);
76
72
    return 0;
77
73
}
78
74
 
79
75
void av_shrink_packet(AVPacket *pkt, int size)
80
76
{
81
 
    if (pkt->size <= size) return;
 
77
    if (pkt->size <= size)
 
78
        return;
82
79
    pkt->size = size;
83
80
    memset(pkt->data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
84
81
}
89
86
    av_assert0((unsigned)pkt->size <= INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE);
90
87
    if (!pkt->size)
91
88
        return av_new_packet(pkt, grow_by);
92
 
    if ((unsigned)grow_by > INT_MAX - (pkt->size + FF_INPUT_BUFFER_PADDING_SIZE))
 
89
    if ((unsigned)grow_by >
 
90
        INT_MAX - (pkt->size + FF_INPUT_BUFFER_PADDING_SIZE))
93
91
        return -1;
94
 
    new_ptr = av_realloc(pkt->data, pkt->size + grow_by + FF_INPUT_BUFFER_PADDING_SIZE);
 
92
    new_ptr = av_realloc(pkt->data,
 
93
                         pkt->size + grow_by + FF_INPUT_BUFFER_PADDING_SIZE);
95
94
    if (!new_ptr)
96
95
        return AVERROR(ENOMEM);
97
 
    pkt->data = new_ptr;
 
96
    pkt->data  = new_ptr;
98
97
    pkt->size += grow_by;
99
98
    memset(pkt->data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
100
99
    return 0;
101
100
}
102
101
 
103
 
#define DUP_DATA(dst, src, size, padding) \
104
 
    do { \
105
 
        void *data; \
106
 
        if (padding) { \
107
 
            if ((unsigned)(size) > (unsigned)(size) + FF_INPUT_BUFFER_PADDING_SIZE) \
108
 
                goto failed_alloc; \
109
 
            data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); \
110
 
        } else { \
111
 
            data = av_malloc(size); \
112
 
        } \
113
 
        if (!data) \
114
 
            goto failed_alloc; \
115
 
        memcpy(data, src, size); \
116
 
        if (padding) \
117
 
            memset((uint8_t*)data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE); \
118
 
        dst = data; \
119
 
    } while(0)
 
102
#define DUP_DATA(dst, src, size, padding)                               \
 
103
    do {                                                                \
 
104
        void *data;                                                     \
 
105
        if (padding) {                                                  \
 
106
            if ((unsigned)(size) >                                      \
 
107
                (unsigned)(size) + FF_INPUT_BUFFER_PADDING_SIZE)        \
 
108
                goto failed_alloc;                                      \
 
109
            data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);      \
 
110
        } else {                                                        \
 
111
            data = av_malloc(size);                                     \
 
112
        }                                                               \
 
113
        if (!data)                                                      \
 
114
            goto failed_alloc;                                          \
 
115
        memcpy(data, src, size);                                        \
 
116
        if (padding)                                                    \
 
117
            memset((uint8_t *)data + size, 0,                           \
 
118
                   FF_INPUT_BUFFER_PADDING_SIZE);                       \
 
119
        dst = data;                                                     \
 
120
    } while (0)
120
121
 
121
122
int av_dup_packet(AVPacket *pkt)
122
123
{
123
124
    AVPacket tmp_pkt;
124
125
 
125
 
    if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
 
126
    if (pkt->destruct == NULL && pkt->data) {
126
127
        tmp_pkt = *pkt;
127
128
 
128
129
        pkt->data      = NULL;
135
136
 
136
137
            DUP_DATA(pkt->side_data, tmp_pkt.side_data,
137
138
                     pkt->side_data_elems * sizeof(*pkt->side_data), 0);
138
 
            memset(pkt->side_data, 0, pkt->side_data_elems * sizeof(*pkt->side_data));
139
 
            for (i = 0; i < pkt->side_data_elems; i++) {
 
139
            memset(pkt->side_data, 0,
 
140
                   pkt->side_data_elems * sizeof(*pkt->side_data));
 
141
            for (i = 0; i < pkt->side_data_elems; i++)
140
142
                DUP_DATA(pkt->side_data[i].data, tmp_pkt.side_data[i].data,
141
 
                         pkt->side_data[i].size, 1);
142
 
            }
 
143
                         tmp_pkt.side_data[i].size, 1);
143
144
        }
144
145
    }
145
146
    return 0;
 
147
 
146
148
failed_alloc:
147
149
    av_destruct_packet(pkt);
148
150
    return AVERROR(ENOMEM);
151
153
void av_free_packet(AVPacket *pkt)
152
154
{
153
155
    if (pkt) {
154
 
        if (pkt->destruct) pkt->destruct(pkt);
155
 
        pkt->data = NULL; pkt->size = 0;
 
156
        if (pkt->destruct)
 
157
            pkt->destruct(pkt);
 
158
        pkt->data            = NULL;
 
159
        pkt->size            = 0;
156
160
        pkt->side_data       = NULL;
157
161
        pkt->side_data_elems = 0;
158
162
    }
159
163
}
160
164
 
161
 
uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 
165
uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
162
166
                                 int size)
163
167
{
164
168
    int elems = pkt->side_data_elems;
168
172
    if ((unsigned)size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
169
173
        return NULL;
170
174
 
171
 
    pkt->side_data = av_realloc(pkt->side_data, (elems + 1) * sizeof(*pkt->side_data));
 
175
    pkt->side_data = av_realloc(pkt->side_data,
 
176
                                (elems + 1) * sizeof(*pkt->side_data));
172
177
    if (!pkt->side_data)
173
178
        return NULL;
174
179
 
182
187
    return pkt->side_data[elems].data;
183
188
}
184
189
 
185
 
uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 
190
uint8_t *av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
186
191
                                 int *size)
187
192
{
188
193
    int i;
196
201
    }
197
202
    return NULL;
198
203
}
 
204
 
 
205
int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 
206
                               int size)
 
207
{
 
208
    int i;
 
209
 
 
210
    for (i = 0; i < pkt->side_data_elems; i++) {
 
211
        if (pkt->side_data[i].type == type) {
 
212
            if (size > pkt->side_data[i].size)
 
213
                return AVERROR(ENOMEM);
 
214
            pkt->side_data[i].size = size;
 
215
            return 0;
 
216
        }
 
217
    }
 
218
    return AVERROR(ENOENT);
 
219
}