avpacket: Replace av_free_packet with av_packet_unref

`av_packet_unref` matches the AVFrame ref-counted API and can be used as
a drop in replacement.

Deprecate `av_free_packet`.
pull/155/head
Luca Barbato 9 years ago
parent a5d4204309
commit ce70f28a17
  1. 10
      avconv.c
  2. 14
      avplay.c
  3. 4
      doc/APIchanges
  4. 6
      doc/examples/avcodec.c
  5. 10
      doc/examples/transcode_aac.c
  6. 33
      libavcodec/avcodec.h
  7. 6
      libavcodec/avpacket.c
  8. 2
      libavcodec/jpeglsenc.c
  9. 2
      libavcodec/libxvid.c
  10. 2
      libavcodec/mpegvideo_enc.c
  11. 8
      libavcodec/utils.c
  12. 5
      libavcodec/version.h
  13. 4
      libavdevice/alsa_dec.c
  14. 2
      libavdevice/jack.c
  15. 2
      libavdevice/oss_dec.c
  16. 2
      libavdevice/pulse.c
  17. 2
      libavdevice/sndio_dec.c
  18. 2
      libavdevice/v4l2.c
  19. 2
      libavdevice/vfwcap.c
  20. 4
      libavfilter/vsrc_movie.c
  21. 2
      libavformat/4xm.c
  22. 4
      libavformat/adxdec.c
  23. 2
      libavformat/amr.c
  24. 14
      libavformat/asfdec.c
  25. 4
      libavformat/avformat.h
  26. 6
      libavformat/avidec.c
  27. 2
      libavformat/avs.c
  28. 2
      libavformat/c93.c
  29. 2
      libavformat/cdg.c
  30. 2
      libavformat/cdxl.c
  31. 4
      libavformat/dfa.c
  32. 2
      libavformat/dsicin.c
  33. 6
      libavformat/dss.c
  34. 2
      libavformat/dxa.c
  35. 2
      libavformat/electronicarts.c
  36. 4
      libavformat/flic.c
  37. 2
      libavformat/g723_1.c
  38. 2
      libavformat/gsmdec.c
  39. 6
      libavformat/hls.c
  40. 2
      libavformat/hnm.c
  41. 4
      libavformat/idcin.c
  42. 2
      libavformat/ilbc.c
  43. 2
      libavformat/img2dec.c
  44. 2
      libavformat/ingenientdec.c
  45. 2
      libavformat/internal.h
  46. 4
      libavformat/ipmovie.c
  47. 2
      libavformat/iv8.c
  48. 2
      libavformat/lxfdec.c
  49. 4
      libavformat/matroskadec.c
  50. 4
      libavformat/matroskaenc.c
  51. 2
      libavformat/mmf.c
  52. 2
      libavformat/mp3enc.c
  53. 4
      libavformat/mpc.c
  54. 2
      libavformat/mpegts.c
  55. 6
      libavformat/mux.c
  56. 2
      libavformat/mxfenc.c
  57. 2
      libavformat/ncdec.c
  58. 4
      libavformat/nsvdec.c
  59. 2
      libavformat/nuv.c
  60. 4
      libavformat/psxstr.c
  61. 2
      libavformat/rawdec.c
  62. 2
      libavformat/rl2.c
  63. 6
      libavformat/rmdec.c
  64. 4
      libavformat/rpl.c
  65. 2
      libavformat/rtpdec_asf.c
  66. 2
      libavformat/rtpdec_mpa_robust.c
  67. 2
      libavformat/rtpdec_qt.c
  68. 2
      libavformat/rtpdec_xiph.c
  69. 2
      libavformat/sapdec.c
  70. 2
      libavformat/seek-test.c
  71. 2
      libavformat/sierravmd.c
  72. 6
      libavformat/spdifdec.c
  73. 4
      libavformat/thp.c
  74. 18
      libavformat/utils.c
  75. 2
      libavformat/vqf.c
  76. 2
      libavformat/wc3movie.c
  77. 2
      libavformat/westwood_vqa.c
  78. 10
      libavformat/wvdec.c
  79. 6
      libavformat/yop.c
  80. 2
      tools/pktdumper.c

@ -270,7 +270,7 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
*/ */
if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) { if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
if (ost->frame_number >= ost->max_frames) { if (ost->frame_number >= ost->max_frames) {
av_free_packet(pkt); av_packet_unref(pkt);
return; return;
} }
ost->frame_number++; ost->frame_number++;
@ -288,7 +288,7 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
pkt->data, pkt->size, pkt->data, pkt->size,
pkt->flags & AV_PKT_FLAG_KEY); pkt->flags & AV_PKT_FLAG_KEY);
if (a > 0) { if (a > 0) {
av_free_packet(pkt); av_packet_unref(pkt);
new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size, new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
av_buffer_default_free, NULL, 0); av_buffer_default_free, NULL, 0);
if (!new_pkt.buf) if (!new_pkt.buf)
@ -2158,7 +2158,7 @@ static void free_input_threads(void)
pthread_mutex_lock(&f->fifo_lock); pthread_mutex_lock(&f->fifo_lock);
while (av_fifo_size(f->fifo)) { while (av_fifo_size(f->fifo)) {
av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL); av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
pthread_cond_signal(&f->fifo_cond); pthread_cond_signal(&f->fifo_cond);
pthread_mutex_unlock(&f->fifo_lock); pthread_mutex_unlock(&f->fifo_lock);
@ -2168,7 +2168,7 @@ static void free_input_threads(void)
while (av_fifo_size(f->fifo)) { while (av_fifo_size(f->fifo)) {
av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL); av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
av_fifo_free(f->fifo); av_fifo_free(f->fifo);
} }
@ -2483,7 +2483,7 @@ static int process_input(void)
process_input_packet(ist, &pkt, 0); process_input_packet(ist, &pkt, 0);
discard_packet: discard_packet:
av_free_packet(&pkt); av_packet_unref(&pkt);
return 0; return 0;
} }

@ -299,7 +299,7 @@ static void packet_queue_flush(PacketQueue *q)
SDL_LockMutex(q->mutex); SDL_LockMutex(q->mutex);
for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) { for (pkt = q->first_pkt; pkt != NULL; pkt = pkt1) {
pkt1 = pkt->next; pkt1 = pkt->next;
av_free_packet(&pkt->pkt); av_packet_unref(&pkt->pkt);
av_freep(&pkt); av_freep(&pkt);
} }
q->last_pkt = NULL; q->last_pkt = NULL;
@ -1617,7 +1617,7 @@ static int video_thread(void *arg)
while (is->paused && !is->videoq.abort_request) while (is->paused && !is->videoq.abort_request)
SDL_Delay(10); SDL_Delay(10);
av_free_packet(&pkt); av_packet_unref(&pkt);
ret = get_video_frame(is, frame, &pts_int, &pkt); ret = get_video_frame(is, frame, &pts_int, &pkt);
if (ret < 0) if (ret < 0)
@ -1684,7 +1684,7 @@ static int video_thread(void *arg)
av_freep(&vfilters); av_freep(&vfilters);
avfilter_graph_free(&graph); avfilter_graph_free(&graph);
#endif #endif
av_free_packet(&pkt); av_packet_unref(&pkt);
av_frame_free(&frame); av_frame_free(&frame);
return 0; return 0;
} }
@ -1753,7 +1753,7 @@ static int subtitle_thread(void *arg)
is->subpq_size++; is->subpq_size++;
SDL_UnlockMutex(is->subpq_mutex); SDL_UnlockMutex(is->subpq_mutex);
} }
av_free_packet(pkt); av_packet_unref(pkt);
} }
return 0; return 0;
} }
@ -1984,7 +1984,7 @@ static int audio_decode_frame(VideoState *is, double *pts_ptr)
/* free the current packet */ /* free the current packet */
if (pkt->data) if (pkt->data)
av_free_packet(pkt); av_packet_unref(pkt);
memset(pkt_temp, 0, sizeof(*pkt_temp)); memset(pkt_temp, 0, sizeof(*pkt_temp));
if (is->paused || is->audioq.abort_request) { if (is->paused || is->audioq.abort_request) {
@ -2181,7 +2181,7 @@ static void stream_component_close(VideoState *is, int stream_index)
SDL_CloseAudio(); SDL_CloseAudio();
packet_queue_end(&is->audioq); packet_queue_end(&is->audioq);
av_free_packet(&is->audio_pkt); av_packet_unref(&is->audio_pkt);
if (is->avr) if (is->avr)
avresample_free(&is->avr); avresample_free(&is->avr);
av_freep(&is->audio_buf1); av_freep(&is->audio_buf1);
@ -2490,7 +2490,7 @@ static int decode_thread(void *arg)
} else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) { } else if (pkt->stream_index == is->subtitle_stream && pkt_in_play_range) {
packet_queue_put(&is->subtitleq, pkt); packet_queue_put(&is->subtitleq, pkt);
} else { } else {
av_free_packet(pkt); av_packet_unref(pkt);
} }
} }
/* wait until the end */ /* wait until the end */

