Revision 2874c81c
libavcodec/ac3dec.c | ||
---|---|---|
216 | 216 |
if (avctx->error_recognition >= FF_ER_CAREFUL) { |
217 | 217 |
s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); |
218 | 218 |
if (!s->input_buffer) |
219 |
return AVERROR_NOMEM;
|
|
219 |
return AVERROR(ENOMEM);
|
|
220 | 220 |
} |
221 | 221 |
|
222 | 222 |
avctx->sample_fmt = SAMPLE_FMT_S16; |
libavcodec/eatgv.c | ||
---|---|---|
288 | 288 |
/* allocate additional 12 bytes to accomodate av_memcpy_backptr() OUTBUF_PADDED optimisation */ |
289 | 289 |
s->frame.data[0] = av_malloc(s->width*s->height + 12); |
290 | 290 |
if (!s->frame.data[0]) |
291 |
return AVERROR_NOMEM;
|
|
291 |
return AVERROR(ENOMEM);
|
|
292 | 292 |
s->frame.data[1] = av_malloc(AVPALETTE_SIZE); |
293 | 293 |
if (!s->frame.data[1]) { |
294 | 294 |
av_freep(&s->frame.data[0]); |
295 |
return AVERROR_NOMEM;
|
|
295 |
return AVERROR(ENOMEM);
|
|
296 | 296 |
} |
297 | 297 |
} |
298 | 298 |
memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE); |
libavcodec/flacenc.c | ||
---|---|---|
352 | 352 |
/* initialize MD5 context */ |
353 | 353 |
s->md5ctx = av_malloc(av_md5_size); |
354 | 354 |
if(!s->md5ctx) |
355 |
return AVERROR_NOMEM;
|
|
355 |
return AVERROR(ENOMEM);
|
|
356 | 356 |
av_md5_init(s->md5ctx); |
357 | 357 |
|
358 | 358 |
streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); |
libavcodec/gif.c | ||
---|---|---|
133 | 133 |
avctx->coded_frame = &s->picture; |
134 | 134 |
s->lzw = av_mallocz(ff_lzw_encode_state_size); |
135 | 135 |
if (!s->lzw) |
136 |
return AVERROR_NOMEM;
|
|
136 |
return AVERROR(ENOMEM);
|
|
137 | 137 |
s->buf = av_malloc(avctx->width*avctx->height*2); |
138 | 138 |
if (!s->buf) |
139 |
return AVERROR_NOMEM;
|
|
139 |
return AVERROR(ENOMEM);
|
|
140 | 140 |
return 0; |
141 | 141 |
} |
142 | 142 |
|
libavdevice/vfwcap.c | ||
---|---|---|
284 | 284 |
st = av_new_stream(s, 0); |
285 | 285 |
if(!st) { |
286 | 286 |
vfw_read_close(s); |
287 |
return AVERROR_NOMEM;
|
|
287 |
return AVERROR(ENOMEM);
|
|
288 | 288 |
} |
289 | 289 |
|
290 | 290 |
/* Set video format */ |
... | ... | |
294 | 294 |
bi = av_malloc(bisize); |
295 | 295 |
if(!bi) { |
296 | 296 |
vfw_read_close(s); |
297 |
return AVERROR_NOMEM;
|
|
297 |
return AVERROR(ENOMEM);
|
|
298 | 298 |
} |
299 | 299 |
ret = SendMessage(ctx->hwnd, WM_CAP_GET_VIDEOFORMAT, bisize, (LPARAM) bi); |
300 | 300 |
if(!ret) |
libavformat/ape.c | ||
---|---|---|
248 | 248 |
} |
249 | 249 |
ape->frames = av_malloc(ape->totalframes * sizeof(APEFrame)); |
250 | 250 |
if(!ape->frames) |
251 |
return AVERROR_NOMEM;
|
|
251 |
return AVERROR(ENOMEM);
|
|
252 | 252 |
ape->firstframe = ape->junklength + ape->descriptorlength + ape->headerlength + ape->seektablelength + ape->wavheaderlength; |
253 | 253 |
ape->currentframe = 0; |
254 | 254 |
|
... | ... | |
351 | 351 |
nblocks = ape->blocksperframe; |
352 | 352 |
|
353 | 353 |
if (av_new_packet(pkt, ape->frames[ape->currentframe].size + extra_size) < 0) |
354 |
return AVERROR_NOMEM;
|
|
354 |
return AVERROR(ENOMEM);
|
|
355 | 355 |
|
356 | 356 |
AV_WL32(pkt->data , nblocks); |
357 | 357 |
AV_WL32(pkt->data + 4, ape->frames[ape->currentframe].skip); |
libavformat/apetag.c | ||
---|---|---|
56 | 56 |
return -1; |
57 | 57 |
value = av_malloc(size+1); |
58 | 58 |
if (!value) |
59 |
return AVERROR_NOMEM;
|
|
59 |
return AVERROR(ENOMEM);
|
|
60 | 60 |
get_buffer(pb, value, size); |
61 | 61 |
value[size] = 0; |
62 | 62 |
av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL); |
libavformat/cafdec.c | ||
---|---|---|
61 | 61 |
/* new audio stream */ |
62 | 62 |
st = av_new_stream(s, 0); |
63 | 63 |
if (!st) |
64 |
return AVERROR_NOMEM;
|
|
64 |
return AVERROR(ENOMEM);
|
|
65 | 65 |
|
66 | 66 |
/* parse format description */ |
67 | 67 |
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
libavformat/flacdec.c | ||
---|---|---|
67 | 67 |
case FLAC_METADATA_TYPE_VORBIS_COMMENT: |
68 | 68 |
buffer = av_mallocz(metadata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
69 | 69 |
if (!buffer) { |
70 |
return AVERROR_NOMEM;
|
|
70 |
return AVERROR(ENOMEM);
|
|
71 | 71 |
} |
72 | 72 |
if (get_buffer(s->pb, buffer, metadata_size) != metadata_size) { |
73 | 73 |
av_freep(&buffer); |
libavformat/mpegtsenc.c | ||
---|---|---|
433 | 433 |
st->codec->extradata_size > 0) { |
434 | 434 |
ts_st->adts = av_mallocz(sizeof(*ts_st->adts)); |
435 | 435 |
if (!ts_st->adts) |
436 |
return AVERROR_NOMEM;
|
|
436 |
return AVERROR(ENOMEM);
|
|
437 | 437 |
if (ff_adts_decode_extradata(s, ts_st->adts, st->codec->extradata, |
438 | 438 |
st->codec->extradata_size) < 0) |
439 | 439 |
return -1; |
... | ... | |
836 | 836 |
return -1; |
837 | 837 |
data = av_malloc(new_size); |
838 | 838 |
if (!data) |
839 |
return AVERROR_NOMEM;
|
|
839 |
return AVERROR(ENOMEM);
|
|
840 | 840 |
ff_adts_write_frame_header(adts, data, pkt->size, adts->pce_size); |
841 | 841 |
if (adts->pce_size) { |
842 | 842 |
memcpy(data+ADTS_HEADER_SIZE, adts->pce_data, adts->pce_size); |
libavformat/msnwc_tcp.c | ||
---|---|---|
77 | 77 |
|
78 | 78 |
st = av_new_stream(ctx, 0); |
79 | 79 |
if(!st) |
80 |
return AVERROR_NOMEM;
|
|
80 |
return AVERROR(ENOMEM);
|
|
81 | 81 |
|
82 | 82 |
codec = st->codec; |
83 | 83 |
codec->codec_type = AVMEDIA_TYPE_VIDEO; |
libavformat/oggenc.c | ||
---|---|---|
121 | 121 |
oggstream->header[0] = av_mallocz(51); // per ogg flac specs |
122 | 122 |
p = oggstream->header[0]; |
123 | 123 |
if (!p) |
124 |
return AVERROR_NOMEM;
|
|
124 |
return AVERROR(ENOMEM);
|
|
125 | 125 |
bytestream_put_byte(&p, 0x7F); |
126 | 126 |
bytestream_put_buffer(&p, "FLAC", 4); |
127 | 127 |
bytestream_put_byte(&p, 1); // major version |
... | ... | |
135 | 135 |
// second packet: VorbisComment |
136 | 136 |
p = ogg_write_vorbiscomment(4, bitexact, &oggstream->header_len[1], m); |
137 | 137 |
if (!p) |
138 |
return AVERROR_NOMEM;
|
|
138 |
return AVERROR(ENOMEM);
|
|
139 | 139 |
oggstream->header[1] = p; |
140 | 140 |
bytestream_put_byte(&p, 0x84); // last metadata block and vorbis comment |
141 | 141 |
bytestream_put_be24(&p, oggstream->header_len[1] - 4); |
... | ... | |
157 | 157 |
// first packet: Speex header |
158 | 158 |
p = av_mallocz(SPEEX_HEADER_SIZE); |
159 | 159 |
if (!p) |
160 |
return AVERROR_NOMEM;
|
|
160 |
return AVERROR(ENOMEM);
|
|
161 | 161 |
oggstream->header[0] = p; |
162 | 162 |
oggstream->header_len[0] = SPEEX_HEADER_SIZE; |
163 | 163 |
bytestream_put_buffer(&p, avctx->extradata, SPEEX_HEADER_SIZE); |
... | ... | |
166 | 166 |
// second packet: VorbisComment |
167 | 167 |
p = ogg_write_vorbiscomment(0, bitexact, &oggstream->header_len[1], m); |
168 | 168 |
if (!p) |
169 |
return AVERROR_NOMEM;
|
|
169 |
return AVERROR(ENOMEM);
|
|
170 | 170 |
oggstream->header[1] = p; |
171 | 171 |
|
172 | 172 |
return 0; |
libavformat/rmdec.c | ||
---|---|---|
106 | 106 |
return -1; |
107 | 107 |
avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); |
108 | 108 |
if (!avctx->extradata) |
109 |
return AVERROR_NOMEM;
|
|
109 |
return AVERROR(ENOMEM);
|
|
110 | 110 |
avctx->extradata_size = get_buffer(pb, avctx->extradata, size); |
111 | 111 |
memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); |
112 | 112 |
if (avctx->extradata_size != size) |
libavformat/rtpdec_amr.c | ||
---|---|---|
83 | 83 |
/* Everything except the codec mode request byte should be output. */ |
84 | 84 |
if (av_new_packet(pkt, len - 1)) { |
85 | 85 |
av_log(ctx, AV_LOG_ERROR, "Out of memory\n"); |
86 |
return AVERROR_NOMEM;
|
|
86 |
return AVERROR(ENOMEM);
|
|
87 | 87 |
} |
88 | 88 |
pkt->stream_index = st->index; |
89 | 89 |
ptr = pkt->data; |
libavformat/rtpdec_h263.c | ||
---|---|---|
78 | 78 |
|
79 | 79 |
if (av_new_packet(pkt, len + startcode)) { |
80 | 80 |
av_log(ctx, AV_LOG_ERROR, "Out of memory\n"); |
81 |
return AVERROR_NOMEM;
|
|
81 |
return AVERROR(ENOMEM);
|
|
82 | 82 |
} |
83 | 83 |
pkt->stream_index = st->index; |
84 | 84 |
ptr = pkt->data; |
libavformat/rtpdec_xiph.c | ||
---|---|---|
134 | 134 |
|
135 | 135 |
if (av_new_packet(pkt, data_len)) { |
136 | 136 |
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n"); |
137 |
return AVERROR_NOMEM;
|
|
137 |
return AVERROR(ENOMEM);
|
|
138 | 138 |
} |
139 | 139 |
pkt->stream_index = st->index; |
140 | 140 |
|
... | ... | |
189 | 189 |
|
190 | 190 |
if (av_new_packet(pkt, frame_size)) { |
191 | 191 |
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n"); |
192 |
return AVERROR_NOMEM;
|
|
192 |
return AVERROR(ENOMEM);
|
|
193 | 193 |
} |
194 | 194 |
|
195 | 195 |
memcpy(pkt->data, xiph_data, frame_size); |
... | ... | |
272 | 272 |
ptr = codec->extradata = av_malloc(extradata_alloc); |
273 | 273 |
if (!ptr) { |
274 | 274 |
av_log(codec, AV_LOG_ERROR, "Out of memory\n"); |
275 |
return AVERROR_NOMEM;
|
|
275 |
return AVERROR(ENOMEM);
|
|
276 | 276 |
} |
277 | 277 |
*ptr++ = 2; |
278 | 278 |
ptr += av_xiphlacing(ptr, length1); |
... | ... | |
331 | 331 |
} else { |
332 | 332 |
av_log(codec, AV_LOG_ERROR, |
333 | 333 |
"Out of memory while decoding SDP configuration.\n"); |
334 |
result = AVERROR_NOMEM;
|
|
334 |
result = AVERROR(ENOMEM);
|
|
335 | 335 |
} |
336 | 336 |
} else { |
337 | 337 |
av_log(codec, AV_LOG_ERROR, "Packet too large\n"); |
... | ... | |
356 | 356 |
|
357 | 357 |
if (!(value = av_malloc(value_size))) { |
358 | 358 |
av_log(codec, AV_LOG_ERROR, "Out of memory\n"); |
359 |
return AVERROR_NOMEM;
|
|
359 |
return AVERROR(ENOMEM);
|
|
360 | 360 |
} |
361 | 361 |
|
362 | 362 |
if (av_strstart(line, "fmtp:", &p)) { |
libavformat/wc3movie.c | ||
---|---|---|
186 | 186 |
/* load up the name */ |
187 | 187 |
buffer = av_malloc(size+1); |
188 | 188 |
if (!buffer) |
189 |
return AVERROR_NOMEM;
|
|
189 |
return AVERROR(ENOMEM);
|
|
190 | 190 |
if ((ret = get_buffer(pb, buffer, size)) != size) |
191 | 191 |
return AVERROR(EIO); |
192 | 192 |
buffer[size] = 0; |
Also available in: Unified diff