00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <string.h>
00023
00024 #include "libavutil/avassert.h"
00025 #include "libavutil/mem.h"
00026 #include "avcodec.h"
00027 #include "bytestream.h"
00028 #include "internal.h"
00029
00030 void ff_packet_free_side_data(AVPacket *pkt)
00031 {
00032 int i;
00033 for (i = 0; i < pkt->side_data_elems; i++)
00034 av_free(pkt->side_data[i].data);
00035 av_freep(&pkt->side_data);
00036 pkt->side_data_elems = 0;
00037 }
00038
00039 void av_destruct_packet(AVPacket *pkt)
00040 {
00041 av_free(pkt->data);
00042 pkt->data = NULL;
00043 pkt->size = 0;
00044
00045 ff_packet_free_side_data(pkt);
00046 }
00047
00048 void av_init_packet(AVPacket *pkt)
00049 {
00050 pkt->pts = AV_NOPTS_VALUE;
00051 pkt->dts = AV_NOPTS_VALUE;
00052 pkt->pos = -1;
00053 pkt->duration = 0;
00054 pkt->convergence_duration = 0;
00055 pkt->flags = 0;
00056 pkt->stream_index = 0;
00057 pkt->destruct = NULL;
00058 pkt->side_data = NULL;
00059 pkt->side_data_elems = 0;
00060 }
00061
00062 int av_new_packet(AVPacket *pkt, int size)
00063 {
00064 uint8_t *data = NULL;
00065 if ((unsigned)size < (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
00066 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
00067 if (data) {
00068 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00069 } else
00070 size = 0;
00071
00072 av_init_packet(pkt);
00073 pkt->data = data;
00074 pkt->size = size;
00075 pkt->destruct = av_destruct_packet;
00076 if (!data)
00077 return AVERROR(ENOMEM);
00078 return 0;
00079 }
00080
00081 void av_shrink_packet(AVPacket *pkt, int size)
00082 {
00083 if (pkt->size <= size)
00084 return;
00085 pkt->size = size;
00086 memset(pkt->data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00087 }
00088
00089 int av_grow_packet(AVPacket *pkt, int grow_by)
00090 {
00091 void *new_ptr;
00092 av_assert0((unsigned)pkt->size <= INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE);
00093 if (!pkt->size)
00094 return av_new_packet(pkt, grow_by);
00095 if ((unsigned)grow_by >
00096 INT_MAX - (pkt->size + FF_INPUT_BUFFER_PADDING_SIZE))
00097 return -1;
00098 new_ptr = av_realloc(pkt->data,
00099 pkt->size + grow_by + FF_INPUT_BUFFER_PADDING_SIZE);
00100 if (!new_ptr)
00101 return AVERROR(ENOMEM);
00102 pkt->data = new_ptr;
00103 pkt->size += grow_by;
00104 memset(pkt->data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00105 return 0;
00106 }
00107
00108 #define DUP_DATA(dst, src, size, padding) \
00109 do { \
00110 void *data; \
00111 if (padding) { \
00112 if ((unsigned)(size) > \
00113 (unsigned)(size) + FF_INPUT_BUFFER_PADDING_SIZE) \
00114 goto failed_alloc; \
00115 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); \
00116 } else { \
00117 data = av_malloc(size); \
00118 } \
00119 if (!data) \
00120 goto failed_alloc; \
00121 memcpy(data, src, size); \
00122 if (padding) \
00123 memset((uint8_t *)data + size, 0, \
00124 FF_INPUT_BUFFER_PADDING_SIZE); \
00125 dst = data; \
00126 } while (0)
00127
00128
00129 static int copy_packet_data(AVPacket *dst, AVPacket *src)
00130 {
00131 dst->data = NULL;
00132 dst->side_data = NULL;
00133 DUP_DATA(dst->data, src->data, dst->size, 1);
00134 dst->destruct = av_destruct_packet;
00135
00136 if (dst->side_data_elems) {
00137 int i;
00138
00139 DUP_DATA(dst->side_data, src->side_data,
00140 dst->side_data_elems * sizeof(*dst->side_data), 0);
00141 memset(dst->side_data, 0,
00142 dst->side_data_elems * sizeof(*dst->side_data));
00143 for (i = 0; i < dst->side_data_elems; i++) {
00144 DUP_DATA(dst->side_data[i].data, src->side_data[i].data,
00145 src->side_data[i].size, 1);
00146 dst->side_data[i].size = src->side_data[i].size;
00147 dst->side_data[i].type = src->side_data[i].type;
00148 }
00149 }
00150 return 0;
00151
00152 failed_alloc:
00153 av_destruct_packet(dst);
00154 return AVERROR(ENOMEM);
00155 }
00156
00157 int av_dup_packet(AVPacket *pkt)
00158 {
00159 AVPacket tmp_pkt;
00160
00161 if (pkt->destruct == NULL && pkt->data) {
00162 tmp_pkt = *pkt;
00163 return copy_packet_data(pkt, &tmp_pkt);
00164 }
00165 return 0;
00166 }
00167
00168 int av_copy_packet(AVPacket *dst, AVPacket *src)
00169 {
00170 *dst = *src;
00171 return copy_packet_data(dst, src);
00172 }
00173
00174 void av_free_packet(AVPacket *pkt)
00175 {
00176 if (pkt) {
00177 if (pkt->destruct)
00178 pkt->destruct(pkt);
00179 pkt->data = NULL;
00180 pkt->size = 0;
00181 pkt->side_data = NULL;
00182 pkt->side_data_elems = 0;
00183 }
00184 }
00185
00186 uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
00187 int size)
00188 {
00189 int elems = pkt->side_data_elems;
00190
00191 if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))
00192 return NULL;
00193 if ((unsigned)size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
00194 return NULL;
00195
00196 pkt->side_data = av_realloc(pkt->side_data,
00197 (elems + 1) * sizeof(*pkt->side_data));
00198 if (!pkt->side_data)
00199 return NULL;
00200
00201 pkt->side_data[elems].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
00202 if (!pkt->side_data[elems].data)
00203 return NULL;
00204 pkt->side_data[elems].size = size;
00205 pkt->side_data[elems].type = type;
00206 pkt->side_data_elems++;
00207
00208 return pkt->side_data[elems].data;
00209 }
00210
00211 uint8_t *av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
00212 int *size)
00213 {
00214 int i;
00215
00216 for (i = 0; i < pkt->side_data_elems; i++) {
00217 if (pkt->side_data[i].type == type) {
00218 if (size)
00219 *size = pkt->side_data[i].size;
00220 return pkt->side_data[i].data;
00221 }
00222 }
00223 return NULL;
00224 }
00225
00226 #define FF_MERGE_MARKER 0x8c4d9d108e25e9feULL
00227
00228 int av_packet_merge_side_data(AVPacket *pkt){
00229 if(pkt->side_data_elems){
00230 int i;
00231 uint8_t *p;
00232 uint64_t size= pkt->size + 8LL + FF_INPUT_BUFFER_PADDING_SIZE;
00233 AVPacket old= *pkt;
00234 for (i=0; i<old.side_data_elems; i++) {
00235 size += old.side_data[i].size + 5LL;
00236 }
00237 if (size > INT_MAX)
00238 return AVERROR(EINVAL);
00239 p = av_malloc(size);
00240 if (!p)
00241 return AVERROR(ENOMEM);
00242 pkt->data = p;
00243 pkt->destruct = av_destruct_packet;
00244 pkt->size = size - FF_INPUT_BUFFER_PADDING_SIZE;
00245 bytestream_put_buffer(&p, old.data, old.size);
00246 for (i=old.side_data_elems-1; i>=0; i--) {
00247 bytestream_put_buffer(&p, old.side_data[i].data, old.side_data[i].size);
00248 bytestream_put_be32(&p, old.side_data[i].size);
00249 *p++ = old.side_data[i].type | ((i==old.side_data_elems-1)*128);
00250 }
00251 bytestream_put_be64(&p, FF_MERGE_MARKER);
00252 av_assert0(p-pkt->data == pkt->size);
00253 memset(p, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00254 av_free_packet(&old);
00255 pkt->side_data_elems = 0;
00256 pkt->side_data = NULL;
00257 return 1;
00258 }
00259 return 0;
00260 }
00261
00262 int av_packet_split_side_data(AVPacket *pkt){
00263 if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
00264 int i;
00265 unsigned int size;
00266 uint8_t *p;
00267
00268 p = pkt->data + pkt->size - 8 - 5;
00269 for (i=1; ; i++){
00270 size = AV_RB32(p);
00271 if (size>INT_MAX || p - pkt->data < size)
00272 return 0;
00273 if (p[4]&128)
00274 break;
00275 p-= size+5;
00276 }
00277
00278 pkt->side_data = av_malloc(i * sizeof(*pkt->side_data));
00279 if (!pkt->side_data)
00280 return AVERROR(ENOMEM);
00281
00282 p= pkt->data + pkt->size - 8 - 5;
00283 for (i=0; ; i++){
00284 size= AV_RB32(p);
00285 av_assert0(size<=INT_MAX && p - pkt->data >= size);
00286 pkt->side_data[i].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
00287 pkt->side_data[i].size = size;
00288 pkt->side_data[i].type = p[4]&127;
00289 if (!pkt->side_data[i].data)
00290 return AVERROR(ENOMEM);
00291 memcpy(pkt->side_data[i].data, p-size, size);
00292 pkt->size -= size + 5;
00293 if(p[4]&128)
00294 break;
00295 p-= size+5;
00296 }
00297 pkt->size -= 8;
00298 pkt->side_data_elems = i+1;
00299 return 1;
00300 }
00301 return 0;
00302 }
00303
00304 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
00305 int size)
00306 {
00307 int i;
00308
00309 for (i = 0; i < pkt->side_data_elems; i++) {
00310 if (pkt->side_data[i].type == type) {
00311 if (size > pkt->side_data[i].size)
00312 return AVERROR(ENOMEM);
00313 pkt->side_data[i].size = size;
00314 return 0;
00315 }
00316 }
00317 return AVERROR(ENOENT);
00318 }