@ -13,6 +13,10 @@ libavutil: 2015-08-28
API changes, most recent first: API changes, most recent first:
2015-xx-xx - xxxxxxx - lavc 57.7.0 - avcodec.h
Deprecate av_free_packet(). Use av_packet_unref() as replacement,
it resets the packet in a more consistent way.
2015-xx-xx - xxxxxxx - lavc 57.5.0 - avcodec.h 2015-xx-xx - xxxxxxx - lavc 57.5.0 - avcodec.h
Add data and linesize array to AVSubtitleRect, to be used instead of Add data and linesize array to AVSubtitleRect, to be used instead of
the ones from the embedded AVPicture. the ones from the embedded AVPicture.

@ -206,7 +206,7 @@ static void audio_encode_example(const char *filename)
} }
if (got_output) { if (got_output) {
fwrite(pkt.data, 1, pkt.size, f); fwrite(pkt.data, 1, pkt.size, f);
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
} }
fclose(f); fclose(f);
@ -403,7 +403,7 @@ static void video_encode_example(const char *filename)
if (got_output) { if (got_output) {
printf("encoding frame %3d (size=%5d)\n", i, pkt.size); printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
fwrite(pkt.data, 1, pkt.size, f); fwrite(pkt.data, 1, pkt.size, f);
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
} }
@ -420,7 +420,7 @@ static void video_encode_example(const char *filename)
if (got_output) { if (got_output) {
printf("encoding frame %3d (size=%5d)\n", i, pkt.size); printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
fwrite(pkt.data, 1, pkt.size, f); fwrite(pkt.data, 1, pkt.size, f);
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
} }

@ -337,7 +337,7 @@ static int decode_audio_frame(AVFrame *frame,
data_present, &input_packet)) < 0) { data_present, &input_packet)) < 0) {
fprintf(stderr, "Could not decode frame (error '%s')\n", fprintf(stderr, "Could not decode frame (error '%s')\n",
get_error_text(error)); get_error_text(error));
av_free_packet(&input_packet); av_packet_unref(&input_packet);
return error; return error;
} }
@ -347,7 +347,7 @@ static int decode_audio_frame(AVFrame *frame,
*/ */
if (*finished && *data_present) if (*finished && *data_present)
*finished = 0; *finished = 0;
av_free_packet(&input_packet); av_packet_unref(&input_packet);
return 0; return 0;
} }
@ -585,7 +585,7 @@ static int encode_audio_frame(AVFrame *frame,
frame, data_present)) < 0) { frame, data_present)) < 0) {
fprintf(stderr, "Could not encode frame (error '%s')\n", fprintf(stderr, "Could not encode frame (error '%s')\n",
get_error_text(error)); get_error_text(error));
av_free_packet(&output_packet); av_packet_unref(&output_packet);
return error; return error;
} }
@ -594,11 +594,11 @@ static int encode_audio_frame(AVFrame *frame,
if ((error = av_write_frame(output_format_context, &output_packet)) < 0) { if ((error = av_write_frame(output_format_context, &output_packet)) < 0) {
fprintf(stderr, "Could not write frame (error '%s')\n", fprintf(stderr, "Could not write frame (error '%s')\n",
get_error_text(error)); get_error_text(error));
av_free_packet(&output_packet); av_packet_unref(&output_packet);
return error; return error;
} }
av_free_packet(&output_packet); av_packet_unref(&output_packet);
} }
return 0; return 0;

