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 "internal.h"
  23 #include "libavutil/avassert.h"
  24 #include "bytestream.h"
  25 #include "avcodec.h"
  26
  27 void av_destruct_packet_nofree(AVPacket *pkt)
  28 {
  29     pkt->data            = NULL;
  30     pkt->size            = 0;
  31     pkt->side_data       = NULL;
  32     pkt->side_data_elems = 0;
  33 }
  34
  35 void ff_packet_free_side_data(AVPacket *pkt)
  36 {
  37     int i;
  38     for (i = 0; i < pkt->side_data_elems; i++)
  39         av_free(pkt->side_data[i].data);
  40     av_freep(&pkt->side_data);
  41     pkt->side_data_elems = 0;
  42 }
  43
  44 void av_destruct_packet(AVPacket *pkt)
  45 {
  46     av_free(pkt->data);
  47     pkt->data = NULL;
  48     pkt->size = 0;
  49
  50     ff_packet_free_side_data(pkt);
  51 }
  52
  53 void av_init_packet(AVPacket *pkt)
  54 {
  55     pkt->pts                  = AV_NOPTS_VALUE;
  56     pkt->dts                  = AV_NOPTS_VALUE;
  57     pkt->pos                  = -1;
  58     pkt->duration             = 0;
  59     pkt->convergence_duration = 0;
  60     pkt->flags                = 0;
  61     pkt->stream_index         = 0;
  62     pkt->destruct             = NULL;
  63     pkt->side_data            = NULL;
  64     pkt->side_data_elems      = 0;
  65 }
  66
  67 int av_new_packet(AVPacket *pkt, int size)
  68 {
  69     uint8_t *data = NULL;
  70     if ((unsigned)size < (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
  71         data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
  72     if (data) {
  73         memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  74     } else
  75         size = 0;
  76
  77     av_init_packet(pkt);
  78     pkt->data     = data;
  79     pkt->size     = size;
  80     pkt->destruct = av_destruct_packet;
  81     if (!data)
  82         return AVERROR(ENOMEM);
  83     return 0;
  84 }
  85
  86 void av_shrink_packet(AVPacket *pkt, int size)
  87 {
  88     if (pkt->size <= size)
  89         return;
  90     pkt->size = size;
  91     memset(pkt->data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  92 }
  93
  94 int av_grow_packet(AVPacket *pkt, int grow_by)
  95 {
  96     void *new_ptr;
  97     av_assert0((unsigned)pkt->size <= INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE);
  98     if (!pkt->size)
  99         return av_new_packet(pkt, grow_by);
 100     if ((unsigned)grow_by >
 101         INT_MAX - (pkt->size + FF_INPUT_BUFFER_PADDING_SIZE))
 102         return -1;
 103     new_ptr = av_realloc(pkt->data,
 104                          pkt->size + grow_by + FF_INPUT_BUFFER_PADDING_SIZE);
 105     if (!new_ptr)
 106         return AVERROR(ENOMEM);
 107     pkt->data  = new_ptr;
 108     pkt->size += grow_by;
 109     memset(pkt->data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 110     return 0;
 111 }
 112
 113 #define DUP_DATA(dst, src, size, padding)                               \
 114     do {                                                                \
 115         void *data;                                                     \
 116         if (padding) {                                                  \
 117             if ((unsigned)(size) >                                      \
 118                 (unsigned)(size) + FF_INPUT_BUFFER_PADDING_SIZE)        \
 119                 goto failed_alloc;                                      \
 120             data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);      \
 121         } else {                                                        \
 122             data = av_malloc(size);                                     \
 123         }                                                               \
 124         if (!data)                                                      \
 125             goto failed_alloc;                                          \
 126         memcpy(data, src, size);                                        \
 127         if (padding)                                                    \
 128             memset((uint8_t *)data + size, 0,                           \
 129                    FF_INPUT_BUFFER_PADDING_SIZE);                       \
 130         dst = data;                                                     \
 131     } while (0)
 132
 133 int av_dup_packet(AVPacket *pkt)
 134 {
 135     AVPacket tmp_pkt;
 136
 137     if (((pkt->destruct == av_destruct_packet_nofree) ||
 138          (pkt->destruct == NULL)) && pkt->data) {
 139         tmp_pkt = *pkt;
 140
 141         pkt->data      = NULL;
 142         pkt->side_data = NULL;
 143         DUP_DATA(pkt->data, tmp_pkt.data, pkt->size, 1);
 144         pkt->destruct = av_destruct_packet;
 145
 146         if (pkt->side_data_elems) {
 147             int i;
 148
 149             DUP_DATA(pkt->side_data, tmp_pkt.side_data,
 150                      pkt->side_data_elems * sizeof(*pkt->side_data), 0);
 151             memset(pkt->side_data, 0,
 152                    pkt->side_data_elems * sizeof(*pkt->side_data));
 153             for (i = 0; i < pkt->side_data_elems; i++)
 154                 DUP_DATA(pkt->side_data[i].data, tmp_pkt.side_data[i].data,
 155                          pkt->side_data[i].size, 1);
 156         }
 157     }
 158     return 0;
 159
 160 failed_alloc:
 161     av_destruct_packet(pkt);
 162     return AVERROR(ENOMEM);
 163 }
 164
 165 void av_free_packet(AVPacket *pkt)
 166 {
 167     if (pkt) {
 168         if (pkt->destruct)
 169             pkt->destruct(pkt);
 170         pkt->data            = NULL;
 171         pkt->size            = 0;
 172         pkt->side_data       = NULL;
 173         pkt->side_data_elems = 0;
 174     }
 175 }
 176
 177 uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 178                                  int size)
 179 {
 180     int elems = pkt->side_data_elems;
 181
 182     if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))
 183         return NULL;
 184     if ((unsigned)size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
 185         return NULL;
 186
 187     pkt->side_data = av_realloc(pkt->side_data,
 188                                 (elems + 1) * sizeof(*pkt->side_data));
 189     if (!pkt->side_data)
 190         return NULL;
 191
 192     pkt->side_data[elems].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 193     if (!pkt->side_data[elems].data)
 194         return NULL;
 195     pkt->side_data[elems].size = size;
 196     pkt->side_data[elems].type = type;
 197     pkt->side_data_elems++;
 198
 199     return pkt->side_data[elems].data;
 200 }
 201
 202 uint8_t *av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 203                                  int *size)
 204 {
 205     int i;
 206
 207     for (i = 0; i < pkt->side_data_elems; i++) {
 208         if (pkt->side_data[i].type == type) {
 209             if (size)
 210                 *size = pkt->side_data[i].size;
 211             return pkt->side_data[i].data;
 212         }
 213     }
 214     return NULL;
 215 }
 216
 217 #define FF_MERGE_MARKER 0x8c4d9d108e25e9feULL
 218
 219 int av_packet_merge_side_data(AVPacket *pkt){
 220     if(pkt->side_data_elems){
 221         int i;
 222         uint8_t *p;
 223         uint64_t size= pkt->size + 8LL + FF_INPUT_BUFFER_PADDING_SIZE;
 224         AVPacket old= *pkt;
 225         for (i=0; i<old.side_data_elems; i++) {
 226             size += old.side_data[i].size + 5LL;
 227         }
 228         if (size > INT_MAX)
 229             return AVERROR(EINVAL);
 230         p = av_malloc(size);
 231         if (!p)
 232             return AVERROR(ENOMEM);
 233         pkt->data = p;
 234         pkt->destruct = av_destruct_packet;
 235         pkt->size = size - FF_INPUT_BUFFER_PADDING_SIZE;
 236         bytestream_put_buffer(&p, old.data, old.size);
 237         for (i=old.side_data_elems-1; i>=0; i--) {
 238             bytestream_put_buffer(&p, old.side_data[i].data, old.side_data[i].size);
 239             bytestream_put_be32(&p, old.side_data[i].size);
 240             *p++ = old.side_data[i].type | ((i==old.side_data_elems-1)*128);
 241         }
 242         bytestream_put_be64(&p, FF_MERGE_MARKER);
 243         av_assert0(p-pkt->data == pkt->size);
 244         memset(p, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 245         av_free_packet(&old);
 246         pkt->side_data_elems = 0;
 247         pkt->side_data = NULL;
 248         return 1;
 249     }
 250     return 0;
 251 }
 252
 253 int av_packet_split_side_data(AVPacket *pkt){
 254     if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
 255         int i;
 256         unsigned int size;
 257         uint8_t *p;
 258
 259         p = pkt->data + pkt->size - 8 - 5;
 260         for (i=1; ; i++){
 261             size = AV_RB32(p);
 262             if (size>INT_MAX || p - pkt->data < size)
 263                 return 0;
 264             if (p[4]&128)
 265                 break;
 266             p-= size+5;
 267         }
 268
 269         pkt->side_data = av_malloc(i * sizeof(*pkt->side_data));
 270         if (!pkt->side_data)
 271             return AVERROR(ENOMEM);
 272
 273         p= pkt->data + pkt->size - 8 - 5;
 274         for (i=0; ; i++){
 275             size= AV_RB32(p);
 276             av_assert0(size<=INT_MAX && p - pkt->data >= size);
 277             pkt->side_data[i].data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 278             pkt->side_data[i].size = size;
 279             pkt->side_data[i].type = p[4]&127;
 280             if (!pkt->side_data[i].data)
 281                 return AVERROR(ENOMEM);
 282             memcpy(pkt->side_data[i].data, p-size, size);
 283             pkt->size -= size + 5;
 284             if(p[4]&128)
 285                 break;
 286             p-= size+5;
 287         }
 288         pkt->size -= 8;
 289         pkt->side_data_elems = i+1;
 290         return 1;
 291     }
 292     return 0;
 293 }
 294
 295 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 296                                int size)
 297 {
 298     int i;
 299
 300     for (i = 0; i < pkt->side_data_elems; i++) {
 301         if (pkt->side_data[i].type == type) {
 302             if (size > pkt->side_data[i].size)
 303                 return AVERROR(ENOMEM);
 304             pkt->side_data[i].size = size;
 305             return 0;
 306         }
 307     }
 308     return AVERROR(ENOENT);
 309 }