git.sesse.net Git - ffmpeg/blob - libavcodec/avpacket.c

   1 /*
   2  * AVPacket functions for libavcodec
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "avcodec.h"
  23 #include "internal.h"
  24 #include "libavutil/avassert.h"
  25 #include "bytestream.h"
  26
  27 void av_destruct_packet_nofree(AVPacket *pkt)
  28 {
  29     pkt->data = NULL; pkt->size = 0;
  30     pkt->side_data       = NULL;
  31     pkt->side_data_elems = 0;
  32 }
  33
  34 void ff_packet_free_side_data(AVPacket *pkt)
  35 {
  36     int i;
  37     for (i = 0; i < pkt->side_data_elems; i++)
  38         av_free(pkt->side_data[i].data);
  39     av_freep(&pkt->side_data);
  40     pkt->side_data_elems = 0;
  41 }
  42
  43 void av_destruct_packet(AVPacket *pkt)
  44 {
  45     av_free(pkt->data);
  46     pkt->data = NULL; pkt->size = 0;
  47
  48     ff_packet_free_side_data(pkt);
  49 }
  50
  51 void av_init_packet(AVPacket *pkt)
  52 {
  53     pkt->pts   = AV_NOPTS_VALUE;
  54     pkt->dts   = AV_NOPTS_VALUE;
  55     pkt->pos   = -1;
  56     pkt->duration = 0;
  57     pkt->convergence_duration = 0;
  58     pkt->flags = 0;
  59     pkt->stream_index = 0;
  60     pkt->destruct= NULL;
  61     pkt->side_data       = NULL;
  62     pkt->side_data_elems = 0;
  63 }
  64
  65 int av_new_packet(AVPacket *pkt, int size)
  66 {
  67     uint8_t *data= NULL;
  68     if((unsigned)size < (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
  69         data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
  70     if (data){
  71         memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  72     }else
  73         size=0;
  74
  75     av_init_packet(pkt);
  76     pkt->data = data;
  77     pkt->size = size;
  78     pkt->destruct = av_destruct_packet;
  79     if(!data)
  80         return AVERROR(ENOMEM);
  81     return 0;
  82 }
  83
  84 void av_shrink_packet(AVPacket *pkt, int size)
  85 {
  86     if (pkt->size <= size) return;
  87     pkt->size = size;
  88     memset(pkt->data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  89 }
  90
  91 int av_grow_packet(AVPacket *pkt, int grow_by)
  92 {
  93     void *new_ptr;
  94     av_assert0((unsigned)pkt->size <= INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE);
  95     if (!pkt->size)
  96         return av_new_packet(pkt, grow_by);
  97     if ((unsigned)grow_by > INT_MAX - (pkt->size + FF_INPUT_BUFFER_PADDING_SIZE))
  98         return -1;
  99     new_ptr = av_realloc(pkt->data, pkt->size + grow_by + FF_INPUT_BUFFER_PADDING_SIZE);
 100     if (!new_ptr)
 101         return AVERROR(ENOMEM);
 102     pkt->data = new_ptr;
 103     pkt->size += grow_by;
 104     memset(pkt->data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 105     return 0;
 106 }
 107
 108 #define DUP_DATA(dst, src, size, padding) \
 109     do { \
 110         void *data; \
 111         if (padding) { \
 112             if ((unsigned)(size) > (unsigned)(size) + FF_INPUT_BUFFER_PADDING_SIZE) \
 113                 goto failed_alloc; \
 114             data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); \
 115         } else { \
 116             data = av_malloc(size); \
 117         } \
 118         if (!data) \
 119             goto failed_alloc; \
 120         memcpy(data, src, size); \
 121         if (padding) \
 122             memset((uint8_t*)data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE); \
 123         dst = data; \
 124     } while(0)
 125
 126 int av_dup_packet(AVPacket *pkt)
 127 {
 128     AVPacket tmp_pkt;
 129
 130     if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
 131         tmp_pkt = *pkt;
 132
 133         pkt->data      = NULL;
 134         pkt->side_data = NULL;
 135         DUP_DATA(pkt->data, tmp_pkt.data, pkt->size, 1);
 136         pkt->destruct = av_destruct_packet;
 137
 138         if (pkt->side_data_elems) {
 139             int i;
 140
 141             DUP_DATA(pkt->side_data, tmp_pkt.side_data,
 142                      pkt->side_data_elems * sizeof(*pkt->side_data), 0);
 143             memset(pkt->side_data, 0, pkt->side_data_elems * sizeof(*pkt->side_data));
 144             for (i = 0; i < pkt->side_data_elems; i++) {
 145                 DUP_DATA(pkt->side_data[i].data, tmp_pkt.side_data[i].data,
 146                          pkt->side_data[i].size, 1);
 147             }
 148         }
 149     }
 150     return 0;
 151 failed_alloc:
 152     av_destruct_packet(pkt);
 153     return AVERROR(ENOMEM);
 154 }
 155
 156 void av_free_packet(AVPacket *pkt)
 157 {
 158     if (pkt) {
 159         if (pkt->destruct) pkt->destruct(pkt);
 160         pkt->data = NULL; pkt->size = 0;
 161         pkt->side_data       = NULL;
 162         pkt->side_data_elems = 0;
 163     }
 164 }
 165
 166 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 167                                  int size)
 168 {
 169     int elems = pkt->side_data_elems;
 170
 171     if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))
 172         return NULL;
 173     if ((unsigned)size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
 174         return NULL;
 175
 176     pkt->side_data = av_realloc(pkt->side_data, (elems + 1) * sizeof(*pkt->side_data));
 177     if (!pkt->side_data)
 178         return NULL;
 179
 180     pkt->side_data[elems].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 181     if (!pkt->side_data[elems].data)
 182         return NULL;
 183     pkt->side_data[elems].size = size;
 184     pkt->side_data[elems].type = type;
 185     pkt->side_data_elems++;
 186
 187     return pkt->side_data[elems].data;
 188 }
 189
 190 uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 191                                  int *size)
 192 {
 193     int i;
 194
 195     for (i = 0; i < pkt->side_data_elems; i++) {
 196         if (pkt->side_data[i].type == type) {
 197             if (size)
 198                 *size = pkt->side_data[i].size;
 199             return pkt->side_data[i].data;
 200         }
 201     }
 202     return NULL;
 203 }
 204
 205 #define FF_MERGE_MARKER 0x8c4d9d108e25e9feULL
 206
 207 int av_packet_merge_side_data(AVPacket *pkt){
 208     if(pkt->side_data_elems){
 209         int i;
 210         uint8_t *p;
 211         uint64_t size= pkt->size + 8LL + FF_INPUT_BUFFER_PADDING_SIZE;
 212         AVPacket old= *pkt;
 213         for (i=0; i<old.side_data_elems; i++) {
 214             size += old.side_data[i].size + 5LL;
 215         }
 216         if (size > INT_MAX)
 217             return AVERROR(EINVAL);
 218         p = av_malloc(size);
 219         if (!p)
 220             return AVERROR(ENOMEM);
 221         pkt->data = p;
 222         pkt->destruct = av_destruct_packet;
 223         pkt->size = size - FF_INPUT_BUFFER_PADDING_SIZE;
 224         bytestream_put_buffer(&p, old.data, old.size);
 225         for (i=old.side_data_elems-1; i>=0; i--) {
 226             bytestream_put_buffer(&p, old.side_data[i].data, old.side_data[i].size);
 227             bytestream_put_be32(&p, old.side_data[i].size);
 228             *p++ = old.side_data[i].type | ((i==old.side_data_elems-1)*128);
 229         }
 230         bytestream_put_be64(&p, FF_MERGE_MARKER);
 231         av_assert0(p-pkt->data == pkt->size);
 232         memset(p, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 233         av_free_packet(&old);
 234         pkt->side_data_elems = 0;
 235         pkt->side_data = NULL;
 236         return 1;
 237     }
 238     return 0;
 239 }
 240
 241 int av_packet_split_side_data(AVPacket *pkt){
 242     if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
 243         int i;
 244         unsigned int size;
 245         uint8_t *p;
 246
 247         p = pkt->data + pkt->size - 8 - 5;
 248         for (i=1; ; i++){
 249             size = AV_RB32(p);
 250             if (size>INT_MAX || p - pkt->data <= size)
 251                 return 0;
 252             if (p[4]&128)
 253                 break;
 254             p-= size+5;
 255         }
 256
 257         pkt->side_data = av_malloc(i * sizeof(*pkt->side_data));
 258         if (!pkt->side_data)
 259             return AVERROR(ENOMEM);
 260
 261         p= pkt->data + pkt->size - 8 - 5;
 262         for (i=0; ; i++){
 263             size= AV_RB32(p);
 264             av_assert0(size<=INT_MAX && p - pkt->data > size);
 265             pkt->side_data[i].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 266             pkt->side_data[i].size = size;
 267             pkt->side_data[i].type = p[4]&127;
 268             if (!pkt->side_data[i].data)
 269                 return AVERROR(ENOMEM);
 270             memcpy(pkt->side_data[i].data, p-size, size);
 271             pkt->size -= size + 5;
 272             if(p[4]&128)
 273                 break;
 274             p-= size+5;
 275         }
 276         pkt->size -= 8;
 277         pkt->side_data_elems = i+1;
 278         return 1;
 279     }
 280     return 0;
 281 }
 282
 283 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 284                                int size)
 285 {
 286     int i;
 287
 288     for (i = 0; i < pkt->side_data_elems; i++) {
 289         if (pkt->side_data[i].type == type) {
 290             if (size > pkt->side_data[i].size)
 291                 return AVERROR(ENOMEM);
 292             pkt->side_data[i].size = size;
 293             return 0;
 294         }
 295     }
 296     return AVERROR(ENOENT);
 297 }