@ -1151,15 +1151,19 @@ typedef struct AVPacketSideData {
* ABI. Thus it may be allocated on stack and no new fields can be added to it * ABI. Thus it may be allocated on stack and no new fields can be added to it
* without libavcodec and libavformat major bump. * without libavcodec and libavformat major bump.
* *
* The semantics of data ownership depends on the buf or destruct (deprecated) * The semantics of data ownership depends on the buf field.
* fields. If either is set, the packet data is dynamically allocated and is * If it is set, the packet data is dynamically allocated and is
* valid indefinitely until av_free_packet() is called (which in turn calls * valid indefinitely until a call to av_packet_unref() reduces the
* av_buffer_unref()/the destruct callback to free the data). If neither is set, * reference count to 0.
* the packet data is typically backed by some static buffer somewhere and is
* only valid for a limited time (e.g. until the next read call when demuxing).
* *
* The side data is always allocated with av_malloc() and is freed in * If the buf field is not set av_packet_ref() would make a copy instead
* av_free_packet(). * of increasing the reference count.
*
* The side data is always allocated with av_malloc(), copied by
* av_packet_ref() and freed by av_packet_unref().
*
* @see av_packet_ref
* @see av_packet_unref
*/ */
typedef struct AVPacket { typedef struct AVPacket {
/** /**
@ -3477,14 +3481,17 @@ int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
* packet is allocated if it was not really allocated. * packet is allocated if it was not really allocated.
*/ */
int av_dup_packet(AVPacket *pkt); int av_dup_packet(AVPacket *pkt);
#if FF_API_AVPACKET_OLD_API
/** /**
* Free a packet. * Free a packet.
* *
* @deprecated Use av_packet_unref
*
* @param pkt packet to free * @param pkt packet to free
*/ */
attribute_deprecated
void av_free_packet(AVPacket *pkt); void av_free_packet(AVPacket *pkt);
#endif
/** /**
* Allocate new information of a packet. * Allocate new information of a packet.
* *
@ -4070,8 +4077,7 @@ AVCodec *avcodec_find_encoder_by_name(const char *name);
* output packet. * output packet.
* *
* If this function fails or produces no output, avpkt will be * If this function fails or produces no output, avpkt will be
* freed using av_free_packet() (i.e. avpkt->destruct will be * freed using av_packet_unref().
* called to free the user supplied buffer).
* @param[in] frame AVFrame containing the raw audio data to be encoded. * @param[in] frame AVFrame containing the raw audio data to be encoded.
* May be NULL when flushing an encoder that has the * May be NULL when flushing an encoder that has the
* AV_CODEC_CAP_DELAY capability set. * AV_CODEC_CAP_DELAY capability set.
@ -4112,8 +4118,7 @@ int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
* caller, he is responsible for freeing it. * caller, he is responsible for freeing it.
* *
* If this function fails or produces no output, avpkt will be * If this function fails or produces no output, avpkt will be
* freed using av_free_packet() (i.e. avpkt->destruct will be * freed using av_packet_unref().
* called to free the user supplied buffer).
* @param[in] frame AVFrame containing the raw video data to be encoded. * @param[in] frame AVFrame containing the raw video data to be encoded.
* May be NULL when flushing an encoder that has the * May be NULL when flushing an encoder that has the
* AV_CODEC_CAP_DELAY capability set. * AV_CODEC_CAP_DELAY capability set.

@ -184,7 +184,7 @@ int av_dup_packet(AVPacket *pkt)
return 0; return 0;
failed_alloc: failed_alloc:
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@ -197,6 +197,8 @@ void av_packet_free_side_data(AVPacket *pkt)
pkt->side_data_elems = 0; pkt->side_data_elems = 0;
} }
#if FF_API_AVPACKET_OLD_API
FF_DISABLE_DEPRECATION_WARNINGS
void av_free_packet(AVPacket *pkt) void av_free_packet(AVPacket *pkt)
{ {
if (pkt) { if (pkt) {
@ -208,6 +210,8 @@ void av_free_packet(AVPacket *pkt)
av_packet_free_side_data(pkt); av_packet_free_side_data(pkt);
} }
} }
FF_ENABLE_DEPRECATION_WARNINGS
#endif
uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size) int size)

@ -406,7 +406,7 @@ static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,
return 0; return 0;
memfail: memfail:
av_free_packet(pkt); av_packet_unref(pkt);
av_freep(&buf2); av_freep(&buf2);
av_freep(&state); av_freep(&state);
av_freep(&zero); av_freep(&zero);

@ -811,7 +811,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
return 0; return 0;
} else { } else {
if (!user_packet) if (!user_packet)
av_free_packet(pkt); av_packet_unref(pkt);
if (!xerr) if (!xerr)
return 0; return 0;
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,

@ -1146,7 +1146,7 @@ static int encode_frame(AVCodecContext *c, AVFrame *frame)
return ret; return ret;
ret = pkt.size; ret = pkt.size;
av_free_packet(&pkt); av_packet_unref(&pkt);
return ret; return ret;
} }

@ -1200,7 +1200,7 @@ int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
*got_packet_ptr = 0; *got_packet_ptr = 0;
if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) { if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
av_free_packet(avpkt); av_packet_unref(avpkt);
av_init_packet(avpkt); av_init_packet(avpkt);
return 0; return 0;
} }
@ -1276,7 +1276,7 @@ int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
} }
if (ret < 0 || !*got_packet_ptr) { if (ret < 0 || !*got_packet_ptr) {
av_free_packet(avpkt); av_packet_unref(avpkt);
av_init_packet(avpkt); av_init_packet(avpkt);
goto end; goto end;
} }
@ -1307,7 +1307,7 @@ int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
*got_packet_ptr = 0; *got_packet_ptr = 0;
if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) { if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
av_free_packet(avpkt); av_packet_unref(avpkt);
av_init_packet(avpkt); av_init_packet(avpkt);
avpkt->size = 0; avpkt->size = 0;
return 0; return 0;
@ -1335,7 +1335,7 @@ int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
} }
if (ret < 0 || !*got_packet_ptr) if (ret < 0 || !*got_packet_ptr)
av_free_packet(avpkt); av_packet_unref(avpkt);
emms_c(); emms_c();
return ret; return ret;

@ -29,7 +29,7 @@
#include "libavutil/version.h" #include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 57 #define LIBAVCODEC_VERSION_MAJOR 57
#define LIBAVCODEC_VERSION_MINOR 7 #define LIBAVCODEC_VERSION_MINOR 8
#define LIBAVCODEC_VERSION_MICRO 0 #define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
@ -174,5 +174,8 @@
#ifndef FF_API_AVPICTURE #ifndef FF_API_AVPICTURE
#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59) #define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59)
#endif #endif
#ifndef FF_API_AVPACKET_OLD_API
#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#endif /* AVCODEC_VERSION_H */ #endif /* AVCODEC_VERSION_H */

@ -128,14 +128,14 @@ static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
while ((res = snd_pcm_readi(s->h, pkt->data, pkt->size / s->frame_size)) < 0) { while ((res = snd_pcm_readi(s->h, pkt->data, pkt->size / s->frame_size)) < 0) {
if (res == -EAGAIN) { if (res == -EAGAIN) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
if (ff_alsa_xrun_recover(s1, res) < 0) { if (ff_alsa_xrun_recover(s1, res) < 0) {
av_log(s1, AV_LOG_ERROR, "ALSA read error: %s\n", av_log(s1, AV_LOG_ERROR, "ALSA read error: %s\n",
snd_strerror(res)); snd_strerror(res));
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -220,7 +220,7 @@ static void free_pkt_fifo(AVFifoBuffer *fifo)
AVPacket pkt; AVPacket pkt;
while (av_fifo_size(fifo)) { while (av_fifo_size(fifo)) {
av_fifo_generic_read(fifo, &pkt, sizeof(pkt), NULL); av_fifo_generic_read(fifo, &pkt, sizeof(pkt), NULL);
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
av_fifo_free(fifo); av_fifo_free(fifo);
} }

@ -82,7 +82,7 @@ static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
ret = read(s->fd, pkt->data, pkt->size); ret = read(s->fd, pkt->data, pkt->size);
if (ret <= 0){ if (ret <= 0){
av_free_packet(pkt); av_packet_unref(pkt);
pkt->size = 0; pkt->size = 0;
if (ret<0) return AVERROR(errno); if (ret<0) return AVERROR(errno);
else return AVERROR_EOF; else return AVERROR_EOF;

@ -133,7 +133,7 @@ static int pulse_read_packet(AVFormatContext *s, AVPacket *pkt)
if ((pa_simple_read(pd->s, pkt->data, pkt->size, &res)) < 0) { if ((pa_simple_read(pd->s, pkt->data, pkt->size, &res)) < 0) {
av_log(s, AV_LOG_ERROR, "pa_simple_read failed: %s\n", av_log(s, AV_LOG_ERROR, "pa_simple_read failed: %s\n",
pa_strerror(res)); pa_strerror(res));
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -67,7 +67,7 @@ static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
ret = sio_read(s->hdl, pkt->data, pkt->size); ret = sio_read(s->hdl, pkt->data, pkt->size);
if (ret == 0 || sio_eof(s->hdl)) { if (ret == 0 || sio_eof(s->hdl)) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR_EOF; return AVERROR_EOF;
} }

@ -508,7 +508,7 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
if (res < 0) { if (res < 0) {
res = AVERROR(errno); res = AVERROR(errno);
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF)\n"); av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF)\n");
av_free_packet(pkt); av_packet_unref(pkt);
return res; return res;
} }
avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1); avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);

@ -233,7 +233,7 @@ static int vfw_read_close(AVFormatContext *s)
pktl = ctx->pktl; pktl = ctx->pktl;
while (pktl) { while (pktl) {
AVPacketList *next = pktl->next; AVPacketList *next = pktl->next;
av_free_packet(&pktl->pkt); av_packet_unref(&pktl->pkt);
av_free(pktl); av_free(pktl);
pktl = next; pktl = next;
} }

@ -230,13 +230,13 @@ static int movie_get_frame(AVFilterLink *outlink)
movie->frame->sample_aspect_ratio.num, movie->frame->sample_aspect_ratio.num,
movie->frame->sample_aspect_ratio.den); movie->frame->sample_aspect_ratio.den);
// We got it. Free the packet since we are returning // We got it. Free the packet since we are returning
av_free_packet(&pkt); av_packet_unref(&pkt);
return 0; return 0;
} }
} }
// Free the packet that was allocated by av_read_frame // Free the packet that was allocated by av_read_frame
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
// On multi-frame source we should stop the mixing process when // On multi-frame source we should stop the mixing process when

@ -308,7 +308,7 @@ static int fourxm_read_packet(AVFormatContext *s,
ret = avio_read(s->pb, &pkt->data[8], size); ret = avio_read(s->pb, &pkt->data[8], size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
} else } else
packet_read = 1; packet_read = 1;
break; break;

@ -47,11 +47,11 @@ static int adx_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
if (ret != size) { if (ret != size) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR(EIO); return ret < 0 ? ret : AVERROR(EIO);
} }
if (AV_RB16(pkt->data) & 0x8000) { if (AV_RB16(pkt->data) & 0x8000) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR_EOF; return AVERROR_EOF;
} }
pkt->size = size; pkt->size = size;

@ -148,7 +148,7 @@ static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
read = avio_read(s->pb, pkt->data + 1, size - 1); read = avio_read(s->pb, pkt->data + 1, size - 1);
if (read != size - 1) { if (read != size - 1) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -444,7 +444,7 @@ static int asf_read_picture(AVFormatContext *s, int len)
fail: fail:
av_freep(&desc); av_freep(&desc);
av_free_packet(&pkt); av_packet_unref(&pkt);
return ret; return ret;
} }
@ -1128,7 +1128,7 @@ static void reset_packet(ASFPacket *asf_pkt)
asf_pkt->flags = 0; asf_pkt->flags = 0;
asf_pkt->dts = 0; asf_pkt->dts = 0;
asf_pkt->duration = 0; asf_pkt->duration = 0;
av_free_packet(&asf_pkt->avpkt); av_packet_unref(&asf_pkt->avpkt);
av_init_packet(&asf_pkt->avpkt); av_init_packet(&asf_pkt->avpkt);
} }
@ -1395,7 +1395,7 @@ static int asf_deinterleave(AVFormatContext *s, ASFPacket *asf_pkt, int st_num)
if (p > asf_pkt->avpkt.data + asf_pkt->data_size) if (p > asf_pkt->avpkt.data + asf_pkt->data_size)
break; break;
} }
av_free_packet(&asf_pkt->avpkt); av_packet_unref(&asf_pkt->avpkt);
asf_pkt->avpkt = pkt; asf_pkt->avpkt = pkt;
return 0; return 0;
@ -1485,7 +1485,7 @@ static int asf_read_close(AVFormatContext *s)
for (i = 0; i < ASF_MAX_STREAMS; i++) { for (i = 0; i < ASF_MAX_STREAMS; i++) {
av_dict_free(&asf->asf_sd[i].asf_met); av_dict_free(&asf->asf_sd[i].asf_met);
if (i < asf->nb_streams) { if (i < asf->nb_streams) {
av_free_packet(&asf->asf_st[i]->pkt.avpkt); av_packet_unref(&asf->asf_st[i]->pkt.avpkt);
av_freep(&asf->asf_st[i]); av_freep(&asf->asf_st[i]);
} }
} }
@ -1521,7 +1521,7 @@ static void reset_packet_state(AVFormatContext *s)
pkt->flags = 0; pkt->flags = 0;
pkt->dts = 0; pkt->dts = 0;
pkt->duration = 0; pkt->duration = 0;
av_free_packet(&pkt->avpkt); av_packet_unref(&pkt->avpkt);
av_init_packet(&pkt->avpkt); av_init_packet(&pkt->avpkt);
} }
} }
@ -1588,11 +1588,11 @@ static int64_t asf_read_timestamp(AVFormatContext *s, int stream_index,
} }
if (st_found) if (st_found)
break; break;
av_free_packet(&pkt); av_packet_unref(&pkt);
} }
*pos = pkt_pos; *pos = pkt_pos;
av_free_packet(&pkt); av_packet_unref(&pkt);
return dts; return dts;
} }

@ -165,7 +165,7 @@
* until the next av_read_frame() call or closing the file. If the caller * until the next av_read_frame() call or closing the file. If the caller
* requires a longer lifetime, av_dup_packet() will make an av_malloc()ed copy * requires a longer lifetime, av_dup_packet() will make an av_malloc()ed copy
* of it. * of it.
* In both cases, the packet must be freed with av_free_packet() when it is no * In both cases, the packet must be freed with av_packet_unref() when it is no
* longer needed. * longer needed.
* *
* @section lavf_decoding_seek Seeking * @section lavf_decoding_seek Seeking
@ -1491,7 +1491,7 @@ int av_find_best_stream(AVFormatContext *ic,
* If pkt->buf is NULL, then the packet is valid until the next * If pkt->buf is NULL, then the packet is valid until the next
* av_read_frame() or until avformat_close_input(). Otherwise the packet * av_read_frame() or until avformat_close_input(). Otherwise the packet
* is valid indefinitely. In both cases the packet must be freed with * is valid indefinitely. In both cases the packet must be freed with
* av_free_packet when it is no longer needed. For video, the packet contains * av_packet_unref when it is no longer needed. For video, the packet contains
* exactly one frame. For audio, it contains an integer number of frames if each * exactly one frame. For audio, it contains an integer number of frames if each
* frame has a known fixed size (e.g. PCM or ADPCM data). If the audio frames * frame has a known fixed size (e.g. PCM or ADPCM data). If the audio frames
* have a variable size (e.g. MPEG audio), then it contains one frame. * have a variable size (e.g. MPEG audio), then it contains one frame.

@ -1215,7 +1215,7 @@ resync:
pkt->buf = avbuf; pkt->buf = avbuf;
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
if (size < 0) if (size < 0)
av_free_packet(pkt); av_packet_unref(pkt);
} else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && } else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE &&
!st->codec->codec_tag && read_gab2_sub(st, pkt)) { !st->codec->codec_tag && read_gab2_sub(st, pkt)) {
ast->frame_offset++; ast->frame_offset++;
@ -1470,7 +1470,7 @@ static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
{ {
AVIStream *ast2 = st2->priv_data; AVIStream *ast2 = st2->priv_data;
int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base); int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base);
av_free_packet(&ast2->sub_pkt); av_packet_unref(&ast2->sub_pkt);
if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 || if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0) avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt); ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
@ -1587,7 +1587,7 @@ static int avi_read_close(AVFormatContext *s)
avformat_close_input(&ast->sub_ctx); avformat_close_input(&ast->sub_ctx);
} }
av_free(ast->sub_buffer); av_free(ast->sub_buffer);
av_free_packet(&ast->sub_pkt); av_packet_unref(&ast->sub_pkt);
} }
} }

@ -108,7 +108,7 @@ avs_read_video_packet(AVFormatContext * s, AVPacket * pkt,
pkt->data[palette_size + 3] = (size >> 8) & 0xFF; pkt->data[palette_size + 3] = (size >> 8) & 0xFF;
ret = avio_read(s->pb, pkt->data + palette_size + 4, size - 4) + 4; ret = avio_read(s->pb, pkt->data + palette_size + 4, size - 4) + 4;
if (ret < size) { if (ret < size) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -188,7 +188,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
return 0; return 0;
fail: fail:
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }

@ -62,7 +62,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_get_packet(s->pb, pkt, CDG_PACKET_SIZE); ret = av_get_packet(s->pb, pkt, CDG_PACKET_SIZE);
if (ret < 1 || (pkt->data[0] & CDG_MASK) == CDG_COMMAND) if (ret < 1 || (pkt->data[0] & CDG_MASK) == CDG_COMMAND)
break; break;
av_free_packet(pkt); av_packet_unref(pkt);
} }
if (!priv->got_first_packet) { if (!priv->got_first_packet) {

@ -146,7 +146,7 @@ static int cdxl_read_packet(AVFormatContext *s, AVPacket *pkt)
memcpy(pkt->data, cdxl->header, CDXL_HEADER_SIZE); memcpy(pkt->data, cdxl->header, CDXL_HEADER_SIZE);
ret = avio_read(pb, pkt->data + CDXL_HEADER_SIZE, video_size); ret = avio_read(pb, pkt->data + CDXL_HEADER_SIZE, video_size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
av_shrink_packet(pkt, CDXL_HEADER_SIZE + ret); av_shrink_packet(pkt, CDXL_HEADER_SIZE + ret);

@ -82,7 +82,7 @@ static int dfa_read_packet(AVFormatContext *s, AVPacket *pkt)
if (!first) { if (!first) {
ret = av_append_packet(pb, pkt, 12); ret = av_append_packet(pb, pkt, 12);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
} else } else
@ -103,7 +103,7 @@ static int dfa_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
ret = av_append_packet(pb, pkt, frame_size); ret = av_append_packet(pb, pkt, frame_size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
} }

@ -197,7 +197,7 @@ static int cin_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = avio_read(pb, &pkt->data[4], pkt_size); ret = avio_read(pb, &pkt->data[4], pkt_size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
if (ret < pkt_size) if (ret < pkt_size)

@ -256,7 +256,7 @@ static int dss_sp_read_packet(AVFormatContext *s, AVPacket *pkt)
return pkt->size; return pkt->size;
error_eof: error_eof:
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
} }
@ -294,7 +294,7 @@ static int dss_723_1_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = avio_read(s->pb, pkt->data + offset, ret = avio_read(s->pb, pkt->data + offset,
size2 - offset); size2 - offset);
if (ret < size2 - offset) { if (ret < size2 - offset) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
} }
@ -304,7 +304,7 @@ static int dss_723_1_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = avio_read(s->pb, pkt->data + offset, size - offset); ret = avio_read(s->pb, pkt->data + offset, size - offset);
if (ret < size - offset) { if (ret < size - offset) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
} }

@ -201,7 +201,7 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE); memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE);
ret = avio_read(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size); ret = avio_read(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size);
if(ret != size){ if(ret != size){
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }
if(pal_size) memcpy(pkt->data, pal, pal_size); if(pal_size) memcpy(pkt->data, pal, pal_size);

@ -567,7 +567,7 @@ static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
case AV_CODEC_ID_ADPCM_EA_R3: case AV_CODEC_ID_ADPCM_EA_R3:
if (pkt->size < 4) { if (pkt->size < 4) {
av_log(s, AV_LOG_ERROR, "Packet is too short\n"); av_log(s, AV_LOG_ERROR, "Packet is too short\n");
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (ea->audio_codec == AV_CODEC_ID_ADPCM_EA_R3) if (ea->audio_codec == AV_CODEC_ID_ADPCM_EA_R3)

@ -228,7 +228,7 @@ static int flic_read_packet(AVFormatContext *s,
ret = avio_read(pb, pkt->data + FLIC_PREAMBLE_SIZE, ret = avio_read(pb, pkt->data + FLIC_PREAMBLE_SIZE,
size - FLIC_PREAMBLE_SIZE); size - FLIC_PREAMBLE_SIZE);
if (ret != size - FLIC_PREAMBLE_SIZE) { if (ret != size - FLIC_PREAMBLE_SIZE) {
av_free_packet(pkt); av_packet_unref(pkt);
ret = AVERROR(EIO); ret = AVERROR(EIO);
} }
packet_read = 1; packet_read = 1;
@ -246,7 +246,7 @@ static int flic_read_packet(AVFormatContext *s,
ret = avio_read(pb, pkt->data, size); ret = avio_read(pb, pkt->data, size);
if (ret != size) { if (ret != size) {
av_free_packet(pkt); av_packet_unref(pkt);
ret = AVERROR(EIO); ret = AVERROR(EIO);
} }

@ -69,7 +69,7 @@ static int g723_1_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = avio_read(s->pb, pkt->data + 1, size - 1); ret = avio_read(s->pb, pkt->data + 1, size - 1);
if (ret < size - 1) { if (ret < size - 1) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
} }

@ -45,7 +45,7 @@ static int gsm_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
if (ret < GSM_BLOCK_SIZE) { if (ret < GSM_BLOCK_SIZE) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR(EIO); return ret < 0 ? ret : AVERROR(EIO);
} }
pkt->size = ret; pkt->size = ret;

@ -129,7 +129,7 @@ static void free_variant_list(HLSContext *c)
for (i = 0; i < c->n_variants; i++) { for (i = 0; i < c->n_variants; i++) {
struct variant *var = c->variants[i]; struct variant *var = c->variants[i];
free_segment_list(var); free_segment_list(var);
av_free_packet(&var->pkt); av_packet_unref(&var->pkt);
av_free(var->pb.buffer); av_free(var->pb.buffer);
if (var->input) if (var->input)
ffurl_close(var->input); ffurl_close(var->input);
@ -724,7 +724,7 @@ start:
c->seek_timestamp = AV_NOPTS_VALUE; c->seek_timestamp = AV_NOPTS_VALUE;
break; break;
} }
av_free_packet(&var->pkt); av_packet_unref(&var->pkt);
reset_packet(&var->pkt); reset_packet(&var->pkt);
} }
} }
@ -815,7 +815,7 @@ static int hls_read_seek(AVFormatContext *s, int stream_index,
ffurl_close(var->input); ffurl_close(var->input);
var->input = NULL; var->input = NULL;
} }
av_free_packet(&var->pkt); av_packet_unref(&var->pkt);
reset_packet(&var->pkt); reset_packet(&var->pkt);
var->pb.eof_reached = 0; var->pb.eof_reached = 0;
/* Clear any buffered data */ /* Clear any buffered data */

@ -190,7 +190,7 @@ static int hnm_read_close(AVFormatContext *s)
Hnm4DemuxContext *hnm = s->priv_data; Hnm4DemuxContext *hnm = s->priv_data;
if (hnm->vpkt.size > 0) if (hnm->vpkt.size > 0)
av_free_packet(&hnm->vpkt); av_packet_unref(&hnm->vpkt);
return 0; return 0;
} }

@ -309,7 +309,7 @@ static int idcin_read_packet(AVFormatContext *s,
return ret; return ret;
else if (ret != chunk_size) { else if (ret != chunk_size) {
av_log(s, AV_LOG_ERROR, "incomplete packet\n"); av_log(s, AV_LOG_ERROR, "incomplete packet\n");
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }
if (command == 1) { if (command == 1) {
@ -318,7 +318,7 @@ static int idcin_read_packet(AVFormatContext *s,
pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
AVPALETTE_SIZE); AVPALETTE_SIZE);
if (!pal) { if (!pal) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
memcpy(pal, palette, AVPALETTE_SIZE); memcpy(pal, palette, AVPALETTE_SIZE);

@ -112,7 +112,7 @@ static int ilbc_read_packet(AVFormatContext *s,
pkt->pos = avio_tell(s->pb); pkt->pos = avio_tell(s->pb);
pkt->duration = enc->block_align == 38 ? 160 : 240; pkt->duration = enc->block_align == 38 ? 160 : 240;
if ((ret = avio_read(s->pb, pkt->data, enc->block_align)) != enc->block_align) { if ((ret = avio_read(s->pb, pkt->data, enc->block_align)) != enc->block_align) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR(EIO); return ret < 0 ? ret : AVERROR(EIO);
} }

@ -280,7 +280,7 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
} }
if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) { if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); /* signal EOF */ return AVERROR(EIO); /* signal EOF */
} else { } else {
s->img_count++; s->img_count++;

@ -51,7 +51,7 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->stream_index = 0; pkt->stream_index = 0;
ret = avio_read(s->pb, pkt->data, size); ret = avio_read(s->pb, pkt->data, size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
pkt->size = ret; pkt->size = ret;

@ -348,7 +348,7 @@ int ff_read_packet(AVFormatContext *s, AVPacket *pkt);
* Interleave a packet per dts in an output media file. * Interleave a packet per dts in an output media file.
* *
* Packets with pkt->destruct == av_destruct_packet will be freed inside this * Packets with pkt->destruct == av_destruct_packet will be freed inside this
* function, so they cannot be used after it. Note that calling av_free_packet() * function, so they cannot be used after it. Note that calling av_packet_unref()
* on them is still safe. * on them is still safe.
* *
* @param s media file handle * @param s media file handle

@ -180,7 +180,7 @@ static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
if (avio_read(pb, pkt->data, s->decode_map_chunk_size) != if (avio_read(pb, pkt->data, s->decode_map_chunk_size) !=
s->decode_map_chunk_size) { s->decode_map_chunk_size) {
av_free_packet(pkt); av_packet_unref(pkt);
return CHUNK_EOF; return CHUNK_EOF;
} }
@ -189,7 +189,7 @@ static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
if (avio_read(pb, pkt->data + s->decode_map_chunk_size, if (avio_read(pb, pkt->data + s->decode_map_chunk_size,
s->video_chunk_size) != s->video_chunk_size) { s->video_chunk_size) != s->video_chunk_size) {
av_free_packet(pkt); av_packet_unref(pkt);
return CHUNK_EOF; return CHUNK_EOF;
} }

@ -92,7 +92,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_append_packet(s->pb, pkt, size); ret = av_append_packet(s->pb, pkt, size);
if (ret < 0) { if (ret < 0) {
av_log(s, AV_LOG_ERROR, "failed to grow packet\n"); av_log(s, AV_LOG_ERROR, "failed to grow packet\n");
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
} }

@ -315,7 +315,7 @@ static int lxf_read_packet(AVFormatContext *s, AVPacket *pkt)
return ret2; return ret2;
if ((ret2 = avio_read(pb, pkt->data, ret)) != ret) { if ((ret2 = avio_read(pb, pkt->data, ret)) != ret) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret2 < 0 ? ret2 : AVERROR_EOF; return ret2 < 0 ? ret2 : AVERROR_EOF;
} }

@ -1227,7 +1227,7 @@ static int matroska_merge_packets(AVPacket *out, AVPacket *in)
memcpy(out->data + old_size, in->data, in->size); memcpy(out->data + old_size, in->data, in->size);
av_free_packet(in); av_packet_unref(in);
av_free(in); av_free(in);
return 0; return 0;
} }
@ -1997,7 +1997,7 @@ static void matroska_clear_queue(MatroskaDemuxContext *matroska)
if (matroska->packets) { if (matroska->packets) {
int n; int n;
for (n = 0; n < matroska->num_packets; n++) { for (n = 0; n < matroska->num_packets; n++) {
av_free_packet(matroska->packets[n]); av_packet_unref(matroska->packets[n]);
av_free(matroska->packets[n]); av_free(matroska->packets[n]);
} }
av_freep(&matroska->packets); av_freep(&matroska->packets);

@ -1597,7 +1597,7 @@ static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
// check if we have an audio packet cached // check if we have an audio packet cached
if (mkv->cur_audio_pkt.size > 0) { if (mkv->cur_audio_pkt.size > 0) {
ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt); ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
av_free_packet(&mkv->cur_audio_pkt); av_packet_unref(&mkv->cur_audio_pkt);
if (ret < 0) { if (ret < 0) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Could not write cached audio packet ret:%d\n", ret); "Could not write cached audio packet ret:%d\n", ret);
@ -1653,7 +1653,7 @@ static int mkv_write_trailer(AVFormatContext *s)
// check if we have an audio packet cached // check if we have an audio packet cached
if (mkv->cur_audio_pkt.size > 0) { if (mkv->cur_audio_pkt.size > 0) {
ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt); ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
av_free_packet(&mkv->cur_audio_pkt); av_packet_unref(&mkv->cur_audio_pkt);
if (ret < 0) { if (ret < 0) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Could not write cached audio packet ret:%d\n", ret); "Could not write cached audio packet ret:%d\n", ret);

@ -292,7 +292,7 @@ static int mmf_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = avio_read(s->pb, pkt->data, pkt->size); ret = avio_read(s->pb, pkt->data, pkt->size);
if (ret < 0) if (ret < 0)
av_free_packet(pkt); av_packet_unref(pkt);
mmf->data_size -= ret; mmf->data_size -= ret;

@ -341,7 +341,7 @@ static int mp3_queue_flush(AVFormatContext *s)
while ((pktl = mp3->queue)) { while ((pktl = mp3->queue)) {
if (write && (ret = mp3_write_audio_packet(s, &pktl->pkt)) < 0) if (write && (ret = mp3_write_audio_packet(s, &pktl->pkt)) < 0)
write = 0; write = 0;
av_free_packet(&pktl->pkt); av_packet_unref(&pktl->pkt);
mp3->queue = pktl->next; mp3->queue = pktl->next;
av_freep(&pktl); av_freep(&pktl);
} }

@ -167,7 +167,7 @@ static int mpc_read_packet(AVFormatContext *s, AVPacket *pkt)
if(c->curbits) if(c->curbits)
avio_seek(s->pb, -4, SEEK_CUR); avio_seek(s->pb, -4, SEEK_CUR);
if(ret < size){ if(ret < size){
av_free_packet(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR(EIO); return ret < 0 ? ret : AVERROR(EIO);
} }
pkt->size = ret + 4; pkt->size = ret + 4;
@ -218,7 +218,7 @@ static int mpc_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
c->curframe = lastframe; c->curframe = lastframe;
return ret; return ret;
} }
av_free_packet(pkt); av_packet_unref(pkt);
} }
return 0; return 0;
} }

@ -2162,7 +2162,7 @@ static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = read_packet(s, pkt->data, ts->raw_packet_size, &data); ret = read_packet(s, pkt->data, ts->raw_packet_size, &data);
pkt->pos = avio_tell(s->pb); pkt->pos = avio_tell(s->pb);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
if (data != pkt->data) if (data != pkt->data)

@ -544,7 +544,7 @@ static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, in
if (s->oformat->interleave_packet) { if (s->oformat->interleave_packet) {
int ret = s->oformat->interleave_packet(s, out, in, flush); int ret = s->oformat->interleave_packet(s, out, in, flush);
if (in) if (in)
av_free_packet(in); av_packet_unref(in);
return ret; return ret;
} else } else
return ff_interleave_packet_per_dts(s, out, in, flush); return ff_interleave_packet_per_dts(s, out, in, flush);
@ -590,7 +590,7 @@ int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
if (ret >= 0) if (ret >= 0)
s->streams[opkt.stream_index]->nb_frames++; s->streams[opkt.stream_index]->nb_frames++;
av_free_packet(&opkt); av_packet_unref(&opkt);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -616,7 +616,7 @@ int av_write_trailer(AVFormatContext *s)
if (ret >= 0) if (ret >= 0)
s->streams[pkt.stream_index]->nb_frames++; s->streams[pkt.stream_index]->nb_frames++;
av_free_packet(&pkt); av_packet_unref(&pkt);
if (ret < 0) if (ret < 0)
goto fail; goto fail;

@ -1855,7 +1855,7 @@ static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, AVPacket
if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl) if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl)
s->streams[pktl->pkt.stream_index]->last_in_packet_buffer= NULL; s->streams[pktl->pkt.stream_index]->last_in_packet_buffer= NULL;
av_free_packet(&pktl->pkt); av_packet_unref(&pktl->pkt);
av_freep(&pktl); av_freep(&pktl);
pktl = next; pktl = next;
} }

@ -83,7 +83,7 @@ static int nc_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
if (ret != size) { if (ret != size) {
if (ret > 0) av_free_packet(pkt); if (ret > 0) av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -711,9 +711,9 @@ static int nsv_read_close(AVFormatContext *s)
av_freep(&nsv->nsvs_file_offset); av_freep(&nsv->nsvs_file_offset);
av_freep(&nsv->nsvs_timestamps); av_freep(&nsv->nsvs_timestamps);
if (nsv->ahead[0].data) if (nsv->ahead[0].data)
av_free_packet(&nsv->ahead[0]); av_packet_unref(&nsv->ahead[0]);
if (nsv->ahead[1].data) if (nsv->ahead[1].data)
av_free_packet(&nsv->ahead[1]); av_packet_unref(&nsv->ahead[1]);
return 0; return 0;
} }

@ -276,7 +276,7 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt)
memcpy(pkt->data, hdr, copyhdrsize); memcpy(pkt->data, hdr, copyhdrsize);
ret = avio_read(pb, pkt->data + copyhdrsize, size); ret = avio_read(pb, pkt->data + copyhdrsize, size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
if (ret < size) if (ret < size)

@ -184,7 +184,7 @@ static int str_read_packet(AVFormatContext *s,
if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){ if(pkt->size != sector_count*VIDEO_DATA_CHUNK_SIZE){
if(pkt->data) if(pkt->data)
av_log(s, AV_LOG_ERROR, "missmatching sector_count\n"); av_log(s, AV_LOG_ERROR, "missmatching sector_count\n");
av_free_packet(pkt); av_packet_unref(pkt);
if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE)) if (av_new_packet(pkt, sector_count*VIDEO_DATA_CHUNK_SIZE))
return AVERROR(EIO); return AVERROR(EIO);
@ -263,7 +263,7 @@ static int str_read_close(AVFormatContext *s)
int i; int i;
for(i=0; i<32; i++){ for(i=0; i<32; i++){
if(str->channels[i].tmp_pkt.data) if(str->channels[i].tmp_pkt.data)
av_free_packet(&str->channels[i].tmp_pkt); av_packet_unref(&str->channels[i].tmp_pkt);
} }
return 0; return 0;

@ -44,7 +44,7 @@ int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
pkt->stream_index = 0; pkt->stream_index = 0;
ret = ffio_read_partial(s->pb, pkt->data, size); ret = ffio_read_partial(s->pb, pkt->data, size);
if (ret < 0) { if (ret < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} else if (ret < size) { } else if (ret < size) {
/* initialize end of packet for partial reads to avoid reading /* initialize end of packet for partial reads to avoid reading

@ -245,7 +245,7 @@ static int rl2_read_packet(AVFormatContext *s,
/** fill the packet */ /** fill the packet */
ret = av_get_packet(pb, pkt, sample->size); ret = av_get_packet(pb, pkt, sample->size);
if(ret != sample->size){ if(ret != sample->size){
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -117,7 +117,7 @@ RMStream *ff_rm_alloc_rmstream (void)
void ff_rm_free_rmstream (RMStream *rms) void ff_rm_free_rmstream (RMStream *rms)
{ {
av_free_packet(&rms->pkt); av_packet_unref(&rms->pkt);
} }
static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb, static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
@ -659,7 +659,7 @@ static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb,
if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){ if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){
vst->slices = ((hdr & 0x3F) << 1) + 1; vst->slices = ((hdr & 0x3F) << 1) + 1;
vst->videobufsize = len2 + 8*vst->slices + 1; vst->videobufsize = len2 + 8*vst->slices + 1;
av_free_packet(&vst->pkt); //FIXME this should be output. av_packet_unref(&vst->pkt); //FIXME this should be output.
if(av_new_packet(&vst->pkt, vst->videobufsize) < 0) if(av_new_packet(&vst->pkt, vst->videobufsize) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->videobufpos = 8*vst->slices + 1; vst->videobufpos = 8*vst->slices + 1;
@ -879,7 +879,7 @@ static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
if( (st->discard >= AVDISCARD_NONKEY && !(flags&2)) if( (st->discard >= AVDISCARD_NONKEY && !(flags&2))
|| st->discard >= AVDISCARD_ALL){ || st->discard >= AVDISCARD_ALL){
av_free_packet(pkt); av_packet_unref(pkt);
} else } else
break; break;
} }

@ -310,7 +310,7 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_get_packet(pb, pkt, frame_size); ret = av_get_packet(pb, pkt, frame_size);
if (ret != frame_size) { if (ret != frame_size) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }
pkt->duration = 1; pkt->duration = 1;
@ -325,7 +325,7 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
} else { } else {
ret = av_get_packet(pb, pkt, index_entry->size); ret = av_get_packet(pb, pkt, index_entry->size);
if (ret != index_entry->size) { if (ret != index_entry->size) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -274,7 +274,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf,
return 1; // FIXME: return 0 if last packet return 1; // FIXME: return 0 if last packet
} }
} }
av_free_packet(pkt); av_packet_unref(pkt);
} }
return res == 1 ? -1 : res; return res == 1 ? -1 : res;

@ -136,7 +136,7 @@ static int mpa_robust_parse_packet(AVFormatContext *ctx, PayloadContext *data,
data->split_pos = 0; data->split_pos = 0;
if (!data->split_buf) { if (!data->split_buf) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n"); av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
memcpy(data->split_buf, buf, data->split_buf_size); memcpy(data->split_buf, buf, data->split_buf_size);

@ -217,7 +217,7 @@ static int qt_rtp_parse_packet(AVFormatContext *s, PayloadContext *qt,
av_freep(&qt->pkt.data); av_freep(&qt->pkt.data);
qt->pkt.data = av_realloc(NULL, qt->remaining * qt->bytes_per_frame); qt->pkt.data = av_realloc(NULL, qt->remaining * qt->bytes_per_frame);
if (!qt->pkt.data) { if (!qt->pkt.data) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
qt->pkt.size = qt->remaining * qt->bytes_per_frame; qt->pkt.size = qt->remaining * qt->bytes_per_frame;

@ -141,7 +141,7 @@ static int xiph_handle_packet(AVFormatContext *ctx, PayloadContext *data,
data->split_buf = av_malloc(data->split_buf_size); data->split_buf = av_malloc(data->split_buf_size);
if (!data->split_buf) { if (!data->split_buf) {
av_log(ctx, AV_LOG_ERROR, "Out of memory.\n"); av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
} }

@ -215,7 +215,7 @@ static int sap_fetch_packet(AVFormatContext *s, AVPacket *pkt)
int i = s->nb_streams; int i = s->nb_streams;
AVStream *st = avformat_new_stream(s, NULL); AVStream *st = avformat_new_stream(s, NULL);
if (!st) { if (!st) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
st->id = i; st->id = i;

@ -102,7 +102,7 @@ int main(int argc, char **argv)
ts_str(dts_buf, pkt.dts, st->time_base); ts_str(dts_buf, pkt.dts, st->time_base);
ts_str(ts_buf, pkt.pts, st->time_base); ts_str(ts_buf, pkt.pts, st->time_base);
printf("ret:%-10s st:%2d flags:%d dts:%s pts:%s pos:%7" PRId64 " size:%6d", ret_str(ret), pkt.stream_index, pkt.flags, dts_buf, ts_buf, pkt.pos, pkt.size); printf("ret:%-10s st:%2d flags:%d dts:%s pts:%s pos:%7" PRId64 " size:%6d", ret_str(ret), pkt.stream_index, pkt.flags, dts_buf, ts_buf, pkt.pos, pkt.size);
av_free_packet(&pkt); av_packet_unref(&pkt);
} else } else
printf("ret:%s", ret_str(ret)); // necessary to avoid trailing whitespace printf("ret:%s", ret_str(ret)); // necessary to avoid trailing whitespace
printf("\n"); printf("\n");

@ -271,7 +271,7 @@ static int vmd_read_packet(AVFormatContext *s,
frame->frame_size); frame->frame_size);
if (ret != frame->frame_size) { if (ret != frame->frame_size) {
av_free_packet(pkt); av_packet_unref(pkt);
ret = AVERROR(EIO); ret = AVERROR(EIO);
} }
pkt->stream_index = frame->stream_index; pkt->stream_index = frame->stream_index;

@ -188,7 +188,7 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->pos = avio_tell(pb) - BURST_HEADER_SIZE; pkt->pos = avio_tell(pb) - BURST_HEADER_SIZE;
if (avio_read(pb, pkt->data, pkt->size) < pkt->size) { if (avio_read(pb, pkt->data, pkt->size) < pkt->size) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR_EOF; return AVERROR_EOF;
} }
ff_spdif_bswap_buf16((uint16_t *)pkt->data, (uint16_t *)pkt->data, pkt->size >> 1); ff_spdif_bswap_buf16((uint16_t *)pkt->data, (uint16_t *)pkt->data, pkt->size >> 1);
@ -196,7 +196,7 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = spdif_get_offset_and_codec(s, data_type, pkt->data, ret = spdif_get_offset_and_codec(s, data_type, pkt->data,
&offset, &codec_id); &offset, &codec_id);
if (ret) { if (ret) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
@ -207,7 +207,7 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
/* first packet, create a stream */ /* first packet, create a stream */
AVStream *st = avformat_new_stream(s, NULL); AVStream *st = avformat_new_stream(s, NULL);
if (!st) { if (!st) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

@ -168,7 +168,7 @@ static int thp_read_packet(AVFormatContext *s,
ret = av_get_packet(pb, pkt, size); ret = av_get_packet(pb, pkt, size);
if (ret != size) { if (ret != size) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }
@ -176,7 +176,7 @@ static int thp_read_packet(AVFormatContext *s,
} else { } else {
ret = av_get_packet(pb, pkt, thp->audiosize); ret = av_get_packet(pb, pkt, thp->audiosize);
if (ret != thp->audiosize) { if (ret != thp->audiosize) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -110,7 +110,7 @@ static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
pkt->pos = orig_pos; pkt->pos = orig_pos;
if (!pkt->size) if (!pkt->size)
av_free_packet(pkt); av_packet_unref(pkt);
return pkt->size > orig_size ? pkt->size - orig_size : ret; return pkt->size > orig_size ? pkt->size - orig_size : ret;
} }
@ -426,7 +426,7 @@ int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
"Dropped corrupted packet (stream = %d)\n", "Dropped corrupted packet (stream = %d)\n",
pkt->stream_index); pkt->stream_index);
av_free_packet(pkt); av_packet_unref(pkt);
continue; continue;
} }
@ -756,7 +756,7 @@ static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_en
while (*pkt_buf) { while (*pkt_buf) {
AVPacketList *pktl = *pkt_buf; AVPacketList *pktl = *pkt_buf;
*pkt_buf = pktl->next; *pkt_buf = pktl->next;
av_free_packet(&pktl->pkt); av_packet_unref(&pktl->pkt);
av_freep(&pktl); av_freep(&pktl);
} }
*pkt_buf_end = NULL; *pkt_buf_end = NULL;
@ -845,7 +845,7 @@ static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
goto fail; goto fail;
if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) { if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
av_free_packet(&out_pkt); av_packet_unref(&out_pkt);
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
} }
@ -858,7 +858,7 @@ static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
} }
fail: fail:
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
@ -949,7 +949,7 @@ static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
return ret; return ret;
} else { } else {
/* free packet */ /* free packet */
av_free_packet(&cur_pkt); av_packet_unref(&cur_pkt);
} }
} }
@ -1450,7 +1450,7 @@ static int seek_frame_generic(AVFormatContext *s, int stream_index,
} while (read_status == AVERROR(EAGAIN)); } while (read_status == AVERROR(EAGAIN));
if (read_status < 0) if (read_status < 0)
break; break;
av_free_packet(&pkt); av_packet_unref(&pkt);
if (stream_index == pkt.stream_index) if (stream_index == pkt.stream_index)
if ((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp) if ((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
break; break;
@ -1752,7 +1752,7 @@ static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
st->duration = duration; st->duration = duration;
} }
} }
av_free_packet(pkt); av_packet_unref(pkt);
} }
} while (end_time == AV_NOPTS_VALUE && } while (end_time == AV_NOPTS_VALUE &&
filesize > (DURATION_MAX_READ_SIZE << retry) && filesize > (DURATION_MAX_READ_SIZE << retry) &&
@ -2461,7 +2461,7 @@ void avformat_free_context(AVFormatContext *s)
av_parser_close(st->parser); av_parser_close(st->parser);
} }
if (st->attached_pic.data) if (st->attached_pic.data)
av_free_packet(&st->attached_pic); av_packet_unref(&st->attached_pic);
av_dict_free(&st->metadata); av_dict_free(&st->metadata);
av_freep(&st->probe_data.buf); av_freep(&st->probe_data.buf);
av_free(st->index_entries); av_free(st->index_entries);

@ -243,7 +243,7 @@ static int vqf_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = avio_read(s->pb, pkt->data+2, size); ret = avio_read(s->pb, pkt->data+2, size);
if (ret<=0) { if (ret<=0) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -288,7 +288,7 @@ static int wc3_read_close(AVFormatContext *s)
Wc3DemuxContext *wc3 = s->priv_data; Wc3DemuxContext *wc3 = s->priv_data;
if (wc3->vpkt.size > 0) if (wc3->vpkt.size > 0)
av_free_packet(&wc3->vpkt); av_packet_unref(&wc3->vpkt);
return 0; return 0;
} }

@ -184,7 +184,7 @@ static int wsvqa_read_packet(AVFormatContext *s,
return AVERROR(EIO); return AVERROR(EIO);
ret = avio_read(pb, pkt->data, chunk_size); ret = avio_read(pb, pkt->data, chunk_size);
if (ret != chunk_size) { if (ret != chunk_size) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }

@ -269,25 +269,25 @@ static int wv_read_packet(AVFormatContext *s, AVPacket *pkt)
memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE); memcpy(pkt->data, wc->block_header, WV_HEADER_SIZE);
ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->header.blocksize); ret = avio_read(s->pb, pkt->data + WV_HEADER_SIZE, wc->header.blocksize);
if (ret != wc->header.blocksize) { if (ret != wc->header.blocksize) {
av_free_packet(pkt); av_packet_unref(pkt);
return AVERROR(EIO); return AVERROR(EIO);
} }
while (!(wc->header.flags & WV_FLAG_FINAL_BLOCK)) { while (!(wc->header.flags & WV_FLAG_FINAL_BLOCK)) {
if ((ret = wv_read_block_header(s, s->pb)) < 0) { if ((ret = wv_read_block_header(s, s->pb)) < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
off = pkt->size; off = pkt->size;
if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->header.blocksize)) < 0) { if ((ret = av_grow_packet(pkt, WV_HEADER_SIZE + wc->header.blocksize)) < 0) {
av_free_packet(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
memcpy(pkt->data + off, wc->block_header, WV_HEADER_SIZE); memcpy(pkt->data + off, wc->block_header, WV_HEADER_SIZE);
ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->header.blocksize); ret = avio_read(s->pb, pkt->data + off + WV_HEADER_SIZE, wc->header.blocksize);
if (ret != wc->header.blocksize) { if (ret != wc->header.blocksize) {
av_free_packet(pkt); av_packet_unref(pkt);
return (ret < 0) ? ret : AVERROR_EOF; return (ret < 0) ? ret : AVERROR_EOF;
} }
} }
@ -334,7 +334,7 @@ static int wv_read_seek(AVFormatContext *s, int stream_index,
return ret; return ret;
} }
pts = pkt->pts; pts = pkt->pts;
av_free_packet(pkt); av_packet_unref(pkt);
} while(pts < timestamp); } while(pts < timestamp);
return 0; return 0;
} }

@ -168,14 +168,14 @@ static int yop_read_packet(AVFormatContext *s, AVPacket *pkt)
return yop->audio_block_length; return yop->audio_block_length;
err_out: err_out:
av_free_packet(&yop->video_packet); av_packet_unref(&yop->video_packet);
return ret; return ret;
} }
static int yop_read_close(AVFormatContext *s) static int yop_read_close(AVFormatContext *s)
{ {
YopDecContext *yop = s->priv_data; YopDecContext *yop = s->priv_data;
av_free_packet(&yop->video_packet); av_packet_unref(&yop->video_packet);
return 0; return 0;
} }
@ -200,7 +200,7 @@ static int yop_read_seek(AVFormatContext *s, int stream_index,
if (avio_seek(s->pb, frame_pos, SEEK_SET) < 0) if (avio_seek(s->pb, frame_pos, SEEK_SET) < 0)
return -1; return -1;
av_free_packet(&yop->video_packet); av_packet_unref(&yop->video_packet);
yop->odd_frame = timestamp & 1; yop->odd_frame = timestamp & 1;
return 0; return 0;

@ -122,7 +122,7 @@ int main(int argc, char **argv)
} }
close(fd); close(fd);
} }
av_free_packet(&pkt); av_packet_unref(&pkt);
pktnum++; pktnum++;
if (maxpkts && (pktnum >= maxpkts)) if (maxpkts && (pktnum >= maxpkts))
break; break;

Loading…
Cancel
Save