Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

lavf: replace AVStream.codec with AVStream.codecpar

Browse Source 
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.

In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.

There are multiple important problems with this approach:
    - the fields in AVCodecContext are in general one of
        * stream parameters
        * codec options
        * codec state
      However, it's not clear which ones are which. It is consequently
      unclear which fields are a demuxer allowed to set or a muxer allowed to
      read. This leads to erratic behaviour depending on whether decoding or
      encoding is being performed or not (and whether it uses the AVStream
      embedded codec context).
    - various synchronization issues arising from the fact that the same
      context is used by several different APIs (muxers/demuxers,
      parsers, bitstream filters and encoders/decoders) simultaneously, with
      there being no clear rules for who can modify what and the different
      processes being typically delayed with respect to each other.
    - avformat_find_stream_info() making it necessary to support opening
      and closing a single codec context multiple times, thus
      complicating the semantics of freeing various allocated objects in the
      codec context.

Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
pull/200/head
Anton Khirnov 11 years ago
parent a8068346e4
commit 9200514ad8
251 changed files with 4515 additions and 4304 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      libavdevice/alsa.c
  2. 14
      libavdevice/alsa_dec.c
  3. 10
      libavdevice/alsa_enc.c
  4. 13
      libavdevice/bktr.c
  5. 16
      libavdevice/fbdev.c
  6. 10
      libavdevice/jack.c
  7. 12
      libavdevice/libcdio.c
  8. 15
      libavdevice/libdc1394.c
  9. 8
      libavdevice/oss_dec.c
  10. 4
      libavdevice/oss_enc.c
  11. 8
      libavdevice/pulse.c
  12. 8
      libavdevice/sndio_dec.c
  13. 4
      libavdevice/sndio_enc.c
  14. 18
      libavdevice/v4l2.c
  15. 35
      libavdevice/vfwcap.c
  16. 15
      libavdevice/x11grab.c
  17. 11
      libavdevice/xcbgrab.c
  18. 44
      libavformat/4xm.c
  19. 10
      libavformat/a64.c
  20. 4
      libavformat/aacdec.c
  21. 8
      libavformat/adtsenc.c
  22. 34
      libavformat/adxdec.c
  23. 20
      libavformat/aea.c
  24. 68
      libavformat/aiffdec.c
  25. 34
      libavformat/aiffenc.c
  26. 36
      libavformat/amr.c
  27. 18
      libavformat/anm.c
  28. 32
      libavformat/apc.c
  29. 22
      libavformat/ape.c
  30. 16
      libavformat/apetag.c
  31. 30
      libavformat/asfdec.c
  32. 58
      libavformat/asfenc.c
  33. 10
      libavformat/assdec.c
  34. 16
      libavformat/assenc.c
  35. 30
      libavformat/au.c
  36. 12
      libavformat/audiointerleave.c
  37. 24
      libavformat/avformat.h
  38. 135
      libavformat/avidec.c
  39. 98
      libavformat/avienc.c
  40. 58
      libavformat/avisynth.c
  41. 12
      libavformat/avs.c
  42. 24
      libavformat/bethsoftvid.c
  43. 36
      libavformat/bfi.c
  44. 46
      libavformat/bink.c
  45. 20
      libavformat/bmv.c
  46. 10
      libavformat/c93.c
  47. 64
      libavformat/cafdec.c
  48. 4
      libavformat/cdg.c
  49. 26
      libavformat/cdxl.c
  50. 60
      libavformat/dashenc.c
  51. 18
      libavformat/dauddec.c
  52. 4
      libavformat/daudenc.c
  53. 8
      libavformat/dfa.c
  54. 26
      libavformat/dsicin.c
  55. 16
      libavformat/dss.c
  56. 34
      libavformat/dump.c
  57. 43
      libavformat/dv.c
  58. 25
      libavformat/dvenc.c
  59. 20
      libavformat/dxa.c
  60. 10
      libavformat/eacdata.c
  61. 32
      libavformat/electronicarts.c
  62. 4
      libavformat/ffmetadec.c
  63. 20
      libavformat/filmstripdec.c
  64. 6
      libavformat/filmstripenc.c
  65. 8
      libavformat/flac_picture.c
  66. 14
      libavformat/flacdec.c
  67. 16
      libavformat/flacenc.c
  68. 54
      libavformat/flic.c
  69. 249
      libavformat/flvdec.c
  70. 152
      libavformat/flvenc.c
  71. 16
      libavformat/g722.c
  72. 12
      libavformat/g723_1.c
  73. 33
      libavformat/gif.c
  74. 12
      libavformat/gsmdec.c
  75. 78
      libavformat/gxf.c
  76. 62
      libavformat/gxfenc.c
  77. 14
      libavformat/hdsenc.c
  78. 2
      libavformat/hls.c
  79. 6
      libavformat/hlsenc.c
  80. 18
      libavformat/hnm.c
  81. 4
      libavformat/id3v2.c
  82. 2
      libavformat/id3v2enc.c
  83. 38
      libavformat/idcin.c
  84. 36
      libavformat/idroqdec.c
  85. 54
      libavformat/iff.c
  86. 36
      libavformat/ilbc.c
  87. 28
      libavformat/img2dec.c
  88. 16
      libavformat/img2enc.c
  89. 16
      libavformat/internal.h
  90. 38
      libavformat/ipmovie.c
  91. 32
      libavformat/isom.c
  92. 30
      libavformat/iss.c
  93. 4
      libavformat/iv8.c
  94. 10
      libavformat/ivfdec.c
  95. 12
      libavformat/ivfenc.c
  96. 24
      libavformat/jvdec.c
  97. 16
      libavformat/latmenc.c
  98. 8
      libavformat/lmlm4.c
  99. 32
      libavformat/lxfdec.c
  100. 118
      libavformat/matroskadec.c
  101. Some files were not shown because too many files have changed in this diff Show More

2
libavdevice/alsa.c
Unescape View File

@ -194,7 +194,7 @@ av_cold int ff_alsa_open(AVFormatContext *ctx, snd_pcm_stream_t mode,
snd_pcm_t *h; snd_pcm_t *h;
snd_pcm_hw_params_t *hw_params; snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t buffer_size, period_size; snd_pcm_uframes_t buffer_size, period_size;
uint64_t layout = ctx->streams[0]->codec->channel_layout; uint64_t layout = ctx->streams[0]->codecpar->channel_layout;
if (ctx->filename[0] == 0) audio_device = "default"; if (ctx->filename[0] == 0) audio_device = "default";
else audio_device = ctx->filename; else audio_device = ctx->filename;

14
libavdevice/alsa_dec.c
Unescape View File

@ -101,10 +101,10 @@ static av_cold int audio_read_header(AVFormatContext *s1)
} }
/* take real parameters */ /* take real parameters */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = codec_id; st->codecpar->codec_id = codec_id;
st->codec->sample_rate = s->sample_rate; st->codecpar->sample_rate = s->sample_rate;
st->codec->channels = s->channels; st->codecpar->channels = s->channels;
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0; return 0;
@ -144,9 +144,9 @@ static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
snd_pcm_htimestamp(s->h, &ts_delay, &timestamp); snd_pcm_htimestamp(s->h, &ts_delay, &timestamp);
ts_delay += res; ts_delay += res;
pkt->pts = timestamp.tv_sec * 1000000LL pkt->pts = timestamp.tv_sec * 1000000LL
+ (timestamp.tv_nsec * st->codec->sample_rate + (timestamp.tv_nsec * st->codecpar->sample_rate
- (int64_t)ts_delay * 1000000000LL + st->codec->sample_rate * 500LL) - (int64_t)ts_delay * 1000000000LL + st->codecpar->sample_rate * 500LL)
/ (st->codec->sample_rate * 1000LL); / (st->codecpar->sample_rate * 1000LL);
pkt->size = res * s->frame_size; pkt->size = res * s->frame_size;

10
libavdevice/alsa_enc.c
Unescape View File

@ -54,14 +54,14 @@ static av_cold int audio_write_header(AVFormatContext *s1)
int res; int res;
st = s1->streams[0]; st = s1->streams[0];
sample_rate = st->codec->sample_rate; sample_rate = st->codecpar->sample_rate;
codec_id = st->codec->codec_id; codec_id = st->codecpar->codec_id;
res = ff_alsa_open(s1, SND_PCM_STREAM_PLAYBACK, &sample_rate, res = ff_alsa_open(s1, SND_PCM_STREAM_PLAYBACK, &sample_rate,
st->codec->channels, &codec_id); st->codecpar->channels, &codec_id);
if (sample_rate != st->codec->sample_rate) { if (sample_rate != st->codecpar->sample_rate) {
av_log(s1, AV_LOG_ERROR, av_log(s1, AV_LOG_ERROR,
"sample rate %d not available, nearest is %d\n", "sample rate %d not available, nearest is %d\n",
st->codec->sample_rate, sample_rate); st->codecpar->sample_rate, sample_rate);
goto fail; goto fail;
} }

13
libavdevice/bktr.c
Unescape View File

@ -295,13 +295,12 @@ static int grab_read_header(AVFormatContext *s1)
s->height = height; s->height = height;
s->per_frame = ((uint64_t)1000000 * framerate.den) / framerate.num; s->per_frame = ((uint64_t)1000000 * framerate.den) / framerate.num;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->pix_fmt = AV_PIX_FMT_YUV420P; st->codecpar->format = AV_PIX_FMT_YUV420P;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = width; st->codecpar->width = width;
st->codec->height = height; st->codecpar->height = height;
st->codec->time_base.den = framerate.num; st->avg_frame_rate = framerate;
st->codec->time_base.num = framerate.den;
if (bktr_init(s1->filename, width, height, s->standard, if (bktr_init(s1->filename, width, height, s->standard,

16
libavdevice/fbdev.c
Unescape View File

@ -164,21 +164,21 @@ static av_cold int fbdev_read_header(AVFormatContext *avctx)
goto fail; goto fail;
} }
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = fbdev->width; st->codecpar->width = fbdev->width;
st->codec->height = fbdev->height; st->codecpar->height = fbdev->height;
st->codec->pix_fmt = pix_fmt; st->codecpar->format = pix_fmt;
st->codec->time_base = (AVRational){fbdev->framerate_q.den, fbdev->framerate_q.num}; st->codecpar->bit_rate =
st->codec->bit_rate =
fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8; fbdev->width * fbdev->height * fbdev->bytes_per_pixel * av_q2d(fbdev->framerate_q) * 8;
st->avg_frame_rate = fbdev->framerate_q;
av_log(avctx, AV_LOG_INFO, av_log(avctx, AV_LOG_INFO,
"w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n", "w:%d h:%d bpp:%d pixfmt:%s fps:%d/%d bit_rate:%d\n",
fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel, fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
av_get_pix_fmt_name(pix_fmt), av_get_pix_fmt_name(pix_fmt),
fbdev->framerate_q.num, fbdev->framerate_q.den, fbdev->framerate_q.num, fbdev->framerate_q.den,
st->codec->bit_rate); st->codecpar->bit_rate);
return 0; return 0;
fail: fail:

10
libavdevice/jack.c
Unescape View File

@ -254,14 +254,14 @@ static int audio_read_header(AVFormatContext *context)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
stream->codec->codec_type = AVMEDIA_TYPE_AUDIO; stream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
stream->codec->codec_id = AV_CODEC_ID_PCM_F32BE; stream->codecpar->codec_id = AV_CODEC_ID_PCM_F32BE;
#else #else
stream->codec->codec_id = AV_CODEC_ID_PCM_F32LE; stream->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE;
#endif #endif
stream->codec->sample_rate = self->sample_rate; stream->codecpar->sample_rate = self->sample_rate;
stream->codec->channels = self->nports; stream->codecpar->channels = self->nports;
avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */ avpriv_set_pts_info(stream, 64, 1, 1000000); /* 64 bits pts in us */
return 0; return 0;

12
libavdevice/libcdio.c
Unescape View File

@ -85,19 +85,19 @@ static av_cold int read_header(AVFormatContext *ctx)
} }
cdio_paranoia_modeset(s->paranoia, s->paranoia_mode); cdio_paranoia_modeset(s->paranoia, s->paranoia_mode);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
if (s->drive->bigendianp) if (s->drive->bigendianp)
st->codec->codec_id = AV_CODEC_ID_PCM_S16BE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE;
else else
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
st->codec->sample_rate = 44100; st->codecpar->sample_rate = 44100;
st->codec->channels = 2; st->codecpar->channels = 2;
if (s->drive->audio_last_sector != CDIO_INVALID_LSN && if (s->drive->audio_last_sector != CDIO_INVALID_LSN &&
s->drive->audio_first_sector != CDIO_INVALID_LSN) s->drive->audio_first_sector != CDIO_INVALID_LSN)
st->duration = s->drive->audio_last_sector - s->drive->audio_first_sector; st->duration = s->drive->audio_last_sector - s->drive->audio_first_sector;
else if (s->drive->tracks) else if (s->drive->tracks)
st->duration = s->drive->disc_toc[s->drive->tracks].dwStartSector; st->duration = s->drive->disc_toc[s->drive->tracks].dwStartSector;
avpriv_set_pts_info(st, 64, CDIO_CD_FRAMESIZE_RAW, 2*st->codec->channels*st->codec->sample_rate); avpriv_set_pts_info(st, 64, CDIO_CD_FRAMESIZE_RAW, 2 * st->codecpar->channels * st->codecpar->sample_rate);
for (i = 0; i < s->drive->tracks; i++) { for (i = 0; i < s->drive->tracks; i++) {
char title[16]; char title[16];

15
libavdevice/libdc1394.c
Unescape View File

@ -170,13 +170,12 @@ static inline int dc1394_read_common(AVFormatContext *c,
goto out; goto out;
} }
avpriv_set_pts_info(vst, 64, 1, 1000); avpriv_set_pts_info(vst, 64, 1, 1000);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_RAWVIDEO; vst->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
vst->codec->time_base.den = framerate.num; vst->codecpar->width = fmt->width;
vst->codec->time_base.num = framerate.den; vst->codecpar->height = fmt->height;
vst->codec->width = fmt->width; vst->codecpar->format = fmt->pix_fmt;
vst->codec->height = fmt->height; vst->avg_frame_rate = framerate;
vst->codec->pix_fmt = fmt->pix_fmt;
/* packet init */ /* packet init */
av_init_packet(&dc1394->packet); av_init_packet(&dc1394->packet);
@ -187,7 +186,7 @@ static inline int dc1394_read_common(AVFormatContext *c,
dc1394->current_frame = 0; dc1394->current_frame = 0;
vst->codec->bit_rate = av_rescale(dc1394->packet.size * 8, fps->frame_rate, 1000); vst->codecpar->bit_rate = av_rescale(dc1394->packet.size * 8, fps->frame_rate, 1000);
*select_fps = fps; *select_fps = fps;
*select_fmt = fmt; *select_fmt = fmt;
out: out:

8
libavdevice/oss_dec.c
Unescape View File

@ -61,10 +61,10 @@ static int audio_read_header(AVFormatContext *s1)
} }
/* take real parameters */ /* take real parameters */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->codec_id; st->codecpar->codec_id = s->codec_id;
st->codec->sample_rate = s->sample_rate; st->codecpar->sample_rate = s->sample_rate;
st->codec->channels = s->channels; st->codecpar->channels = s->channels;
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0; return 0;

4
libavdevice/oss_enc.c
Unescape View File

@ -47,8 +47,8 @@ static int audio_write_header(AVFormatContext *s1)
int ret; int ret;
st = s1->streams[0]; st = s1->streams[0];
s->sample_rate = st->codec->sample_rate; s->sample_rate = st->codecpar->sample_rate;
s->channels = st->codec->channels; s->channels = st->codecpar->channels;
ret = ff_oss_audio_open(s1, 1, s1->filename); ret = ff_oss_audio_open(s1, 1, s1->filename);
if (ret < 0) { if (ret < 0) {
return AVERROR(EIO); return AVERROR(EIO);

8
libavdevice/pulse.c
Unescape View File

@ -107,10 +107,10 @@ static av_cold int pulse_read_header(AVFormatContext *s)
return AVERROR(EIO); return AVERROR(EIO);
} }
/* take real parameters */ /* take real parameters */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = codec_id; st->codecpar->codec_id = codec_id;
st->codec->sample_rate = pd->sample_rate; st->codecpar->sample_rate = pd->sample_rate;
st->codec->channels = pd->channels; st->codecpar->channels = pd->channels;
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
pd->pts = AV_NOPTS_VALUE; pd->pts = AV_NOPTS_VALUE;

8
libavdevice/sndio_dec.c
Unescape View File

@ -46,10 +46,10 @@ static av_cold int audio_read_header(AVFormatContext *s1)
return ret; return ret;
/* take real parameters */ /* take real parameters */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->codec_id; st->codecpar->codec_id = s->codec_id;
st->codec->sample_rate = s->sample_rate; st->codecpar->sample_rate = s->sample_rate;
st->codec->channels = s->channels; st->codecpar->channels = s->channels;
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */

4
libavdevice/sndio_enc.c
Unescape View File

@ -35,8 +35,8 @@ static av_cold int audio_write_header(AVFormatContext *s1)
int ret; int ret;
st = s1->streams[0]; st = s1->streams[0];
s->sample_rate = st->codec->sample_rate; s->sample_rate = st->codecpar->sample_rate;
s->channels = st->codec->channels; s->channels = st->codecpar->channels;
ret = ff_sndio_open(s1, 1, s1->filename); ret = ff_sndio_open(s1, 1, s1->filename);

18
libavdevice/v4l2.c
Unescape View File

@ -827,8 +827,8 @@ static int v4l2_read_header(AVFormatContext *s1)
if ((res = v4l2_set_parameters(s1) < 0)) if ((res = v4l2_set_parameters(s1) < 0))
return res; return res;
st->codec->pix_fmt = fmt_v4l2ff(desired_format, codec_id); st->codecpar->format = fmt_v4l2ff(desired_format, codec_id);
s->frame_size = av_image_get_buffer_size(st->codec->pix_fmt, s->frame_size = av_image_get_buffer_size(st->codecpar->format,
s->width, s->height, 1); s->width, s->height, 1);
if ((res = mmap_init(s1)) || if ((res = mmap_init(s1)) ||
@ -839,14 +839,14 @@ static int v4l2_read_header(AVFormatContext *s1)
s->top_field_first = first_field(s->fd); s->top_field_first = first_field(s->fd);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = codec_id; st->codecpar->codec_id = codec_id;
if (codec_id == AV_CODEC_ID_RAWVIDEO) if (codec_id == AV_CODEC_ID_RAWVIDEO)
st->codec->codec_tag = st->codecpar->codec_tag =
avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt); avcodec_pix_fmt_to_codec_tag(st->codecpar->format);
st->codec->width = s->width; st->codecpar->width = s->width;
st->codec->height = s->height; st->codecpar->height = s->height;
st->codec->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8; st->codecpar->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8;
return 0; return 0;
} }

35
libavdevice/vfwcap.c
Unescape View File

@ -244,7 +244,7 @@ static int vfw_read_close(AVFormatContext *s)
static int vfw_read_header(AVFormatContext *s) static int vfw_read_header(AVFormatContext *s)
{ {
struct vfw_ctx *ctx = s->priv_data; struct vfw_ctx *ctx = s->priv_data;
AVCodecContext *codec; AVCodecParameters *par;
AVStream *st; AVStream *st;
int devnum; int devnum;
int bisize; int bisize;
@ -373,29 +373,30 @@ static int vfw_read_header(AVFormatContext *s)
if(!ret) if(!ret)
goto fail_io; goto fail_io;
codec = st->codec; st->avg_frame_rate = framerate_q;
codec->time_base = (AVRational){framerate_q.den, framerate_q.num};
codec->codec_type = AVMEDIA_TYPE_VIDEO; par = st->codecpar;
codec->width = bi->bmiHeader.biWidth; par->codec_type = AVMEDIA_TYPE_VIDEO;
codec->height = bi->bmiHeader.biHeight; par->width = bi->bmiHeader.biWidth;
codec->pix_fmt = vfw_pixfmt(biCompression, biBitCount); par->height = bi->bmiHeader.biHeight;
if(codec->pix_fmt == AV_PIX_FMT_NONE) { par->format = vfw_pixfmt(biCompression, biBitCount);
codec->codec_id = vfw_codecid(biCompression); if (par->format == AV_PIX_FMT_NONE) {
if(codec->codec_id == AV_CODEC_ID_NONE) { par->codec_id = vfw_codecid(biCompression);
if (par->codec_id == AV_CODEC_ID_NONE) {
av_log(s, AV_LOG_ERROR, "Unknown compression type. " av_log(s, AV_LOG_ERROR, "Unknown compression type. "
"Please report verbose (-v 9) debug information.\n"); "Please report verbose (-v 9) debug information.\n");
vfw_read_close(s); vfw_read_close(s);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
codec->bits_per_coded_sample = biBitCount; par->bits_per_coded_sample = biBitCount;
} else { } else {
codec->codec_id = AV_CODEC_ID_RAWVIDEO; par->codec_id = AV_CODEC_ID_RAWVIDEO;
if(biCompression == BI_RGB) { if(biCompression == BI_RGB) {
codec->bits_per_coded_sample = biBitCount; par->bits_per_coded_sample = biBitCount;
codec->extradata = av_malloc(9 + AV_INPUT_BUFFER_PADDING_SIZE); par->extradata = av_malloc(9 + AV_INPUT_BUFFER_PADDING_SIZE);
if (codec->extradata) { if (par->extradata) {
codec->extradata_size = 9; par->extradata_size = 9;
memcpy(codec->extradata, "BottomUp", 9); memcpy(par->extradata, "BottomUp", 9);
} }
} }
} }

15
libavdevice/x11grab.c
Unescape View File

@ -347,16 +347,17 @@ static int x11grab_read_header(AVFormatContext *s1)
x11grab->image = image; x11grab->image = image;
x11grab->use_shm = use_shm; x11grab->use_shm = use_shm;
ret = pixfmt_from_image(s1, image, &st->codec->pix_fmt); ret = pixfmt_from_image(s1, image, &st->codecpar->format);
if (ret < 0) if (ret < 0)
goto out; goto out;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = x11grab->width; st->codecpar->width = x11grab->width;
st->codec->height = x11grab->height; st->codecpar->height = x11grab->height;
st->codec->time_base = x11grab->time_base; st->codecpar->bit_rate = x11grab->frame_size * 1 / av_q2d(x11grab->time_base) * 8;
st->codec->bit_rate = x11grab->frame_size * 1 / av_q2d(x11grab->time_base) * 8;
st->avg_frame_rate = av_inv_q(x11grab->time_base);
out: out:
av_free(param); av_free(param);

11
libavdevice/xcbgrab.c
Unescape View File

@ -544,13 +544,12 @@ static int create_stream(AVFormatContext *s)
st->avg_frame_rate.num }; st->avg_frame_rate.num };
c->time_frame = av_gettime(); c->time_frame = av_gettime();
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = c->width; st->codecpar->width = c->width;
st->codec->height = c->height; st->codecpar->height = c->height;
st->codec->time_base = c->time_base;
ret = pixfmt_from_pixmap_format(s, geo->depth, &st->codec->pix_fmt); ret = pixfmt_from_pixmap_format(s, geo->depth, &st->codecpar->format);
free(geo); free(geo);

44
libavformat/4xm.c
Unescape View File

@ -108,16 +108,16 @@ static int parse_vtrk(AVFormatContext *s,
fourxm->video_stream_index = st->index; fourxm->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_4XM; st->codecpar->codec_id = AV_CODEC_ID_4XM;
st->codec->extradata = av_mallocz(4 + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(4 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = 4; st->codecpar->extradata_size = 4;
AV_WL32(st->codec->extradata, AV_RL32(buf + 16)); AV_WL32(st->codecpar->extradata, AV_RL32(buf + 16));
st->codec->width = AV_RL32(buf + 36); st->codecpar->width = AV_RL32(buf + 36);
st->codec->height = AV_RL32(buf + 40); st->codecpar->height = AV_RL32(buf + 40);
return 0; return 0;
} }
@ -165,23 +165,23 @@ static int parse_strk(AVFormatContext *s,
fourxm->tracks[track].stream_index = st->index; fourxm->tracks[track].stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
st->codec->channels = fourxm->tracks[track].channels; st->codecpar->channels = fourxm->tracks[track].channels;
st->codec->sample_rate = fourxm->tracks[track].sample_rate; st->codecpar->sample_rate = fourxm->tracks[track].sample_rate;
st->codec->bits_per_coded_sample = fourxm->tracks[track].bits; st->codecpar->bits_per_coded_sample = fourxm->tracks[track].bits;
st->codec->bit_rate = st->codec->channels * st->codecpar->bit_rate = st->codecpar->channels *
st->codec->sample_rate * st->codecpar->sample_rate *
st->codec->bits_per_coded_sample; st->codecpar->bits_per_coded_sample;
st->codec->block_align = st->codec->channels * st->codecpar->block_align = st->codecpar->channels *
st->codec->bits_per_coded_sample; st->codecpar->bits_per_coded_sample;
if (fourxm->tracks[track].adpcm){ if (fourxm->tracks[track].adpcm){
st->codec->codec_id = AV_CODEC_ID_ADPCM_4XM; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_4XM;
} else if (st->codec->bits_per_coded_sample == 8) { } else if (st->codecpar->bits_per_coded_sample == 8) {
st->codec->codec_id = AV_CODEC_ID_PCM_U8; st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
} else } else
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
return 0; return 0;
} }

10
libavformat/a64.c
Unescape View File

@ -27,7 +27,7 @@
static int a64_write_header(AVFormatContext *s) static int a64_write_header(AVFormatContext *s)
{ {
AVCodecContext *avctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
uint8_t header[5] = { uint8_t header[5] = {
0x00, //load 0x00, //load
0x40, //address 0x40, //address
@ -36,20 +36,20 @@ static int a64_write_header(AVFormatContext *s)
0x00 //fps in 50/fps; 0x00 //fps in 50/fps;
}; };
if (avctx->extradata_size < 4) { if (par->extradata_size < 4) {
av_log(s, AV_LOG_ERROR, "Missing extradata\n"); av_log(s, AV_LOG_ERROR, "Missing extradata\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
switch (avctx->codec->id) { switch (par->codec_id) {
case AV_CODEC_ID_A64_MULTI: case AV_CODEC_ID_A64_MULTI:
header[2] = 0x00; header[2] = 0x00;
header[3] = AV_RB32(avctx->extradata+0); header[3] = AV_RB32(par->extradata+0);
header[4] = 2; header[4] = 2;
break; break;
case AV_CODEC_ID_A64_MULTI5: case AV_CODEC_ID_A64_MULTI5:
header[2] = 0x01; header[2] = 0x01;
header[3] = AV_RB32(avctx->extradata+0); header[3] = AV_RB32(par->extradata+0);
header[4] = 3; header[4] = 3;
break; break;
default: default:

4
libavformat/aacdec.c
Unescape View File

@ -82,8 +82,8 @@ static int adts_aac_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->iformat->raw_codec_id; st->codecpar->codec_id = s->iformat->raw_codec_id;
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
ff_id3v1_read(s); ff_id3v1_read(s);

8
libavformat/adtsenc.c
Unescape View File

@ -91,11 +91,11 @@ static int adts_decode_extradata(AVFormatContext *s, ADTSContext *adts, uint8_t
static int adts_write_header(AVFormatContext *s) static int adts_write_header(AVFormatContext *s)
{ {
ADTSContext *adts = s->priv_data; ADTSContext *adts = s->priv_data;
AVCodecContext *avc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if (avc->extradata_size > 0) if (par->extradata_size > 0)
return adts_decode_extradata(s, adts, avc->extradata, return adts_decode_extradata(s, adts, par->extradata,
avc->extradata_size); par->extradata_size);
return 0; return 0;
} }

34
libavformat/adxdec.c
Unescape View File

@ -37,10 +37,10 @@ typedef struct ADXDemuxerContext {
static int adx_read_packet(AVFormatContext *s, AVPacket *pkt) static int adx_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
ADXDemuxerContext *c = s->priv_data; ADXDemuxerContext *c = s->priv_data;
AVCodecContext *avctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
int ret, size; int ret, size;
size = BLOCK_SIZE * avctx->channels; size = BLOCK_SIZE * par->channels;
pkt->pos = avio_tell(s->pb); pkt->pos = avio_tell(s->pb);
pkt->stream_index = 0; pkt->stream_index = 0;
@ -64,43 +64,43 @@ static int adx_read_packet(AVFormatContext *s, AVPacket *pkt)
static int adx_read_header(AVFormatContext *s) static int adx_read_header(AVFormatContext *s)
{ {
ADXDemuxerContext *c = s->priv_data; ADXDemuxerContext *c = s->priv_data;
AVCodecContext *avctx; AVCodecParameters *par;
AVStream *st = avformat_new_stream(s, NULL); AVStream *st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avctx = s->streams[0]->codec; par = s->streams[0]->codecpar;
if (avio_rb16(s->pb) != 0x8000) if (avio_rb16(s->pb) != 0x8000)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
c->header_size = avio_rb16(s->pb) + 4; c->header_size = avio_rb16(s->pb) + 4;
avio_seek(s->pb, -4, SEEK_CUR); avio_seek(s->pb, -4, SEEK_CUR);
avctx->extradata = av_mallocz(c->header_size + AV_INPUT_BUFFER_PADDING_SIZE); par->extradata = av_mallocz(c->header_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata) if (!par->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (avio_read(s->pb, avctx->extradata, c->header_size) < c->header_size) { if (avio_read(s->pb, par->extradata, c->header_size) < c->header_size) {
av_freep(&avctx->extradata); av_freep(&par->extradata);
return AVERROR(EIO); return AVERROR(EIO);
} }
avctx->extradata_size = c->header_size; par->extradata_size = c->header_size;
if (avctx->extradata_size < 12) { if (par->extradata_size < 12) {
av_log(s, AV_LOG_ERROR, "Invalid extradata size.\n"); av_log(s, AV_LOG_ERROR, "Invalid extradata size.\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avctx->channels = AV_RB8(avctx->extradata + 7); par->channels = AV_RB8 (par->extradata + 7);
avctx->sample_rate = AV_RB32(avctx->extradata + 8); par->sample_rate = AV_RB32(par->extradata + 8);
if (avctx->channels <= 0) { if (par->channels <= 0) {
av_log(s, AV_LOG_ERROR, "invalid number of channels %d\n", avctx->channels); av_log(s, AV_LOG_ERROR, "invalid number of channels %d\n", par->channels);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; par->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->iformat->raw_codec_id; par->codec_id = s->iformat->raw_codec_id;
avpriv_set_pts_info(st, 64, BLOCK_SAMPLES, avctx->sample_rate); avpriv_set_pts_info(st, 64, BLOCK_SAMPLES, par->sample_rate);
return 0; return 0;
} }

20
libavformat/aea.c
Unescape View File

@ -62,29 +62,29 @@ static int aea_read_header(AVFormatContext *s)
/* Parse the amount of channels and skip to pos 2048(0x800) */ /* Parse the amount of channels and skip to pos 2048(0x800) */
avio_skip(s->pb, 264); avio_skip(s->pb, 264);
st->codec->channels = avio_r8(s->pb); st->codecpar->channels = avio_r8(s->pb);
avio_skip(s->pb, 1783); avio_skip(s->pb, 1783);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ATRAC1; st->codecpar->codec_id = AV_CODEC_ID_ATRAC1;
st->codec->sample_rate = 44100; st->codecpar->sample_rate = 44100;
st->codec->bit_rate = 292000; st->codecpar->bit_rate = 292000;
if (st->codec->channels != 1 && st->codec->channels != 2) { if (st->codecpar->channels != 1 && st->codecpar->channels != 2) {
av_log(s,AV_LOG_ERROR,"Channels %d not supported!\n",st->codec->channels); av_log(s, AV_LOG_ERROR, "Channels %d not supported!\n", st->codecpar->channels);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->channel_layout = (st->codec->channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = (st->codecpar->channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
st->codec->block_align = AT1_SU_SIZE * st->codec->channels; st->codecpar->block_align = AT1_SU_SIZE * st->codecpar->channels;
return 0; return 0;
} }
static int aea_read_packet(AVFormatContext *s, AVPacket *pkt) static int aea_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
int ret = av_get_packet(s->pb, pkt, s->streams[0]->codec->block_align); int ret = av_get_packet(s->pb, pkt, s->streams[0]->codecpar->block_align);
pkt->stream_index = 0; pkt->stream_index = 0;
if (ret <= 0) if (ret <= 0)

68
libavformat/aiffdec.c
Unescape View File

@ -90,7 +90,7 @@ static unsigned int get_aiff_header(AVFormatContext *s, int size,
unsigned version) unsigned version)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *codec = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
AIFFInputContext *aiff = s->priv_data; AIFFInputContext *aiff = s->priv_data;
int exp; int exp;
uint64_t val; uint64_t val;
@ -99,30 +99,30 @@ static unsigned int get_aiff_header(AVFormatContext *s, int size,
if (size & 1) if (size & 1)
size++; size++;
codec->codec_type = AVMEDIA_TYPE_AUDIO; par->codec_type = AVMEDIA_TYPE_AUDIO;
codec->channels = avio_rb16(pb); par->channels = avio_rb16(pb);
num_frames = avio_rb32(pb); num_frames = avio_rb32(pb);
codec->bits_per_coded_sample = avio_rb16(pb); par->bits_per_coded_sample = avio_rb16(pb);
exp = avio_rb16(pb); exp = avio_rb16(pb);
val = avio_rb64(pb); val = avio_rb64(pb);
sample_rate = ldexp(val, exp - 16383 - 63); sample_rate = ldexp(val, exp - 16383 - 63);
codec->sample_rate = sample_rate; par->sample_rate = sample_rate;
size -= 18; size -= 18;
/* get codec id for AIFF-C */ /* get codec id for AIFF-C */
if (version == AIFF_C_VERSION1) { if (version == AIFF_C_VERSION1) {
codec->codec_tag = avio_rl32(pb); par->codec_tag = avio_rl32(pb);
codec->codec_id = ff_codec_get_id(ff_codec_aiff_tags, codec->codec_tag); par->codec_id = ff_codec_get_id(ff_codec_aiff_tags, par->codec_tag);
size -= 4; size -= 4;
} }
if (version != AIFF_C_VERSION1 || codec->codec_id == AV_CODEC_ID_PCM_S16BE) { if (version != AIFF_C_VERSION1 || par->codec_id == AV_CODEC_ID_PCM_S16BE) {
codec->codec_id = aiff_codec_get_id(codec->bits_per_coded_sample); par->codec_id = aiff_codec_get_id(par->bits_per_coded_sample);
codec->bits_per_coded_sample = av_get_bits_per_sample(codec->codec_id); par->bits_per_coded_sample = av_get_bits_per_sample(par->codec_id);
aiff->block_duration = 1; aiff->block_duration = 1;
} else { } else {
switch (codec->codec_id) { switch (par->codec_id) {
case AV_CODEC_ID_PCM_F32BE: case AV_CODEC_ID_PCM_F32BE:
case AV_CODEC_ID_PCM_F64BE: case AV_CODEC_ID_PCM_F64BE:
case AV_CODEC_ID_PCM_S16LE: case AV_CODEC_ID_PCM_S16LE:
@ -131,37 +131,37 @@ static unsigned int get_aiff_header(AVFormatContext *s, int size,
aiff->block_duration = 1; aiff->block_duration = 1;
break; break;
case AV_CODEC_ID_ADPCM_IMA_QT: case AV_CODEC_ID_ADPCM_IMA_QT:
codec->block_align = 34*codec->channels; par->block_align = 34 * par->channels;
break; break;
case AV_CODEC_ID_MACE3: case AV_CODEC_ID_MACE3:
codec->block_align = 2*codec->channels; par->block_align = 2 * par->channels;
break; break;
case AV_CODEC_ID_ADPCM_G722: case AV_CODEC_ID_ADPCM_G722:
case AV_CODEC_ID_MACE6: case AV_CODEC_ID_MACE6:
codec->block_align = 1*codec->channels; par->block_align = 1 * par->channels;
break; break;
case AV_CODEC_ID_GSM: case AV_CODEC_ID_GSM:
codec->block_align = 33; par->block_align = 33;
break; break;
case AV_CODEC_ID_QCELP: case AV_CODEC_ID_QCELP:
codec->block_align = 35; par->block_align = 35;
break; break;
default: default:
break; break;
} }
if (codec->block_align > 0) if (par->block_align > 0)
aiff->block_duration = av_get_audio_frame_duration(codec, aiff->block_duration = av_get_audio_frame_duration2(par,
codec->block_align); par->block_align);
} }
/* Block align needs to be computed in all cases, as the definition /* Block align needs to be computed in all cases, as the definition
* is specific to applications -> here we use the WAVE format definition */ * is specific to applications -> here we use the WAVE format definition */
if (!codec->block_align) if (!par->block_align)
codec->block_align = (codec->bits_per_coded_sample * codec->channels) >> 3; par->block_align = (par->bits_per_coded_sample * par->channels) >> 3;
if (aiff->block_duration) { if (aiff->block_duration) {
codec->bit_rate = codec->sample_rate * (codec->block_align << 3) / par->bit_rate = par->sample_rate * (par->block_align << 3) /
aiff->block_duration; aiff->block_duration;
} }
/* Chunk is over */ /* Chunk is over */
@ -249,7 +249,7 @@ static int aiff_read_header(AVFormatContext *s)
offset = avio_rb32(pb); /* Offset of sound data */ offset = avio_rb32(pb); /* Offset of sound data */
avio_rb32(pb); /* BlockSize... don't care */ avio_rb32(pb); /* BlockSize... don't care */
offset += avio_tell(pb); /* Compute absolute data offset */ offset += avio_tell(pb); /* Compute absolute data offset */
if (st->codec->block_align) /* Assume COMM already parsed */ if (st->codecpar->block_align) /* Assume COMM already parsed */
goto got_sound; goto got_sound;
if (!pb->seekable) { if (!pb->seekable) {
av_log(s, AV_LOG_ERROR, "file is not seekable\n"); av_log(s, AV_LOG_ERROR, "file is not seekable\n");
@ -260,11 +260,11 @@ static int aiff_read_header(AVFormatContext *s)
case MKTAG('w', 'a', 'v', 'e'): case MKTAG('w', 'a', 'v', 'e'):
if ((uint64_t)size > (1<<30)) if ((uint64_t)size > (1<<30))
return -1; return -1;
st->codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = size; st->codecpar->extradata_size = size;
avio_read(pb, st->codec->extradata, size); avio_read(pb, st->codecpar->extradata, size);
break; break;
default: /* Jump */ default: /* Jump */
if (size & 1) /* Always even aligned */ if (size & 1) /* Always even aligned */
@ -274,13 +274,13 @@ static int aiff_read_header(AVFormatContext *s)
} }
got_sound: got_sound:
if (!st->codec->block_align) { if (!st->codecpar->block_align) {
av_log(s, AV_LOG_ERROR, "could not find COMM tag or invalid block_align value\n"); av_log(s, AV_LOG_ERROR, "could not find COMM tag or invalid block_align value\n");
return -1; return -1;
} }
/* Now positioned, get the sound data start and end */ /* Now positioned, get the sound data start and end */
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
st->start_time = 0; st->start_time = 0;
st->duration = st->nb_frames * aiff->block_duration; st->duration = st->nb_frames * aiff->block_duration;
@ -306,10 +306,10 @@ static int aiff_read_packet(AVFormatContext *s,
return AVERROR_EOF; return AVERROR_EOF;
/* Now for that packet */ /* Now for that packet */
if (st->codec->block_align >= 33) // GSM, QCLP, IMA4 if (st->codecpar->block_align >= 33) // GSM, QCLP, IMA4
size = st->codec->block_align; size = st->codecpar->block_align;
else else
size = (MAX_SIZE / st->codec->block_align) * st->codec->block_align; size = (MAX_SIZE / st->codecpar->block_align) * st->codecpar->block_align;
size = FFMIN(max_size, size); size = FFMIN(max_size, size);
res = av_get_packet(s->pb, pkt, size); res = av_get_packet(s->pb, pkt, size);
if (res < 0) if (res < 0)
@ -317,7 +317,7 @@ static int aiff_read_packet(AVFormatContext *s,
/* Only one stream in an AIFF file */ /* Only one stream in an AIFF file */
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->duration = (res / st->codec->block_align) * aiff->block_duration; pkt->duration = (res / st->codecpar->block_align) * aiff->block_duration;
return 0; return 0;
} }

34
libavformat/aiffenc.c
Unescape View File

@ -37,14 +37,14 @@ static int aiff_write_header(AVFormatContext *s)
{ {
AIFFOutputContext *aiff = s->priv_data; AIFFOutputContext *aiff = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
uint64_t sample_rate; uint64_t sample_rate;
int aifc = 0; int aifc = 0;
/* First verify if format is ok */ /* First verify if format is ok */
if (!enc->codec_tag) if (!par->codec_tag)
return -1; return -1;
if (enc->codec_tag != MKTAG('N','O','N','E')) if (par->codec_tag != MKTAG('N','O','N','E'))
aifc = 1; aifc = 1;
/* FORM AIFF header */ /* FORM AIFF header */
@ -54,8 +54,8 @@ static int aiff_write_header(AVFormatContext *s)
ffio_wfourcc(pb, aifc ? "AIFC" : "AIFF"); ffio_wfourcc(pb, aifc ? "AIFC" : "AIFF");
if (aifc) { // compressed audio if (aifc) { // compressed audio
enc->bits_per_coded_sample = 16; par->bits_per_coded_sample = 16;
if (!enc->block_align) { if (!par->block_align) {
av_log(s, AV_LOG_ERROR, "block align not set\n"); av_log(s, AV_LOG_ERROR, "block align not set\n");
return -1; return -1;
} }
@ -68,28 +68,28 @@ static int aiff_write_header(AVFormatContext *s)
/* Common chunk */ /* Common chunk */
ffio_wfourcc(pb, "COMM"); ffio_wfourcc(pb, "COMM");
avio_wb32(pb, aifc ? 24 : 18); /* size */ avio_wb32(pb, aifc ? 24 : 18); /* size */
avio_wb16(pb, enc->channels); /* Number of channels */ avio_wb16(pb, par->channels); /* Number of channels */
aiff->frames = avio_tell(pb); aiff->frames = avio_tell(pb);
avio_wb32(pb, 0); /* Number of frames */ avio_wb32(pb, 0); /* Number of frames */
if (!enc->bits_per_coded_sample) if (!par->bits_per_coded_sample)
enc->bits_per_coded_sample = av_get_bits_per_sample(enc->codec_id); par->bits_per_coded_sample = av_get_bits_per_sample(par->codec_id);
if (!enc->bits_per_coded_sample) { if (!par->bits_per_coded_sample) {
av_log(s, AV_LOG_ERROR, "could not compute bits per sample\n"); av_log(s, AV_LOG_ERROR, "could not compute bits per sample\n");
return -1; return -1;
} }
if (!enc->block_align) if (!par->block_align)
enc->block_align = (enc->bits_per_coded_sample * enc->channels) >> 3; par->block_align = (par->bits_per_coded_sample * par->channels) >> 3;
avio_wb16(pb, enc->bits_per_coded_sample); /* Sample size */ avio_wb16(pb, par->bits_per_coded_sample); /* Sample size */
sample_rate = av_double2int(enc->sample_rate); sample_rate = av_double2int(par->sample_rate);
avio_wb16(pb, (sample_rate >> 52) + (16383 - 1023)); avio_wb16(pb, (sample_rate >> 52) + (16383 - 1023));
avio_wb64(pb, UINT64_C(1) << 63 | sample_rate << 11); avio_wb64(pb, UINT64_C(1) << 63 | sample_rate << 11);
if (aifc) { if (aifc) {
avio_wl32(pb, enc->codec_tag); avio_wl32(pb, par->codec_tag);
avio_wb16(pb, 0); avio_wb16(pb, 0);
} }
@ -100,7 +100,7 @@ static int aiff_write_header(AVFormatContext *s)
avio_wb32(pb, 0); /* Data offset */ avio_wb32(pb, 0); /* Data offset */
avio_wb32(pb, 0); /* Block-size (block align) */ avio_wb32(pb, 0); /* Block-size (block align) */
avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate); avpriv_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codecpar->sample_rate);
/* Data is starting here */ /* Data is starting here */
avio_flush(pb); avio_flush(pb);
@ -119,7 +119,7 @@ static int aiff_write_trailer(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AIFFOutputContext *aiff = s->priv_data; AIFFOutputContext *aiff = s->priv_data;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
/* Chunks sizes must be even */ /* Chunks sizes must be even */
int64_t file_size, end_size; int64_t file_size, end_size;
@ -136,7 +136,7 @@ static int aiff_write_trailer(AVFormatContext *s)
/* Number of sample frames */ /* Number of sample frames */
avio_seek(pb, aiff->frames, SEEK_SET); avio_seek(pb, aiff->frames, SEEK_SET);
avio_wb32(pb, (file_size-aiff->ssnd-12)/enc->block_align); avio_wb32(pb, (file_size - aiff->ssnd - 12) / par->block_align);
/* Sound Data chunk size */ /* Sound Data chunk size */
avio_seek(pb, aiff->ssnd, SEEK_SET); avio_seek(pb, aiff->ssnd, SEEK_SET);

36
libavformat/amr.c
Unescape View File

@ -37,13 +37,13 @@ static const char AMRWB_header[] = "#!AMR-WB\n";
static int amr_write_header(AVFormatContext *s) static int amr_write_header(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
s->priv_data = NULL; s->priv_data = NULL;
if (enc->codec_id == AV_CODEC_ID_AMR_NB) { if (par->codec_id == AV_CODEC_ID_AMR_NB) {
avio_write(pb, AMR_header, sizeof(AMR_header) - 1); /* magic number */ avio_write(pb, AMR_header, sizeof(AMR_header) - 1); /* magic number */
} else if (enc->codec_id == AV_CODEC_ID_AMR_WB) { } else if (par->codec_id == AV_CODEC_ID_AMR_WB) {
avio_write(pb, AMRWB_header, sizeof(AMRWB_header) - 1); /* magic number */ avio_write(pb, AMRWB_header, sizeof(AMRWB_header) - 1); /* magic number */
} else { } else {
return -1; return -1;
@ -89,25 +89,25 @@ static int amr_read_header(AVFormatContext *s)
return -1; return -1;
} }
st->codec->codec_tag = MKTAG('s', 'a', 'w', 'b'); st->codecpar->codec_tag = MKTAG('s', 'a', 'w', 'b');
st->codec->codec_id = AV_CODEC_ID_AMR_WB; st->codecpar->codec_id = AV_CODEC_ID_AMR_WB;
st->codec->sample_rate = 16000; st->codecpar->sample_rate = 16000;
} else { } else {
st->codec->codec_tag = MKTAG('s', 'a', 'm', 'r'); st->codecpar->codec_tag = MKTAG('s', 'a', 'm', 'r');
st->codec->codec_id = AV_CODEC_ID_AMR_NB; st->codecpar->codec_id = AV_CODEC_ID_AMR_NB;
st->codec->sample_rate = 8000; st->codecpar->sample_rate = 8000;
} }
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
return 0; return 0;
} }
static int amr_read_packet(AVFormatContext *s, AVPacket *pkt) static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
int read, size = 0, toc, mode; int read, size = 0, toc, mode;
int64_t pos = avio_tell(s->pb); int64_t pos = avio_tell(s->pb);
@ -119,13 +119,13 @@ static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
toc = avio_r8(s->pb); toc = avio_r8(s->pb);
mode = (toc >> 3) & 0x0F; mode = (toc >> 3) & 0x0F;
if (enc->codec_id == AV_CODEC_ID_AMR_NB) { if (par->codec_id == AV_CODEC_ID_AMR_NB) {
static const uint8_t packed_size[16] = { static const uint8_t packed_size[16] = {
12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0
}; };
size = packed_size[mode] + 1; size = packed_size[mode] + 1;
} else if (enc->codec_id == AV_CODEC_ID_AMR_WB) { } else if (par->codec_id == AV_CODEC_ID_AMR_WB) {
static const uint8_t packed_size[16] = { static const uint8_t packed_size[16] = {
18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1 18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1
}; };
@ -139,12 +139,12 @@ static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR(EIO); return AVERROR(EIO);
/* Both AMR formats have 50 frames per second */ /* Both AMR formats have 50 frames per second */
s->streams[0]->codec->bit_rate = size*8*50; s->streams[0]->codecpar->bit_rate = size*8*50;
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->pos = pos; pkt->pos = pos;
pkt->data[0] = toc; pkt->data[0] = toc;
pkt->duration = enc->codec_id == AV_CODEC_ID_AMR_NB ? 160 : 320; pkt->duration = par->codec_id == AV_CODEC_ID_AMR_NB ? 160 : 320;
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) {

18
libavformat/anm.c
Unescape View File

@ -100,11 +100,11 @@ static int read_header(AVFormatContext *s)
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_ANM; st->codecpar->codec_id = AV_CODEC_ID_ANM;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = avio_rl16(pb); st->codecpar->width = avio_rl16(pb);
st->codec->height = avio_rl16(pb); st->codecpar->height = avio_rl16(pb);
if (avio_r8(pb) != 0) if (avio_r8(pb) != 0)
goto invalid; goto invalid;
avio_skip(pb, 1); /* frame rate multiplier info */ avio_skip(pb, 1); /* frame rate multiplier info */
@ -132,12 +132,12 @@ static int read_header(AVFormatContext *s)
avio_skip(pb, 58); avio_skip(pb, 58);
/* color cycling and palette data */ /* color cycling and palette data */
st->codec->extradata_size = 16*8 + 4*256; st->codecpar->extradata_size = 16*8 + 4*256;
st->codec->extradata = av_mallocz(st->codec->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(st->codecpar->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) { if (!st->codecpar->extradata) {
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
ret = avio_read(pb, st->codec->extradata, st->codec->extradata_size); ret = avio_read(pb, st->codecpar->extradata, st->codecpar->extradata_size);
if (ret < 0) if (ret < 0)
return ret; return ret;

32
libavformat/apc.c
Unescape View File

@ -45,33 +45,33 @@ static int apc_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_APC; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_APC;
avio_rl32(pb); /* number of samples */ avio_rl32(pb); /* number of samples */
st->codec->sample_rate = avio_rl32(pb); st->codecpar->sample_rate = avio_rl32(pb);
st->codec->extradata_size = 2 * 4; st->codecpar->extradata_size = 2 * 4;
st->codec->extradata = av_malloc(st->codec->extradata_size + st->codecpar->extradata = av_malloc(st->codecpar->extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE); AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
/* initial predictor values for adpcm decoder */ /* initial predictor values for adpcm decoder */
avio_read(pb, st->codec->extradata, 2 * 4); avio_read(pb, st->codecpar->extradata, 2 * 4);
if (avio_rl32(pb)) { if (avio_rl32(pb)) {
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
} else { } else {
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
} }
st->codec->bits_per_coded_sample = 4; st->codecpar->bits_per_coded_sample = 4;
st->codec->bit_rate = st->codec->bits_per_coded_sample * st->codec->channels st->codecpar->bit_rate = st->codecpar->bits_per_coded_sample * st->codecpar->channels
* st->codec->sample_rate; * st->codecpar->sample_rate;
st->codec->block_align = 1; st->codecpar->block_align = 1;
return 0; return 0;
} }

22
libavformat/ape.c
Unescape View File

@ -344,23 +344,23 @@ static int ape_read_header(AVFormatContext * s)
total_blocks = (ape->totalframes == 0) ? 0 : ((ape->totalframes - 1) * ape->blocksperframe) + ape->finalframeblocks; total_blocks = (ape->totalframes == 0) ? 0 : ((ape->totalframes - 1) * ape->blocksperframe) + ape->finalframeblocks;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_APE; st->codecpar->codec_id = AV_CODEC_ID_APE;
st->codec->codec_tag = MKTAG('A', 'P', 'E', ' '); st->codecpar->codec_tag = MKTAG('A', 'P', 'E', ' ');
st->codec->channels = ape->channels; st->codecpar->channels = ape->channels;
st->codec->sample_rate = ape->samplerate; st->codecpar->sample_rate = ape->samplerate;
st->codec->bits_per_coded_sample = ape->bps; st->codecpar->bits_per_coded_sample = ape->bps;
st->nb_frames = ape->totalframes; st->nb_frames = ape->totalframes;
st->start_time = 0; st->start_time = 0;
st->duration = total_blocks / MAC_SUBFRAME_SIZE; st->duration = total_blocks / MAC_SUBFRAME_SIZE;
avpriv_set_pts_info(st, 64, MAC_SUBFRAME_SIZE, ape->samplerate); avpriv_set_pts_info(st, 64, MAC_SUBFRAME_SIZE, ape->samplerate);
st->codec->extradata = av_malloc(APE_EXTRADATA_SIZE); st->codecpar->extradata = av_malloc(APE_EXTRADATA_SIZE);
st->codec->extradata_size = APE_EXTRADATA_SIZE; st->codecpar->extradata_size = APE_EXTRADATA_SIZE;
AV_WL16(st->codec->extradata + 0, ape->fileversion); AV_WL16(st->codecpar->extradata + 0, ape->fileversion);
AV_WL16(st->codec->extradata + 2, ape->compressiontype); AV_WL16(st->codecpar->extradata + 2, ape->compressiontype);
AV_WL16(st->codec->extradata + 4, ape->formatflags); AV_WL16(st->codecpar->extradata + 4, ape->formatflags);
pts = 0; pts = 0;
for (i = 0; i < ape->totalframes; i++) { for (i = 0; i < ape->totalframes; i++) {

16
libavformat/apetag.c
Unescape View File

@ -87,22 +87,22 @@ static int ape_tag_read_field(AVFormatContext *s)
} }
st->disposition |= AV_DISPOSITION_ATTACHED_PIC; st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = id; st->codecpar->codec_id = id;
st->attached_pic = pkt; st->attached_pic = pkt;
st->attached_pic.stream_index = st->index; st->attached_pic.stream_index = st->index;
st->attached_pic.flags |= AV_PKT_FLAG_KEY; st->attached_pic.flags |= AV_PKT_FLAG_KEY;
} else { } else {
st->codec->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (avio_read(pb, st->codec->extradata, size) != size) { if (avio_read(pb, st->codecpar->extradata, size) != size) {
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
return AVERROR(EIO); return AVERROR(EIO);
} }
st->codec->extradata_size = size; st->codecpar->extradata_size = size;
st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT; st->codecpar->codec_type = AVMEDIA_TYPE_ATTACHMENT;
} }
} else { } else {
value = av_malloc(size+1); value = av_malloc(size+1);

30
libavformat/asfdec.c
Unescape View File

@ -431,8 +431,8 @@ static int asf_read_picture(AVFormatContext *s, int len)
} }
st->disposition |= AV_DISPOSITION_ATTACHED_PIC; st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codec->codec_type = asf_st->type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = asf_st->type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = id; st->codecpar->codec_id = id;
st->attached_pic = pkt; st->attached_pic = pkt;
st->attached_pic.stream_index = asf_st->index = st->index; st->attached_pic.stream_index = asf_st->index = st->index;
st->attached_pic.flags |= AV_PKT_FLAG_KEY; st->attached_pic.flags |= AV_PKT_FLAG_KEY;
@ -695,26 +695,26 @@ static int parse_video_info(AVIOContext *pb, AVStream *st)
uint16_t size; uint16_t size;
unsigned int tag; unsigned int tag;
st->codec->width = avio_rl32(pb); st->codecpar->width = avio_rl32(pb);
st->codec->height = avio_rl32(pb); st->codecpar->height = avio_rl32(pb);
avio_skip(pb, 1); // skip reserved flags avio_skip(pb, 1); // skip reserved flags
size = avio_rl16(pb); // size of the Format Data size = avio_rl16(pb); // size of the Format Data
tag = ff_get_bmp_header(pb, st); tag = ff_get_bmp_header(pb, st);
st->codec->codec_tag = tag; st->codecpar->codec_tag = tag;
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag); st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag);
if (size > BMP_HEADER_SIZE) { if (size > BMP_HEADER_SIZE) {
int ret; int ret;
st->codec->extradata_size = size - BMP_HEADER_SIZE; st->codecpar->extradata_size = size - BMP_HEADER_SIZE;
if (!(st->codec->extradata = av_malloc(st->codec->extradata_size + if (!(st->codecpar->extradata = av_malloc(st->codecpar->extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE))) { AV_INPUT_BUFFER_PADDING_SIZE))) {
st->codec->extradata_size = 0; st->codecpar->extradata_size = 0;
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
memset(st->codec->extradata + st->codec->extradata_size , 0, memset(st->codecpar->extradata + st->codecpar->extradata_size , 0,
AV_INPUT_BUFFER_PADDING_SIZE); AV_INPUT_BUFFER_PADDING_SIZE);
if ((ret = avio_read(pb, st->codec->extradata, if ((ret = avio_read(pb, st->codecpar->extradata,
st->codec->extradata_size)) < 0) st->codecpar->extradata_size)) < 0)
return ret; return ret;
} }
return 0; return 0;
@ -773,7 +773,7 @@ static int asf_read_stream_properties(AVFormatContext *s, const GUIDParseTable *
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 32, 1, 1000); // pts should be dword, in milliseconds avpriv_set_pts_info(st, 32, 1, 1000); // pts should be dword, in milliseconds
st->codec->codec_type = type; st->codecpar->codec_type = type;
asf->asf_st[asf->nb_streams] = av_mallocz(sizeof(*asf_st)); asf->asf_st[asf->nb_streams] = av_mallocz(sizeof(*asf_st));
if (!asf->asf_st[asf->nb_streams]) if (!asf->asf_st[asf->nb_streams])
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -790,7 +790,7 @@ static int asf_read_stream_properties(AVFormatContext *s, const GUIDParseTable *
switch (type) { switch (type) {
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
asf_st->type = AVMEDIA_TYPE_AUDIO; asf_st->type = AVMEDIA_TYPE_AUDIO;
if ((ret = ff_get_wav_header(s, pb, st->codec, ts_data_len)) < 0) if ((ret = ff_get_wav_header(s, pb, st->codecpar, ts_data_len)) < 0)
return ret; return ret;
break; break;
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
@ -867,7 +867,7 @@ static int asf_read_ext_stream_properties(AVFormatContext *s, const GUIDParseTab
if (st) { if (st) {
st->start_time = start_time; st->start_time = start_time;
st->duration = end_time - start_time; st->duration = end_time - start_time;
st->codec->bit_rate = bitrate; st->codecpar->bit_rate = bitrate;
st->avg_frame_rate.num = 10000000; st->avg_frame_rate.num = 10000000;
st->avg_frame_rate.den = time_per_frame; st->avg_frame_rate.den = time_per_frame;
} }

58
libavformat/asfenc.c
Unescape View File

@ -377,7 +377,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
int header_size, n, extra_size, extra_size2, wav_extra_size, file_time; int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;
int has_title; int has_title;
int metadata_count; int metadata_count;
AVCodecContext *enc; AVCodecParameters *par;
int64_t header_offset, cur_pos, hpos; int64_t header_offset, cur_pos, hpos;
int bit_rate; int bit_rate;
int64_t duration; int64_t duration;
@ -396,11 +396,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
bit_rate = 0; bit_rate = 0;
for (n = 0; n < s->nb_streams; n++) { for (n = 0; n < s->nb_streams; n++) {
enc = s->streams[n]->codec; par = s->streams[n]->codecpar;
avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */ avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
bit_rate += enc->bit_rate; bit_rate += par->bit_rate;
} }
if (asf->is_streamed) { if (asf->is_streamed) {
@ -479,11 +479,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
int64_t es_pos; int64_t es_pos;
// ASFStream *stream = &asf->streams[n]; // ASFStream *stream = &asf->streams[n];
enc = s->streams[n]->codec; par = s->streams[n]->codecpar;
asf->streams[n].num = n + 1; asf->streams[n].num = n + 1;
asf->streams[n].seq = 0; asf->streams[n].seq = 0;
switch (enc->codec_type) { switch (par->codec_type) {
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
wav_extra_size = 0; wav_extra_size = 0;
extra_size = 18 + wav_extra_size; extra_size = 18 + wav_extra_size;
@ -491,14 +491,14 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
break; break;
default: default:
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
wav_extra_size = enc->extradata_size; wav_extra_size = par->extradata_size;
extra_size = 0x33 + wav_extra_size; extra_size = 0x33 + wav_extra_size;
extra_size2 = 0; extra_size2 = 0;
break; break;
} }
hpos = put_header(pb, &ff_asf_stream_header); hpos = put_header(pb, &ff_asf_stream_header);
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
put_guid(pb, &ff_asf_audio_stream); put_guid(pb, &ff_asf_audio_stream);
put_guid(pb, &ff_asf_audio_conceal_spread); put_guid(pb, &ff_asf_audio_conceal_spread);
} else { } else {
@ -512,9 +512,9 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
avio_wl16(pb, n + 1); /* stream number */ avio_wl16(pb, n + 1); /* stream number */
avio_wl32(pb, 0); /* ??? */ avio_wl32(pb, 0); /* ??? */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
/* WAVEFORMATEX header */ /* WAVEFORMATEX header */
int wavsize = ff_put_wav_header(pb, enc); int wavsize = ff_put_wav_header(s, pb, par);
if (wavsize < 0) if (wavsize < 0)
return -1; return -1;
@ -526,23 +526,23 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
} }
/* ERROR Correction */ /* ERROR Correction */
avio_w8(pb, 0x01); avio_w8(pb, 0x01);
if (enc->codec_id == AV_CODEC_ID_ADPCM_G726 || !enc->block_align) { if (par->codec_id == AV_CODEC_ID_ADPCM_G726 || !par->block_align) {
avio_wl16(pb, 0x0190); avio_wl16(pb, 0x0190);
avio_wl16(pb, 0x0190); avio_wl16(pb, 0x0190);
} else { } else {
avio_wl16(pb, enc->block_align); avio_wl16(pb, par->block_align);
avio_wl16(pb, enc->block_align); avio_wl16(pb, par->block_align);
} }
avio_wl16(pb, 0x01); avio_wl16(pb, 0x01);
avio_w8(pb, 0x00); avio_w8(pb, 0x00);
} else { } else {
avio_wl32(pb, enc->width); avio_wl32(pb, par->width);
avio_wl32(pb, enc->height); avio_wl32(pb, par->height);
avio_w8(pb, 2); /* ??? */ avio_w8(pb, 2); /* ??? */
avio_wl16(pb, 40 + enc->extradata_size); /* size */ avio_wl16(pb, 40 + par->extradata_size); /* size */
/* BITMAPINFOHEADER header */ /* BITMAPINFOHEADER header */
ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 1); ff_put_bmp_header(pb, par, ff_codec_bmp_tags, 1);
} }
end_header(pb, hpos); end_header(pb, hpos);
} }
@ -556,17 +556,17 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
const AVCodecDescriptor *codec_desc; const AVCodecDescriptor *codec_desc;
const char *desc; const char *desc;
enc = s->streams[n]->codec; par = s->streams[n]->codecpar;
codec_desc = avcodec_descriptor_get(enc->codec_id); codec_desc = avcodec_descriptor_get(par->codec_id);
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) if (par->codec_type == AVMEDIA_TYPE_AUDIO)
avio_wl16(pb, 2); avio_wl16(pb, 2);
else if (enc->codec_type == AVMEDIA_TYPE_VIDEO) else if (par->codec_type == AVMEDIA_TYPE_VIDEO)
avio_wl16(pb, 1); avio_wl16(pb, 1);
else else
avio_wl16(pb, -1); avio_wl16(pb, -1);
if (enc->codec_id == AV_CODEC_ID_WMAV2) if (par->codec_id == AV_CODEC_ID_WMAV2)
desc = "Windows Media Audio V8"; desc = "Windows Media Audio V8";
else else
desc = codec_desc ? codec_desc->name : NULL; desc = codec_desc ? codec_desc->name : NULL;
@ -591,14 +591,14 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
avio_wl16(pb, 0); /* no parameters */ avio_wl16(pb, 0); /* no parameters */
/* id */ /* id */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
avio_wl16(pb, 2); avio_wl16(pb, 2);
avio_wl16(pb, enc->codec_tag); avio_wl16(pb, par->codec_tag);
} else { } else {
avio_wl16(pb, 4); avio_wl16(pb, 4);
avio_wl32(pb, enc->codec_tag); avio_wl32(pb, par->codec_tag);
} }
if (!enc->codec_tag) if (!par->codec_tag)
return -1; return -1;
} }
end_header(pb, hpos); end_header(pb, hpos);
@ -813,7 +813,7 @@ static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
PACKET_HEADER_MIN_SIZE - 1; PACKET_HEADER_MIN_SIZE - 1;
if (frag_len1 < payload_len && if (frag_len1 < payload_len &&
avst->codec->codec_type == AVMEDIA_TYPE_AUDIO) { avst->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
flush_packet(s); flush_packet(s);
continue; continue;
} }
@ -855,16 +855,16 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ASFStream *stream; ASFStream *stream;
int64_t duration; int64_t duration;
AVCodecContext *codec; AVCodecParameters *par;
int64_t packet_st, pts; int64_t packet_st, pts;
int start_sec, i; int start_sec, i;
int flags = pkt->flags; int flags = pkt->flags;
uint64_t offset = avio_tell(pb); uint64_t offset = avio_tell(pb);
codec = s->streams[pkt->stream_index]->codec; par = s->streams[pkt->stream_index]->codecpar;
stream = &asf->streams[pkt->stream_index]; stream = &asf->streams[pkt->stream_index];
if (codec->codec_type == AVMEDIA_TYPE_AUDIO) if (par->codec_type == AVMEDIA_TYPE_AUDIO)
flags &= ~AV_PKT_FLAG_KEY; flags &= ~AV_PKT_FLAG_KEY;
pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts; pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;

10
libavformat/assdec.c
Unescape View File

@ -91,11 +91,11 @@ static int read_header(AVFormatContext *s)
if (!st) if (!st)
return -1; return -1;
avpriv_set_pts_info(st, 64, 1, 100); avpriv_set_pts_info(st, 64, 1, 100);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_SSA; st->codecpar->codec_id = AV_CODEC_ID_SSA;
header_remaining = INT_MAX; header_remaining = INT_MAX;
dst[0] = &st->codec->extradata; dst[0] = &st->codecpar->extradata;
dst[1] = &ass->event_buffer; dst[1] = &ass->event_buffer;
while (!pb->eof_reached) { while (!pb->eof_reached) {
uint8_t line[MAX_LINESIZE]; uint8_t line[MAX_LINESIZE];
@ -123,7 +123,7 @@ static int read_header(AVFormatContext *s)
else else
header_remaining--; header_remaining--;
} }
st->codec->extradata_size = pos[0]; st->codecpar->extradata_size = pos[0];
if (ass->event_count >= UINT_MAX / sizeof(*ass->event)) if (ass->event_count >= UINT_MAX / sizeof(*ass->event))
goto fail; goto fail;
@ -163,7 +163,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
if (ret < 0) if (ret < 0)
return ret; return ret;
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
pkt->pos = p - ass->event_buffer + s->streams[0]->codec->extradata_size; pkt->pos = p - ass->event_buffer + s->streams[0]->codecpar->extradata_size;
pkt->pts = pkt->dts = get_pts(p); pkt->pts = pkt->dts = get_pts(p);
memcpy(pkt->data, p, pkt->size); memcpy(pkt->data, p, pkt->size);

16
libavformat/assenc.c
Unescape View File

@ -28,18 +28,18 @@ typedef struct ASSContext{
static int write_header(AVFormatContext *s) static int write_header(AVFormatContext *s)
{ {
ASSContext *ass = s->priv_data; ASSContext *ass = s->priv_data;
AVCodecContext *avctx= s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
uint8_t *last= NULL; uint8_t *last= NULL;
if(s->nb_streams != 1 || avctx->codec_id != AV_CODEC_ID_SSA){ if(s->nb_streams != 1 || par->codec_id != AV_CODEC_ID_SSA){
av_log(s, AV_LOG_ERROR, "Exactly one ASS/SSA stream is needed.\n"); av_log(s, AV_LOG_ERROR, "Exactly one ASS/SSA stream is needed.\n");
return -1; return -1;
} }
while(ass->extra_index < avctx->extradata_size){ while(ass->extra_index < par->extradata_size){
uint8_t *p = avctx->extradata + ass->extra_index; uint8_t *p = par->extradata + ass->extra_index;
uint8_t *end= strchr(p, '\n'); uint8_t *end= strchr(p, '\n');
if(!end) end= avctx->extradata + avctx->extradata_size; if(!end) end= par->extradata + par->extradata_size;
else end++; else end++;
avio_write(s->pb, p, end-p); avio_write(s->pb, p, end-p);
@ -64,10 +64,10 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
static int write_trailer(AVFormatContext *s) static int write_trailer(AVFormatContext *s)
{ {
ASSContext *ass = s->priv_data; ASSContext *ass = s->priv_data;
AVCodecContext *avctx= s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
avio_write(s->pb, avctx->extradata + ass->extra_index, avio_write(s->pb, par->extradata + ass->extra_index,
avctx->extradata_size - ass->extra_index); par->extradata_size - ass->extra_index);
return 0; return 0;
} }

30
libavformat/au.c
Unescape View File

@ -108,13 +108,13 @@ static int au_read_header(AVFormatContext *s)
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_tag = id; st->codecpar->codec_tag = id;
st->codec->codec_id = codec; st->codecpar->codec_id = codec;
st->codec->channels = channels; st->codecpar->channels = channels;
st->codec->sample_rate = rate; st->codecpar->sample_rate = rate;
st->codec->bit_rate = channels * rate * bps; st->codecpar->bit_rate = channels * rate * bps;
st->codec->block_align = channels * bps >> 3; st->codecpar->block_align = channels * bps >> 3;
st->start_time = 0; st->start_time = 0;
avpriv_set_pts_info(st, 64, 1, rate); avpriv_set_pts_info(st, 64, 1, rate);
@ -127,12 +127,12 @@ static int au_read_packet(AVFormatContext *s, AVPacket *pkt)
int ret; int ret;
ret = av_get_packet(s->pb, pkt, BLOCK_SIZE * ret = av_get_packet(s->pb, pkt, BLOCK_SIZE *
s->streams[0]->codec->block_align); s->streams[0]->codecpar->block_align);
if (ret < 0) if (ret < 0)
return ret; return ret;
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->duration = ret / s->streams[0]->codec->block_align; pkt->duration = ret / s->streams[0]->codecpar->block_align;
return 0; return 0;
} }
@ -157,17 +157,17 @@ AVInputFormat ff_au_demuxer = {
#define AU_UNKNOWN_SIZE ((uint32_t)(~0)) #define AU_UNKNOWN_SIZE ((uint32_t)(~0))
/* AUDIO_FILE header */ /* AUDIO_FILE header */
static int put_au_header(AVIOContext *pb, AVCodecContext *enc) static int put_au_header(AVIOContext *pb, AVCodecParameters *par)
{ {
if (!enc->codec_tag) if (!par->codec_tag)
return AVERROR(EINVAL); return AVERROR(EINVAL);
ffio_wfourcc(pb, ".snd"); /* magic number */ ffio_wfourcc(pb, ".snd"); /* magic number */
avio_wb32(pb, 24); /* header size */ avio_wb32(pb, 24); /* header size */
avio_wb32(pb, AU_UNKNOWN_SIZE); /* data size */ avio_wb32(pb, AU_UNKNOWN_SIZE); /* data size */
avio_wb32(pb, enc->codec_tag); /* codec ID */ avio_wb32(pb, par->codec_tag); /* codec ID */
avio_wb32(pb, enc->sample_rate); avio_wb32(pb, par->sample_rate);
avio_wb32(pb, enc->channels); avio_wb32(pb, par->channels);
return 0; return 0;
} }
@ -179,7 +179,7 @@ static int au_write_header(AVFormatContext *s)
s->priv_data = NULL; s->priv_data = NULL;
if ((ret = put_au_header(pb, s->streams[0]->codec)) < 0) if ((ret = put_au_header(pb, s->streams[0]->codecpar)) < 0)
return ret; return ret;
avio_flush(pb); avio_flush(pb);

12
libavformat/audiointerleave.c
Unescape View File

@ -33,7 +33,7 @@ void ff_audio_interleave_close(AVFormatContext *s)
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
AudioInterleaveContext *aic = st->priv_data; AudioInterleaveContext *aic = st->priv_data;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
av_fifo_free(aic->fifo); av_fifo_free(aic->fifo);
} }
} }
@ -51,9 +51,9 @@ int ff_audio_interleave_init(AVFormatContext *s,
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
AudioInterleaveContext *aic = st->priv_data; AudioInterleaveContext *aic = st->priv_data;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
aic->sample_size = (st->codec->channels * aic->sample_size = (st->codecpar->channels *
av_get_bits_per_sample(st->codec->codec_id)) / 8; av_get_bits_per_sample(st->codecpar->codec_id)) / 8;
if (!aic->sample_size) { if (!aic->sample_size) {
av_log(s, AV_LOG_ERROR, "could not compute sample size\n"); av_log(s, AV_LOG_ERROR, "could not compute sample size\n");
return -1; return -1;
@ -106,7 +106,7 @@ int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt
if (pkt) { if (pkt) {
AVStream *st = s->streams[pkt->stream_index]; AVStream *st = s->streams[pkt->stream_index];
AudioInterleaveContext *aic = st->priv_data; AudioInterleaveContext *aic = st->priv_data;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
unsigned new_size = av_fifo_size(aic->fifo) + pkt->size; unsigned new_size = av_fifo_size(aic->fifo) + pkt->size;
if (new_size > aic->fifo_size) { if (new_size > aic->fifo_size) {
if (av_fifo_realloc2(aic->fifo, new_size) < 0) if (av_fifo_realloc2(aic->fifo, new_size) < 0)
@ -126,7 +126,7 @@ int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
AVPacket new_pkt = { 0 }; AVPacket new_pkt = { 0 };
while (interleave_new_audio_packet(s, &new_pkt, i, flush)) while (interleave_new_audio_packet(s, &new_pkt, i, flush))
if ((ret = ff_interleave_add_packet(s, &new_pkt, compare_ts)) < 0) if ((ret = ff_interleave_add_packet(s, &new_pkt, compare_ts)) < 0)

24
libavformat/avformat.h
Unescape View File

@ -704,18 +704,13 @@ typedef struct AVStream {
* encoding: set by the user, replaced by libavformat if left unset * encoding: set by the user, replaced by libavformat if left unset
*/ */
int id; int id;
#if FF_API_LAVF_AVCTX
/** /**
* Codec context associated with this stream. Allocated and freed by * @deprecated use the codecpar struct instead
* libavformat.
*
* - decoding: The demuxer exports codec information stored in the headers
* here.
* - encoding: The user sets codec information, the muxer writes it to the
* output. Mandatory fields as specified in AVCodecContext
* documentation must be set even if this AVCodecContext is
* not actually used for encoding.
*/ */
attribute_deprecated
AVCodecContext *codec; AVCodecContext *codec;
#endif
void *priv_data; void *priv_data;
#if FF_API_LAVF_FRAC #if FF_API_LAVF_FRAC
@ -818,6 +813,17 @@ typedef struct AVStream {
int event_flags; int event_flags;
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata. #define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001 ///< The call resulted in updated metadata.
/*
* Codec parameters associated with this stream. Allocated and freed by
* libavformat in avformat_new_stream() and avformat_free_context()
* respectively.
*
* - demuxing: filled by libavformat on stream creation or in
* avformat_find_stream_info()
* - muxing: filled by the caller before avformat_write_header()
*/
AVCodecParameters *codecpar;
/***************************************************************** /*****************************************************************
* All fields below this line are not part of the public API. They * All fields below this line are not part of the public API. They
* may not be used outside of libavformat and can be changed and * may not be used outside of libavformat and can be changed and

135
libavformat/avidec.c
Unescape View File

@ -487,8 +487,8 @@ static int avi_read_header(AVFormatContext *s)
goto fail; goto fail;
ast = s->streams[0]->priv_data; ast = s->streams[0]->priv_data;
av_freep(&s->streams[0]->codec->extradata); av_freep(&s->streams[0]->codecpar->extradata);
av_freep(&s->streams[0]->codec); av_freep(&s->streams[0]->codecpar);
av_freep(&s->streams[0]->info); av_freep(&s->streams[0]->info);
av_freep(&s->streams[0]); av_freep(&s->streams[0]);
s->nb_streams = 0; s->nb_streams = 0;
@ -606,10 +606,10 @@ static int avi_read_header(AVFormatContext *s)
switch (codec_type) { switch (codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
if (amv_file_format) { if (amv_file_format) {
st->codec->width = avih_width; st->codecpar->width = avih_width;
st->codec->height = avih_height; st->codecpar->height = avih_height;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_AMV; st->codecpar->codec_id = AV_CODEC_ID_AMV;
avio_skip(pb, size); avio_skip(pb, size);
break; break;
} }
@ -617,41 +617,41 @@ static int avi_read_header(AVFormatContext *s)
if (tag1 == MKTAG('D', 'X', 'S', 'B') || if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
tag1 == MKTAG('D', 'X', 'S', 'A')) { tag1 == MKTAG('D', 'X', 'S', 'A')) {
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_tag = tag1; st->codecpar->codec_tag = tag1;
st->codec->codec_id = AV_CODEC_ID_XSUB; st->codecpar->codec_id = AV_CODEC_ID_XSUB;
break; break;
} }
if (size > 10 * 4 && size < (1 << 30)) { if (size > 10 * 4 && size < (1 << 30)) {
st->codec->extradata_size = size - 10 * 4; st->codecpar->extradata_size = size - 10 * 4;
st->codec->extradata = av_malloc(st->codec->extradata_size + st->codecpar->extradata = av_malloc(st->codecpar->extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE); AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) { if (!st->codecpar->extradata) {
st->codec->extradata_size = 0; st->codecpar->extradata_size = 0;
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
avio_read(pb, avio_read(pb,
st->codec->extradata, st->codecpar->extradata,
st->codec->extradata_size); st->codecpar->extradata_size);
} }
// FIXME: check if the encoder really did this correctly // FIXME: check if the encoder really did this correctly
if (st->codec->extradata_size & 1) if (st->codecpar->extradata_size & 1)
avio_r8(pb); avio_r8(pb);
/* Extract palette from extradata if bpp <= 8. /* Extract palette from extradata if bpp <= 8.
* This code assumes that extradata contains only palette. * This code assumes that extradata contains only palette.
* This is true for all paletted codecs implemented in * This is true for all paletted codecs implemented in
* Libav. */ * Libav. */
if (st->codec->extradata_size && if (st->codecpar->extradata_size &&
(st->codec->bits_per_coded_sample <= 8)) { (st->codecpar->bits_per_coded_sample <= 8)) {
int pal_size = (1 << st->codec->bits_per_coded_sample) << 2; int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;
const uint8_t *pal_src; const uint8_t *pal_src;
pal_size = FFMIN(pal_size, st->codec->extradata_size); pal_size = FFMIN(pal_size, st->codecpar->extradata_size);
pal_src = st->codec->extradata + pal_src = st->codecpar->extradata +
st->codec->extradata_size - pal_size; st->codecpar->extradata_size - pal_size;
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
for (i = 0; i < pal_size / 4; i++) for (i = 0; i < pal_size / 4; i++)
ast->pal[i] = av_bswap32(((uint32_t *)pal_src)[i]); ast->pal[i] = av_bswap32(((uint32_t *)pal_src)[i]);
@ -663,17 +663,17 @@ static int avi_read_header(AVFormatContext *s)
print_tag("video", tag1, 0); print_tag("video", tag1, 0);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_tag = tag1; st->codecpar->codec_tag = tag1;
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags,
tag1); tag1);
/* If codec is not found yet, try with the mov tags. */ /* If codec is not found yet, try with the mov tags. */
if (!st->codec->codec_id) { if (!st->codecpar->codec_id) {
char tag_buf[32]; char tag_buf[32];
av_get_codec_tag_string(tag_buf, sizeof(tag_buf), tag1); av_get_codec_tag_string(tag_buf, sizeof(tag_buf), tag1);
st->codec->codec_id = st->codecpar->codec_id =
ff_codec_get_id(ff_codec_movvideo_tags, tag1); ff_codec_get_id(ff_codec_movvideo_tags, tag1);
if (st->codec->codec_id) if (st->codecpar->codec_id)
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
"mov tag found in avi (fourcc %s)\n", "mov tag found in avi (fourcc %s)\n",
tag_buf); tag_buf);
@ -682,45 +682,45 @@ static int avi_read_header(AVFormatContext *s)
* for generating correct pts. */ * for generating correct pts. */
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
if (st->codec->codec_id == AV_CODEC_ID_MPEG4 && if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&
ast->handler == MKTAG('X', 'V', 'I', 'D')) ast->handler == MKTAG('X', 'V', 'I', 'D'))
st->codec->codec_tag = MKTAG('X', 'V', 'I', 'D'); st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');
// Support "Resolution 1:1" for Avid AVI Codec // Support "Resolution 1:1" for Avid AVI Codec
if (tag1 == MKTAG('A', 'V', 'R', 'n') && if (tag1 == MKTAG('A', 'V', 'R', 'n') &&
st->codec->extradata_size >= 31 && st->codecpar->extradata_size >= 31 &&
!memcmp(&st->codec->extradata[28], "1:1", 3)) !memcmp(&st->codecpar->extradata[28], "1:1", 3))
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
if (st->codec->codec_tag == 0 && st->codec->height > 0 && if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&
st->codec->extradata_size < 1U << 30) { st->codecpar->extradata_size < 1U << 30) {
st->codec->extradata_size += 9; st->codecpar->extradata_size += 9;
if ((ret = av_reallocp(&st->codec->extradata, if ((ret = av_reallocp(&st->codecpar->extradata,
st->codec->extradata_size + st->codecpar->extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE)) < 0) { AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
st->codec->extradata_size = 0; st->codecpar->extradata_size = 0;
return ret; return ret;
} else } else
memcpy(st->codec->extradata + st->codec->extradata_size - 9, memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,
"BottomUp", 9); "BottomUp", 9);
} }
st->codec->height = FFABS(st->codec->height); st->codecpar->height = FFABS(st->codecpar->height);
// avio_skip(pb, size - 5 * 4); // avio_skip(pb, size - 5 * 4);
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
ret = ff_get_wav_header(s, pb, st->codec, size); ret = ff_get_wav_header(s, pb, st->codecpar, size);
if (ret < 0) if (ret < 0)
return ret; return ret;
ast->dshow_block_align = st->codec->block_align; ast->dshow_block_align = st->codecpar->block_align;
if (ast->sample_size && st->codec->block_align && if (ast->sample_size && st->codecpar->block_align &&
ast->sample_size != st->codec->block_align) { ast->sample_size != st->codecpar->block_align) {
av_log(s, av_log(s,
AV_LOG_WARNING, AV_LOG_WARNING,
"sample size (%d) != block align (%d)\n", "sample size (%d) != block align (%d)\n",
ast->sample_size, ast->sample_size,
st->codec->block_align); st->codecpar->block_align);
ast->sample_size = st->codec->block_align; ast->sample_size = st->codecpar->block_align;
} }
/* 2-aligned /* 2-aligned
* (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */ * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
@ -732,28 +732,28 @@ static int avi_read_header(AVFormatContext *s)
/* ADTS header is in extradata, AAC without header must be /* ADTS header is in extradata, AAC without header must be
* stored as exact frames. Parser not needed and it will * stored as exact frames. Parser not needed and it will
* fail. */ * fail. */
if (st->codec->codec_id == AV_CODEC_ID_AAC && if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
st->codec->extradata_size) st->codecpar->extradata_size)
st->need_parsing = AVSTREAM_PARSE_NONE; st->need_parsing = AVSTREAM_PARSE_NONE;
/* AVI files with Xan DPCM audio (wrongly) declare PCM /* AVI files with Xan DPCM audio (wrongly) declare PCM
* audio in the header but have Axan as stream_code_tag. */ * audio in the header but have Axan as stream_code_tag. */
if (ast->handler == AV_RL32("Axan")) { if (ast->handler == AV_RL32("Axan")) {
st->codec->codec_id = AV_CODEC_ID_XAN_DPCM; st->codecpar->codec_id = AV_CODEC_ID_XAN_DPCM;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
} }
if (amv_file_format) { if (amv_file_format) {
st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_AMV; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_AMV;
ast->dshow_block_align = 0; ast->dshow_block_align = 0;
} }
break; break;
case AVMEDIA_TYPE_SUBTITLE: case AVMEDIA_TYPE_SUBTITLE:
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_PROBE; st->codecpar->codec_id = AV_CODEC_ID_PROBE;
break; break;
default: default:
st->codec->codec_type = AVMEDIA_TYPE_DATA; st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
st->codec->codec_id = AV_CODEC_ID_NONE; st->codecpar->codec_id = AV_CODEC_ID_NONE;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
avio_skip(pb, size); avio_skip(pb, size);
break; break;
} }
@ -895,8 +895,7 @@ static int read_gab2_sub(AVStream *st, AVPacket *pkt)
ast->sub_ctx->pb = pb; ast->sub_ctx->pb = pb;
if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) { if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
ff_read_packet(ast->sub_ctx, &ast->sub_pkt); ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
*st->codec = *ast->sub_ctx->streams[0]->codec; avcodec_parameters_copy(st->codecpar, ast->sub_ctx->streams[0]->codecpar);
ast->sub_ctx->streams[0]->codec->extradata = NULL;
time_base = ast->sub_ctx->streams[0]->time_base; time_base = ast->sub_ctx->streams[0]->time_base;
avpriv_set_pts_info(st, 64, time_base.num, time_base.den); avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
} }
@ -1022,8 +1021,8 @@ start_sync:
AVIStream *ast1 = st1->priv_data; AVIStream *ast1 = st1->priv_data;
// workaround for broken small-file-bug402.avi // workaround for broken small-file-bug402.avi
if (d[2] == 'w' && d[3] == 'b' && n == 0 && if (d[2] == 'w' && d[3] == 'b' && n == 0 &&
st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
st1->codec->codec_type == AVMEDIA_TYPE_AUDIO && st1->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
ast->prefix == 'd' * 256 + 'c' && ast->prefix == 'd' * 256 + 'c' &&
(d[2] * 256 + d[3] == ast1->prefix || (d[2] * 256 + d[3] == ast1->prefix ||
!ast1->prefix_count)) { !ast1->prefix_count)) {
@ -1230,8 +1229,8 @@ resync:
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
if (size < 0) if (size < 0)
av_packet_unref(pkt); av_packet_unref(pkt);
} else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
!st->codec->codec_tag && read_gab2_sub(st, pkt)) { !st->codecpar->codec_tag && read_gab2_sub(st, pkt)) {
ast->frame_offset++; ast->frame_offset++;
avi->stream_index = -1; avi->stream_index = -1;
ast->remaining = 0; ast->remaining = 0;
@ -1255,7 +1254,7 @@ resync:
size); size);
pkt->stream_index = avi->stream_index; pkt->stream_index = avi->stream_index;
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
AVIndexEntry *e; AVIndexEntry *e;
int index; int index;
assert(st->index_entries); assert(st->index_entries);
@ -1391,7 +1390,7 @@ static int check_stream_max_drift(AVFormatContext *s)
max_dts = FFMAX(max_dts, dts); max_dts = FFMAX(max_dts, dts);
max_buffer = FFMAX(max_buffer, max_buffer = FFMAX(max_buffer,
av_rescale(dts - min_dts, av_rescale(dts - min_dts,
st->codec->bit_rate, st->codecpar->bit_rate,
AV_TIME_BASE)); AV_TIME_BASE));
} }
} }
@ -1555,7 +1554,7 @@ static int avi_read_seek(AVFormatContext *s, int stream_index,
if (st2->nb_index_entries <= 0) if (st2->nb_index_entries <= 0)
continue; continue;
// assert(st2->codec->block_align); // assert(st2->codecpar->block_align);
assert((int64_t)st2->time_base.num * ast2->rate == assert((int64_t)st2->time_base.num * ast2->rate ==
(int64_t)st2->time_base.den * ast2->scale); (int64_t)st2->time_base.den * ast2->scale);
index = av_index_search_timestamp(st2, index = av_index_search_timestamp(st2,

98
libavformat/avienc.c
Unescape View File

@ -111,21 +111,21 @@ static int avi_write_counters(AVFormatContext *s, int riff_id)
AVIContext *avi = s->priv_data; AVIContext *avi = s->priv_data;
int n, au_byterate, au_ssize, au_scale, nb_frames = 0; int n, au_byterate, au_ssize, au_scale, nb_frames = 0;
int64_t file_size; int64_t file_size;
AVCodecContext *stream; AVCodecParameters *par;
file_size = avio_tell(pb); file_size = avio_tell(pb);
for (n = 0; n < s->nb_streams; n++) { for (n = 0; n < s->nb_streams; n++) {
AVIStream *avist = s->streams[n]->priv_data; AVIStream *avist = s->streams[n]->priv_data;
assert(avist->frames_hdr_strm); assert(avist->frames_hdr_strm);
stream = s->streams[n]->codec; par = s->streams[n]->codecpar;
avio_seek(pb, avist->frames_hdr_strm, SEEK_SET); avio_seek(pb, avist->frames_hdr_strm, SEEK_SET);
ff_parse_specific_params(s->streams[n], &au_byterate, &au_ssize, &au_scale); ff_parse_specific_params(s->streams[n], &au_byterate, &au_ssize, &au_scale);
if (au_ssize == 0) if (au_ssize == 0)
avio_wl32(pb, avist->packet_count); avio_wl32(pb, avist->packet_count);
else else
avio_wl32(pb, avist->audio_strm_length / au_ssize); avio_wl32(pb, avist->audio_strm_length / au_ssize);
if (stream->codec_type == AVMEDIA_TYPE_VIDEO) if (par->codec_type == AVMEDIA_TYPE_VIDEO)
nb_frames = FFMAX(nb_frames, avist->packet_count); nb_frames = FFMAX(nb_frames, avist->packet_count);
} }
if (riff_id == 1) { if (riff_id == 1) {
@ -143,7 +143,7 @@ static int avi_write_header(AVFormatContext *s)
AVIContext *avi = s->priv_data; AVIContext *avi = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale; int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
AVCodecContext *video_enc; AVCodecParameters *video_par;
AVStream *video_st = NULL; AVStream *video_st = NULL;
int64_t list1, list2, strh, strf; int64_t list1, list2, strh, strf;
AVDictionaryEntry *t = NULL; AVDictionaryEntry *t = NULL;
@ -169,12 +169,12 @@ static int avi_write_header(AVFormatContext *s)
avio_wl32(pb, 14 * 4); avio_wl32(pb, 14 * 4);
bitrate = 0; bitrate = 0;
video_enc = NULL; video_par = NULL;
for (n = 0; n < s->nb_streams; n++) { for (n = 0; n < s->nb_streams; n++) {
AVCodecContext *codec = s->streams[n]->codec; AVCodecParameters *par = s->streams[n]->codecpar;
bitrate += codec->bit_rate; bitrate += par->bit_rate;
if (codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
video_enc = codec; video_par = par;
video_st = s->streams[n]; video_st = s->streams[n];
} }
} }
@ -198,9 +198,9 @@ static int avi_write_header(AVFormatContext *s)
avio_wl32(pb, 0); /* initial frame */ avio_wl32(pb, 0); /* initial frame */
avio_wl32(pb, s->nb_streams); /* nb streams */ avio_wl32(pb, s->nb_streams); /* nb streams */
avio_wl32(pb, 1024 * 1024); /* suggested buffer size */ avio_wl32(pb, 1024 * 1024); /* suggested buffer size */
if (video_enc) { if (video_par) {
avio_wl32(pb, video_enc->width); avio_wl32(pb, video_par->width);
avio_wl32(pb, video_enc->height); avio_wl32(pb, video_par->height);
} else { } else {
avio_wl32(pb, 0); avio_wl32(pb, 0);
avio_wl32(pb, 0); avio_wl32(pb, 0);
@ -213,18 +213,18 @@ static int avi_write_header(AVFormatContext *s)
/* stream list */ /* stream list */
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
AVCodecContext *enc = st->codec; AVCodecParameters *par = st->codecpar;
AVIStream *avist = st->priv_data; AVIStream *avist = st->priv_data;
list2 = ff_start_tag(pb, "LIST"); list2 = ff_start_tag(pb, "LIST");
ffio_wfourcc(pb, "strl"); ffio_wfourcc(pb, "strl");
/* stream generic header */ /* stream generic header */
strh = ff_start_tag(pb, "strh"); strh = ff_start_tag(pb, "strh");
switch (enc->codec_type) { switch (par->codec_type) {
case AVMEDIA_TYPE_SUBTITLE: case AVMEDIA_TYPE_SUBTITLE:
// XSUB subtitles behave like video tracks, other subtitles // XSUB subtitles behave like video tracks, other subtitles
// are not (yet) supported. // are not (yet) supported.
if (enc->codec_id != AV_CODEC_ID_XSUB) { if (par->codec_id != AV_CODEC_ID_XSUB) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n"); "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
@ -242,9 +242,9 @@ static int avi_write_header(AVFormatContext *s)
ffio_wfourcc(pb, "dats"); ffio_wfourcc(pb, "dats");
break; break;
} }
if (enc->codec_type == AVMEDIA_TYPE_VIDEO || if (par->codec_type == AVMEDIA_TYPE_VIDEO ||
enc->codec_id == AV_CODEC_ID_XSUB) par->codec_id == AV_CODEC_ID_XSUB)
avio_wl32(pb, enc->codec_tag); avio_wl32(pb, par->codec_tag);
else else
avio_wl32(pb, 1); avio_wl32(pb, 1);
avio_wl32(pb, 0); /* flags */ avio_wl32(pb, 0); /* flags */
@ -268,32 +268,32 @@ static int avi_write_header(AVFormatContext *s)
avio_wl32(pb, 0); /* length, XXX: filled later */ avio_wl32(pb, 0); /* length, XXX: filled later */
/* suggested buffer size */ //FIXME set at the end to largest chunk /* suggested buffer size */ //FIXME set at the end to largest chunk
if (enc->codec_type == AVMEDIA_TYPE_VIDEO) if (par->codec_type == AVMEDIA_TYPE_VIDEO)
avio_wl32(pb, 1024 * 1024); avio_wl32(pb, 1024 * 1024);
else if (enc->codec_type == AVMEDIA_TYPE_AUDIO) else if (par->codec_type == AVMEDIA_TYPE_AUDIO)
avio_wl32(pb, 12 * 1024); avio_wl32(pb, 12 * 1024);
else else
avio_wl32(pb, 0); avio_wl32(pb, 0);
avio_wl32(pb, -1); /* quality */ avio_wl32(pb, -1); /* quality */
avio_wl32(pb, au_ssize); /* sample size */ avio_wl32(pb, au_ssize); /* sample size */
avio_wl32(pb, 0); avio_wl32(pb, 0);
avio_wl16(pb, enc->width); avio_wl16(pb, par->width);
avio_wl16(pb, enc->height); avio_wl16(pb, par->height);
ff_end_tag(pb, strh); ff_end_tag(pb, strh);
if (enc->codec_type != AVMEDIA_TYPE_DATA) { if (par->codec_type != AVMEDIA_TYPE_DATA) {
strf = ff_start_tag(pb, "strf"); strf = ff_start_tag(pb, "strf");
switch (enc->codec_type) { switch (par->codec_type) {
case AVMEDIA_TYPE_SUBTITLE: case AVMEDIA_TYPE_SUBTITLE:
/* XSUB subtitles behave like video tracks, other subtitles /* XSUB subtitles behave like video tracks, other subtitles
* are not (yet) supported. */ * are not (yet) supported. */
if (enc->codec_id != AV_CODEC_ID_XSUB) if (par->codec_id != AV_CODEC_ID_XSUB)
break; break;
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 0); ff_put_bmp_header(pb, par, ff_codec_bmp_tags, 0);
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
if (ff_put_wav_header(pb, enc) < 0) if (ff_put_wav_header(s, pb, par) < 0)
return -1; return -1;
break; break;
default: default:
@ -320,7 +320,7 @@ static int avi_write_header(AVFormatContext *s)
avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */ avio_w8(pb, 0); /* bIndexSubType (0 == frame index) */
avio_w8(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */ avio_w8(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
avio_wl32(pb, 0); /* nEntriesInUse (will fill out later on) */ avio_wl32(pb, 0); /* nEntriesInUse (will fill out later on) */
ffio_wfourcc(pb, avi_stream2fourcc(tag, i, enc->codec_type)); ffio_wfourcc(pb, avi_stream2fourcc(tag, i, par->codec_type));
/* dwChunkId */ /* dwChunkId */
avio_wl64(pb, 0); /* dwReserved[3] */ avio_wl64(pb, 0); /* dwReserved[3] */
// avio_wl32(pb, 0); /* Must be 0. */ // avio_wl32(pb, 0); /* Must be 0. */
@ -329,13 +329,13 @@ static int avi_write_header(AVFormatContext *s)
ff_end_tag(pb, avist->indexes.indx_start); ff_end_tag(pb, avist->indexes.indx_start);
} }
if (enc->codec_type == AVMEDIA_TYPE_VIDEO && if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
st->sample_aspect_ratio.num > 0 && st->sample_aspect_ratio.num > 0 &&
st->sample_aspect_ratio.den > 0) { st->sample_aspect_ratio.den > 0) {
int vprp = ff_start_tag(pb, "vprp"); int vprp = ff_start_tag(pb, "vprp");
AVRational dar = av_mul_q(st->sample_aspect_ratio, AVRational dar = av_mul_q(st->sample_aspect_ratio,
(AVRational) { enc->width, (AVRational) { par->width,
enc->height }); par->height });
int num, den; int num, den;
av_reduce(&num, &den, dar.num, dar.den, 0xFFFF); av_reduce(&num, &den, dar.num, dar.den, 0xFFFF);
@ -343,18 +343,18 @@ static int avi_write_header(AVFormatContext *s)
avio_wl32(pb, 0); // video standard = unknown avio_wl32(pb, 0); // video standard = unknown
// TODO: should be avg_frame_rate // TODO: should be avg_frame_rate
avio_wl32(pb, lrintf(1.0 / av_q2d(st->time_base))); avio_wl32(pb, lrintf(1.0 / av_q2d(st->time_base)));
avio_wl32(pb, enc->width); avio_wl32(pb, par->width);
avio_wl32(pb, enc->height); avio_wl32(pb, par->height);
avio_wl16(pb, den); avio_wl16(pb, den);
avio_wl16(pb, num); avio_wl16(pb, num);
avio_wl32(pb, enc->width); avio_wl32(pb, par->width);
avio_wl32(pb, enc->height); avio_wl32(pb, par->height);
avio_wl32(pb, 1); // progressive FIXME avio_wl32(pb, 1); // progressive FIXME
avio_wl32(pb, enc->height); avio_wl32(pb, par->height);
avio_wl32(pb, enc->width); avio_wl32(pb, par->width);
avio_wl32(pb, enc->height); avio_wl32(pb, par->height);
avio_wl32(pb, enc->width); avio_wl32(pb, par->width);
avio_wl32(pb, 0); avio_wl32(pb, 0);
avio_wl32(pb, 0); avio_wl32(pb, 0);
@ -412,7 +412,7 @@ static int avi_write_ix(AVFormatContext *s)
AVIStream *avist = s->streams[i]->priv_data; AVIStream *avist = s->streams[i]->priv_data;
int64_t ix, pos; int64_t ix, pos;
avi_stream2fourcc(tag, i, s->streams[i]->codec->codec_type); avi_stream2fourcc(tag, i, s->streams[i]->codecpar->codec_type);
ix_tag[3] = '0' + i; ix_tag[3] = '0' + i;
/* Writing AVI OpenDML leaf index chunk */ /* Writing AVI OpenDML leaf index chunk */
@ -489,7 +489,7 @@ static int avi_write_idx1(AVFormatContext *s)
if (!empty) { if (!empty) {
avist = s->streams[stream_id]->priv_data; avist = s->streams[stream_id]->priv_data;
avi_stream2fourcc(tag, stream_id, avi_stream2fourcc(tag, stream_id,
s->streams[stream_id]->codec->codec_type); s->streams[stream_id]->codecpar->codec_type);
ffio_wfourcc(pb, tag); ffio_wfourcc(pb, tag);
avio_wl32(pb, ie->flags); avio_wl32(pb, ie->flags);
avio_wl32(pb, ie->pos); avio_wl32(pb, ie->pos);
@ -513,9 +513,9 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
AVIContext *avi = s->priv_data; AVIContext *avi = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVIStream *avist = s->streams[stream_index]->priv_data; AVIStream *avist = s->streams[stream_index]->priv_data;
AVCodecContext *enc = s->streams[stream_index]->codec; AVCodecParameters *par = s->streams[stream_index]->codecpar;
while (enc->block_align == 0 && pkt->dts != AV_NOPTS_VALUE && while (par->block_align == 0 && pkt->dts != AV_NOPTS_VALUE &&
pkt->dts > avist->packet_count) { pkt->dts > avist->packet_count) {
AVPacket empty_packet; AVPacket empty_packet;
@ -540,10 +540,10 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi"); avi->movi_list = avi_start_new_riff(s, pb, "AVIX", "movi");
} }
avi_stream2fourcc(tag, stream_index, enc->codec_type); avi_stream2fourcc(tag, stream_index, par->codec_type);
if (pkt->flags & AV_PKT_FLAG_KEY) if (pkt->flags & AV_PKT_FLAG_KEY)
flags = 0x10; flags = 0x10;
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) if (par->codec_type == AVMEDIA_TYPE_AUDIO)
avist->audio_strm_length += size; avist->audio_strm_length += size;
if (s->pb->seekable) { if (s->pb->seekable) {
@ -604,15 +604,15 @@ static int avi_write_trailer(AVFormatContext *s)
avio_skip(pb, 16); avio_skip(pb, 16);
for (n = nb_frames = 0; n < s->nb_streams; n++) { for (n = nb_frames = 0; n < s->nb_streams; n++) {
AVCodecContext *stream = s->streams[n]->codec; AVCodecParameters *par = s->streams[n]->codecpar;
AVIStream *avist = s->streams[n]->priv_data; AVIStream *avist = s->streams[n]->priv_data;
if (stream->codec_type == AVMEDIA_TYPE_VIDEO) { if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
if (nb_frames < avist->packet_count) if (nb_frames < avist->packet_count)
nb_frames = avist->packet_count; nb_frames = avist->packet_count;
} else { } else {
if (stream->codec_id == AV_CODEC_ID_MP2 || if (par->codec_id == AV_CODEC_ID_MP2 ||
stream->codec_id == AV_CODEC_ID_MP3) par->codec_id == AV_CODEC_ID_MP3)
nb_frames += avist->packet_count; nb_frames += avist->packet_count;
} }
} }

58
libavformat/avisynth.c
Unescape View File

@ -233,10 +233,10 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
AviSynthContext *avs = s->priv_data; AviSynthContext *avs = s->priv_data;
int planar = 0; // 0: packed, 1: YUV, 2: Y8 int planar = 0; // 0: packed, 1: YUV, 2: Y8
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->width = avs->vi->width; st->codecpar->width = avs->vi->width;
st->codec->height = avs->vi->height; st->codecpar->height = avs->vi->height;
st->time_base = (AVRational) { avs->vi->fps_denominator, st->time_base = (AVRational) { avs->vi->fps_denominator,
avs->vi->fps_numerator }; avs->vi->fps_numerator };
@ -249,38 +249,38 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
switch (avs->vi->pixel_type) { switch (avs->vi->pixel_type) {
#ifdef USING_AVISYNTH #ifdef USING_AVISYNTH
case AVS_CS_YV24: case AVS_CS_YV24:
st->codec->pix_fmt = AV_PIX_FMT_YUV444P; st->codecpar->format = AV_PIX_FMT_YUV444P;
planar = 1; planar = 1;
break; break;
case AVS_CS_YV16: case AVS_CS_YV16:
st->codec->pix_fmt = AV_PIX_FMT_YUV422P; st->codecpar->format = AV_PIX_FMT_YUV422P;
planar = 1; planar = 1;
break; break;
case AVS_CS_YV411: case AVS_CS_YV411:
st->codec->pix_fmt = AV_PIX_FMT_YUV411P; st->codecpar->format = AV_PIX_FMT_YUV411P;
planar = 1; planar = 1;
break; break;
case AVS_CS_Y8: case AVS_CS_Y8:
st->codec->pix_fmt = AV_PIX_FMT_GRAY8; st->codecpar->format = AV_PIX_FMT_GRAY8;
planar = 2; planar = 2;
break; break;
#endif #endif
case AVS_CS_BGR24: case AVS_CS_BGR24:
st->codec->pix_fmt = AV_PIX_FMT_BGR24; st->codecpar->format = AV_PIX_FMT_BGR24;
break; break;
case AVS_CS_BGR32: case AVS_CS_BGR32:
st->codec->pix_fmt = AV_PIX_FMT_RGB32; st->codecpar->format = AV_PIX_FMT_RGB32;
break; break;
case AVS_CS_YUY2: case AVS_CS_YUY2:
st->codec->pix_fmt = AV_PIX_FMT_YUYV422; st->codecpar->format = AV_PIX_FMT_YUYV422;
break; break;
case AVS_CS_YV12: case AVS_CS_YV12:
st->codec->pix_fmt = AV_PIX_FMT_YUV420P; st->codecpar->format = AV_PIX_FMT_YUV420P;
planar = 1; planar = 1;
break; break;
case AVS_CS_I420: // Is this even used anywhere? case AVS_CS_I420: // Is this even used anywhere?
st->codec->pix_fmt = AV_PIX_FMT_YUV420P; st->codecpar->format = AV_PIX_FMT_YUV420P;
planar = 1; planar = 1;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
@ -309,28 +309,28 @@ static int avisynth_create_stream_audio(AVFormatContext *s, AVStream *st)
{ {
AviSynthContext *avs = s->priv_data; AviSynthContext *avs = s->priv_data;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->sample_rate = avs->vi->audio_samples_per_second; st->codecpar->sample_rate = avs->vi->audio_samples_per_second;
st->codec->channels = avs->vi->nchannels; st->codecpar->channels = avs->vi->nchannels;
st->time_base = (AVRational) { 1, st->time_base = (AVRational) { 1,
avs->vi->audio_samples_per_second }; avs->vi->audio_samples_per_second };
st->duration = avs->vi->num_audio_samples; st->duration = avs->vi->num_audio_samples;
switch (avs->vi->sample_type) { switch (avs->vi->sample_type) {
case AVS_SAMPLE_INT8: case AVS_SAMPLE_INT8:
st->codec->codec_id = AV_CODEC_ID_PCM_U8; st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
break; break;
case AVS_SAMPLE_INT16: case AVS_SAMPLE_INT16:
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
break; break;
case AVS_SAMPLE_INT24: case AVS_SAMPLE_INT24:
st->codec->codec_id = AV_CODEC_ID_PCM_S24LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
break; break;
case AVS_SAMPLE_INT32: case AVS_SAMPLE_INT32:
st->codec->codec_id = AV_CODEC_ID_PCM_S32LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
break; break;
case AVS_SAMPLE_FLOAT: case AVS_SAMPLE_FLOAT:
st->codec->codec_id = AV_CODEC_ID_PCM_F32LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
@ -639,7 +639,7 @@ static int avisynth_read_packet(AVFormatContext *s, AVPacket *pkt)
/* If either stream reaches EOF, try to read the other one before /* If either stream reaches EOF, try to read the other one before
* giving up. */ * giving up. */
avisynth_next_stream(s, &st, pkt, &discard); avisynth_next_stream(s, &st, pkt, &discard);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
ret = avisynth_read_packet_video(s, pkt, discard); ret = avisynth_read_packet_video(s, pkt, discard);
if (ret == AVERROR_EOF && avs_has_audio(avs->vi)) { if (ret == AVERROR_EOF && avs_has_audio(avs->vi)) {
avisynth_next_stream(s, &st, pkt, &discard); avisynth_next_stream(s, &st, pkt, &discard);
@ -681,7 +681,7 @@ static int avisynth_read_seek(AVFormatContext *s, int stream_index,
samplerate = (AVRational) { avs->vi->audio_samples_per_second, 1 }; samplerate = (AVRational) { avs->vi->audio_samples_per_second, 1 };
st = s->streams[stream_index]; st = s->streams[stream_index];
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
/* AviSynth frame counts are signed int. */ /* AviSynth frame counts are signed int. */
if ((timestamp >= avs->vi->num_frames) || if ((timestamp >= avs->vi->num_frames) ||
(timestamp > INT_MAX) || (timestamp > INT_MAX) ||

12
libavformat/avs.c
Unescape View File

@ -184,11 +184,11 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt)
avs->st_video = avformat_new_stream(s, NULL); avs->st_video = avformat_new_stream(s, NULL);
if (!avs->st_video) if (!avs->st_video)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avs->st_video->codec->codec_type = AVMEDIA_TYPE_VIDEO; avs->st_video->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
avs->st_video->codec->codec_id = AV_CODEC_ID_AVS; avs->st_video->codecpar->codec_id = AV_CODEC_ID_AVS;
avs->st_video->codec->width = avs->width; avs->st_video->codecpar->width = avs->width;
avs->st_video->codec->height = avs->height; avs->st_video->codecpar->height = avs->height;
avs->st_video->codec->bits_per_coded_sample=avs->bits_per_sample; avs->st_video->codecpar->bits_per_coded_sample=avs->bits_per_sample;
avs->st_video->nb_frames = avs->nb_frames; avs->st_video->nb_frames = avs->nb_frames;
avs->st_video->avg_frame_rate = (AVRational){avs->fps, 1}; avs->st_video->avg_frame_rate = (AVRational){avs->fps, 1};
} }
@ -200,7 +200,7 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt)
avs->st_audio = avformat_new_stream(s, NULL); avs->st_audio = avformat_new_stream(s, NULL);
if (!avs->st_audio) if (!avs->st_audio)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avs->st_audio->codec->codec_type = AVMEDIA_TYPE_AUDIO; avs->st_audio->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
} }
avs->remaining_audio_size = size - 4; avs->remaining_audio_size = size - 4;
size = avs_read_audio_packet(s, pkt); size = avs_read_audio_packet(s, pkt);

24
libavformat/bethsoftvid.c
Unescape View File

@ -113,13 +113,13 @@ static int read_frame(BVID_DemuxContext *vid, AVIOContext *pb, AVPacket *pkt,
"video packet"); "video packet");
} }
avpriv_set_pts_info(st, 64, 185, vid->sample_rate); avpriv_set_pts_info(st, 64, 185, vid->sample_rate);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_BETHSOFTVID; st->codecpar->codec_id = AV_CODEC_ID_BETHSOFTVID;
st->codec->width = vid->width; st->codecpar->width = vid->width;
st->codec->height = vid->height; st->codecpar->height = vid->height;
} }
st = s->streams[vid->video_index]; st = s->streams[vid->video_index];
npixels = st->codec->width * st->codec->height; npixels = st->codecpar->width * st->codecpar->height;
vidbuf_start = av_malloc(vidbuf_capacity = BUFFER_PADDING_SIZE); vidbuf_start = av_malloc(vidbuf_capacity = BUFFER_PADDING_SIZE);
if(!vidbuf_start) if(!vidbuf_start)
@ -240,13 +240,13 @@ static int vid_read_packet(AVFormatContext *s,
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vid->audio_index = st->index; vid->audio_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_PCM_U8; st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->bits_per_coded_sample = 8; st->codecpar->bits_per_coded_sample = 8;
st->codec->sample_rate = vid->sample_rate; st->codecpar->sample_rate = vid->sample_rate;
st->codec->bit_rate = 8 * st->codec->sample_rate; st->codecpar->bit_rate = 8 * st->codecpar->sample_rate;
st->start_time = 0; st->start_time = 0;
avpriv_set_pts_info(st, 64, 1, vid->sample_rate); avpriv_set_pts_info(st, 64, 1, vid->sample_rate);
} }

36
libavformat/bfi.c
Unescape View File

@ -75,34 +75,34 @@ static int bfi_read_header(AVFormatContext * s)
avio_rl32(pb); avio_rl32(pb);
fps = avio_rl32(pb); fps = avio_rl32(pb);
avio_skip(pb, 12); avio_skip(pb, 12);
vstream->codec->width = avio_rl32(pb); vstream->codecpar->width = avio_rl32(pb);
vstream->codec->height = avio_rl32(pb); vstream->codecpar->height = avio_rl32(pb);
/*Load the palette to extradata */ /*Load the palette to extradata */
avio_skip(pb, 8); avio_skip(pb, 8);
vstream->codec->extradata = av_malloc(768); vstream->codecpar->extradata = av_malloc(768);
vstream->codec->extradata_size = 768; vstream->codecpar->extradata_size = 768;
avio_read(pb, vstream->codec->extradata, avio_read(pb, vstream->codecpar->extradata,
vstream->codec->extradata_size); vstream->codecpar->extradata_size);
astream->codec->sample_rate = avio_rl32(pb); astream->codecpar->sample_rate = avio_rl32(pb);
/* Set up the video codec... */ /* Set up the video codec... */
avpriv_set_pts_info(vstream, 32, 1, fps); avpriv_set_pts_info(vstream, 32, 1, fps);
vstream->codec->codec_type = AVMEDIA_TYPE_VIDEO; vstream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vstream->codec->codec_id = AV_CODEC_ID_BFI; vstream->codecpar->codec_id = AV_CODEC_ID_BFI;
vstream->codec->pix_fmt = AV_PIX_FMT_PAL8; vstream->codecpar->format = AV_PIX_FMT_PAL8;
/* Set up the audio codec now... */ /* Set up the audio codec now... */
astream->codec->codec_type = AVMEDIA_TYPE_AUDIO; astream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
astream->codec->codec_id = AV_CODEC_ID_PCM_U8; astream->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
astream->codec->channels = 1; astream->codecpar->channels = 1;
astream->codec->channel_layout = AV_CH_LAYOUT_MONO; astream->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
astream->codec->bits_per_coded_sample = 8; astream->codecpar->bits_per_coded_sample = 8;
astream->codec->bit_rate = astream->codecpar->bit_rate =
astream->codec->sample_rate * astream->codec->bits_per_coded_sample; astream->codecpar->sample_rate * astream->codecpar->bits_per_coded_sample;
avio_seek(pb, chunk_header - 3, SEEK_SET); avio_seek(pb, chunk_header - 3, SEEK_SET);
avpriv_set_pts_info(astream, 64, 1, astream->codec->sample_rate); avpriv_set_pts_info(astream, 64, 1, astream->codecpar->sample_rate);
return 0; return 0;
} }

46
libavformat/bink.c
Unescape View File

@ -86,7 +86,7 @@ static int read_header(AVFormatContext *s)
if (!vst) if (!vst)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->codec->codec_tag = avio_rl32(pb); vst->codecpar->codec_tag = avio_rl32(pb);
bink->file_size = avio_rl32(pb) + 8; bink->file_size = avio_rl32(pb) + 8;
vst->duration = avio_rl32(pb); vst->duration = avio_rl32(pb);
@ -104,8 +104,8 @@ static int read_header(AVFormatContext *s)
avio_skip(pb, 4); avio_skip(pb, 4);
vst->codec->width = avio_rl32(pb); vst->codecpar->width = avio_rl32(pb);
vst->codec->height = avio_rl32(pb); vst->codecpar->height = avio_rl32(pb);
fps_num = avio_rl32(pb); fps_num = avio_rl32(pb);
fps_den = avio_rl32(pb); fps_den = avio_rl32(pb);
@ -118,13 +118,13 @@ static int read_header(AVFormatContext *s)
avpriv_set_pts_info(vst, 64, fps_den, fps_num); avpriv_set_pts_info(vst, 64, fps_den, fps_num);
vst->avg_frame_rate = av_inv_q(vst->time_base); vst->avg_frame_rate = av_inv_q(vst->time_base);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_BINKVIDEO; vst->codecpar->codec_id = AV_CODEC_ID_BINKVIDEO;
vst->codec->extradata = av_mallocz(4 + AV_INPUT_BUFFER_PADDING_SIZE); vst->codecpar->extradata = av_mallocz(4 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!vst->codec->extradata) if (!vst->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->codec->extradata_size = 4; vst->codecpar->extradata_size = 4;
avio_read(pb, vst->codec->extradata, 4); avio_read(pb, vst->codecpar->extradata, 4);
bink->num_audio_tracks = avio_rl32(pb); bink->num_audio_tracks = avio_rl32(pb);
@ -142,25 +142,25 @@ static int read_header(AVFormatContext *s)
ast = avformat_new_stream(s, NULL); ast = avformat_new_stream(s, NULL);
if (!ast) if (!ast)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO; ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_tag = 0; ast->codecpar->codec_tag = 0;
ast->codec->sample_rate = avio_rl16(pb); ast->codecpar->sample_rate = avio_rl16(pb);
avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate); avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
flags = avio_rl16(pb); flags = avio_rl16(pb);
ast->codec->codec_id = flags & BINK_AUD_USEDCT ? ast->codecpar->codec_id = flags & BINK_AUD_USEDCT ?
AV_CODEC_ID_BINKAUDIO_DCT : AV_CODEC_ID_BINKAUDIO_RDFT; AV_CODEC_ID_BINKAUDIO_DCT : AV_CODEC_ID_BINKAUDIO_RDFT;
if (flags & BINK_AUD_STEREO) { if (flags & BINK_AUD_STEREO) {
ast->codec->channels = 2; ast->codecpar->channels = 2;
ast->codec->channel_layout = AV_CH_LAYOUT_STEREO; ast->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
} else { } else {
ast->codec->channels = 1; ast->codecpar->channels = 1;
ast->codec->channel_layout = AV_CH_LAYOUT_MONO; ast->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
} }
ast->codec->extradata = av_mallocz(4 + AV_INPUT_BUFFER_PADDING_SIZE); ast->codecpar->extradata = av_mallocz(4 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!ast->codec->extradata) if (!ast->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ast->codec->extradata_size = 4; ast->codecpar->extradata_size = 4;
AV_WL32(ast->codec->extradata, vst->codec->codec_tag); AV_WL32(ast->codecpar->extradata, vst->codecpar->codec_tag);
} }
for (i = 0; i < bink->num_audio_tracks; i++) for (i = 0; i < bink->num_audio_tracks; i++)
@ -242,7 +242,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
(in bytes). We use this value to calcuate the audio PTS */ (in bytes). We use this value to calcuate the audio PTS */
if (pkt->size >= 4) if (pkt->size >= 4)
bink->audio_pts[bink->current_track -1] += bink->audio_pts[bink->current_track -1] +=
AV_RL32(pkt->data) / (2 * s->streams[bink->current_track]->codec->channels); AV_RL32(pkt->data) / (2 * s->streams[bink->current_track]->codecpar->channels);
return 0; return 0;
} else { } else {
avio_skip(pb, audio_size); avio_skip(pb, audio_size);

20
libavformat/bmv.c
Unescape View File

@ -47,20 +47,20 @@ static int bmv_read_header(AVFormatContext *s)
st = avformat_new_stream(s, 0); st = avformat_new_stream(s, 0);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_BMV_VIDEO; st->codecpar->codec_id = AV_CODEC_ID_BMV_VIDEO;
st->codec->width = 640; st->codecpar->width = 640;
st->codec->height = 429; st->codecpar->height = 429;
st->codec->pix_fmt = AV_PIX_FMT_PAL8; st->codecpar->format = AV_PIX_FMT_PAL8;
avpriv_set_pts_info(st, 16, 1, 12); avpriv_set_pts_info(st, 16, 1, 12);
ast = avformat_new_stream(s, 0); ast = avformat_new_stream(s, 0);
if (!ast) if (!ast)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO; ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = AV_CODEC_ID_BMV_AUDIO; ast->codecpar->codec_id = AV_CODEC_ID_BMV_AUDIO;
ast->codec->channels = 2; ast->codecpar->channels = 2;
ast->codec->channel_layout = AV_CH_LAYOUT_STEREO; ast->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
ast->codec->sample_rate = 22050; ast->codecpar->sample_rate = 22050;
avpriv_set_pts_info(ast, 16, 1, 22050); avpriv_set_pts_info(ast, 16, 1, 22050);
c->get_next = 1; c->get_next = 1;

10
libavformat/c93.c
Unescape View File

@ -83,10 +83,10 @@ static int read_header(AVFormatContext *s)
if (!video) if (!video)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
video->codec->codec_type = AVMEDIA_TYPE_VIDEO; video->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
video->codec->codec_id = AV_CODEC_ID_C93; video->codecpar->codec_id = AV_CODEC_ID_C93;
video->codec->width = 320; video->codecpar->width = 320;
video->codec->height = 192; video->codecpar->height = 192;
/* 4:3 320x200 with 8 empty lines */ /* 4:3 320x200 with 8 empty lines */
video->sample_aspect_ratio = (AVRational) { 5, 6 }; video->sample_aspect_ratio = (AVRational) { 5, 6 };
avpriv_set_pts_info(video, 64, 2, 25); avpriv_set_pts_info(video, 64, 2, 25);
@ -120,7 +120,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
c93->audio = avformat_new_stream(s, NULL); c93->audio = avformat_new_stream(s, NULL);
if (!c93->audio) if (!c93->audio)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
c93->audio->codec->codec_type = AVMEDIA_TYPE_AUDIO; c93->audio->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
} }
avio_skip(pb, 26); /* VOC header */ avio_skip(pb, 26); /* VOC header */
ret = ff_voc_get_packet(s, pkt, c93->audio, datasize - 26); ret = ff_voc_get_packet(s, pkt, c93->audio, datasize - 26);

64
libavformat/cafdec.c
Unescape View File

@ -69,29 +69,29 @@ static int read_desc_chunk(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
/* parse format description */ /* parse format description */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->sample_rate = av_int2double(avio_rb64(pb)); st->codecpar->sample_rate = av_int2double(avio_rb64(pb));
st->codec->codec_tag = avio_rb32(pb); st->codecpar->codec_tag = avio_rb32(pb);
flags = avio_rb32(pb); flags = avio_rb32(pb);
caf->bytes_per_packet = avio_rb32(pb); caf->bytes_per_packet = avio_rb32(pb);
st->codec->block_align = caf->bytes_per_packet; st->codecpar->block_align = caf->bytes_per_packet;
caf->frames_per_packet = avio_rb32(pb); caf->frames_per_packet = avio_rb32(pb);
st->codec->channels = avio_rb32(pb); st->codecpar->channels = avio_rb32(pb);
st->codec->bits_per_coded_sample = avio_rb32(pb); st->codecpar->bits_per_coded_sample = avio_rb32(pb);
/* calculate bit rate for constant size packets */ /* calculate bit rate for constant size packets */
if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) { if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) {
st->codec->bit_rate = (uint64_t)st->codec->sample_rate * (uint64_t)caf->bytes_per_packet * 8 st->codecpar->bit_rate = (uint64_t)st->codecpar->sample_rate * (uint64_t)caf->bytes_per_packet * 8
/ (uint64_t)caf->frames_per_packet; / (uint64_t)caf->frames_per_packet;
} else { } else {
st->codec->bit_rate = 0; st->codecpar->bit_rate = 0;
} }
/* determine codec */ /* determine codec */
if (st->codec->codec_tag == MKBETAG('l','p','c','m')) if (st->codecpar->codec_tag == MKBETAG('l','p','c','m'))
st->codec->codec_id = ff_mov_get_lpcm_codec_id(st->codec->bits_per_coded_sample, (flags ^ 0x2) | 0x4); st->codecpar->codec_id = ff_mov_get_lpcm_codec_id(st->codecpar->bits_per_coded_sample, (flags ^ 0x2) | 0x4);
else else
st->codec->codec_id = ff_codec_get_id(ff_codec_caf_tags, st->codec->codec_tag); st->codecpar->codec_id = ff_codec_get_id(ff_codec_caf_tags, st->codecpar->codec_tag);
return 0; return 0;
} }
@ -104,7 +104,7 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
return -1; return -1;
if (st->codec->codec_id == AV_CODEC_ID_AAC) { if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
/* The magic cookie format for AAC is an mp4 esds atom. /* The magic cookie format for AAC is an mp4 esds atom.
The lavc AAC decoder requires the data from the codec specific The lavc AAC decoder requires the data from the codec specific
description as extradata input. */ description as extradata input. */
@ -113,13 +113,13 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
strt = avio_tell(pb); strt = avio_tell(pb);
ff_mov_read_esds(s, pb); ff_mov_read_esds(s, pb);
skip = size - (avio_tell(pb) - strt); skip = size - (avio_tell(pb) - strt);
if (skip < 0 || !st->codec->extradata || if (skip < 0 || !st->codecpar->extradata ||
st->codec->codec_id != AV_CODEC_ID_AAC) { st->codecpar->codec_id != AV_CODEC_ID_AAC) {
av_log(s, AV_LOG_ERROR, "invalid AAC magic cookie\n"); av_log(s, AV_LOG_ERROR, "invalid AAC magic cookie\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avio_skip(pb, skip); avio_skip(pb, skip);
} else if (st->codec->codec_id == AV_CODEC_ID_ALAC) { } else if (st->codecpar->codec_id == AV_CODEC_ID_ALAC) {
#define ALAC_PREAMBLE 12 #define ALAC_PREAMBLE 12
#define ALAC_HEADER 36 #define ALAC_HEADER 36
#define ALAC_NEW_KUKI 24 #define ALAC_NEW_KUKI 24
@ -131,8 +131,8 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
} }
avio_read(pb, preamble, ALAC_PREAMBLE); avio_read(pb, preamble, ALAC_PREAMBLE);
st->codec->extradata = av_mallocz(ALAC_HEADER + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(ALAC_HEADER + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
/* For the old style cookie, we skip 12 bytes, then read 36 bytes. /* For the old style cookie, we skip 12 bytes, then read 36 bytes.
@ -142,26 +142,26 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
if (!memcmp(&preamble[4], "frmaalac", 8)) { if (!memcmp(&preamble[4], "frmaalac", 8)) {
if (size < ALAC_PREAMBLE + ALAC_HEADER) { if (size < ALAC_PREAMBLE + ALAC_HEADER) {
av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n"); av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n");
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avio_read(pb, st->codec->extradata, ALAC_HEADER); avio_read(pb, st->codecpar->extradata, ALAC_HEADER);
avio_skip(pb, size - ALAC_PREAMBLE - ALAC_HEADER); avio_skip(pb, size - ALAC_PREAMBLE - ALAC_HEADER);
} else { } else {
AV_WB32(st->codec->extradata, 36); AV_WB32(st->codecpar->extradata, 36);
memcpy(&st->codec->extradata[4], "alac", 4); memcpy(&st->codecpar->extradata[4], "alac", 4);
AV_WB32(&st->codec->extradata[8], 0); AV_WB32(&st->codecpar->extradata[8], 0);
memcpy(&st->codec->extradata[12], preamble, 12); memcpy(&st->codecpar->extradata[12], preamble, 12);
avio_read(pb, &st->codec->extradata[24], ALAC_NEW_KUKI - 12); avio_read(pb, &st->codecpar->extradata[24], ALAC_NEW_KUKI - 12);
avio_skip(pb, size - ALAC_NEW_KUKI); avio_skip(pb, size - ALAC_NEW_KUKI);
} }
st->codec->extradata_size = ALAC_HEADER; st->codecpar->extradata_size = ALAC_HEADER;
} else { } else {
st->codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_read(pb, st->codec->extradata, size); avio_read(pb, st->codecpar->extradata, size);
st->codec->extradata_size = size; st->codecpar->extradata_size = size;
} }
return 0; return 0;
@ -309,7 +309,7 @@ static int read_header(AVFormatContext *s)
if (caf->data_size > 0) if (caf->data_size > 0)
st->nb_frames = (caf->data_size / caf->bytes_per_packet) * caf->frames_per_packet; st->nb_frames = (caf->data_size / caf->bytes_per_packet) * caf->frames_per_packet;
} else if (st->nb_index_entries) { } else if (st->nb_index_entries) {
st->codec->bit_rate = st->codec->sample_rate * caf->data_size * 8 / st->codecpar->bit_rate = st->codecpar->sample_rate * caf->data_size * 8 /
st->duration; st->duration;
} else { } else {
av_log(s, AV_LOG_ERROR, "Missing packet table. It is required when " av_log(s, AV_LOG_ERROR, "Missing packet table. It is required when "
@ -317,7 +317,7 @@ static int read_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
st->start_time = 0; st->start_time = 0;
/* position the stream at the start of data */ /* position the stream at the start of data */

4
libavformat/cdg.c
Unescape View File

@ -39,8 +39,8 @@ static int read_header(AVFormatContext *s)
if (!vst) if (!vst)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_CDGRAPHICS; vst->codecpar->codec_id = AV_CODEC_ID_CDGRAPHICS;
/// 75 sectors/sec * 4 packets/sector = 300 packets/sec /// 75 sectors/sec * 4 packets/sector = 300 packets/sec
avpriv_set_pts_info(vst, 32, 1, 300); avpriv_set_pts_info(vst, 32, 1, 300);

26
libavformat/cdxl.c
Unescape View File

@ -99,17 +99,17 @@ static int cdxl_read_packet(AVFormatContext *s, AVPacket *pkt)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
st->codec->codec_id = AV_CODEC_ID_PCM_S8; st->codecpar->codec_id = AV_CODEC_ID_PCM_S8;
if (cdxl->header[1] & 0x10) { if (cdxl->header[1] & 0x10) {
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
} else { } else {
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
} }
st->codec->sample_rate = cdxl->sample_rate; st->codecpar->sample_rate = cdxl->sample_rate;
st->start_time = 0; st->start_time = 0;
cdxl->audio_stream_index = st->index; cdxl->audio_stream_index = st->index;
avpriv_set_pts_info(st, 64, 1, cdxl->sample_rate); avpriv_set_pts_info(st, 64, 1, cdxl->sample_rate);
@ -128,11 +128,11 @@ static int cdxl_read_packet(AVFormatContext *s, AVPacket *pkt)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
st->codec->codec_id = AV_CODEC_ID_CDXL; st->codecpar->codec_id = AV_CODEC_ID_CDXL;
st->codec->width = width; st->codecpar->width = width;
st->codec->height = height; st->codecpar->height = height;
st->start_time = 0; st->start_time = 0;
cdxl->video_stream_index = st->index; cdxl->video_stream_index = st->index;
if (cdxl->framerate) if (cdxl->framerate)

60
libavformat/dashenc.c
Unescape View File

@ -105,19 +105,19 @@ static int dash_write(void *opaque, uint8_t *buf, int buf_size)
} }
// RFC 6381 // RFC 6381
static void set_codec_str(AVFormatContext *s, AVCodecContext *codec, static void set_codec_str(AVFormatContext *s, AVCodecParameters *par,
char *str, int size) char *str, int size)
{ {
const AVCodecTag *tags[2] = { NULL, NULL }; const AVCodecTag *tags[2] = { NULL, NULL };
uint32_t tag; uint32_t tag;
if (codec->codec_type == AVMEDIA_TYPE_VIDEO) if (par->codec_type == AVMEDIA_TYPE_VIDEO)
tags[0] = ff_codec_movvideo_tags; tags[0] = ff_codec_movvideo_tags;
else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) else if (par->codec_type == AVMEDIA_TYPE_AUDIO)
tags[0] = ff_codec_movaudio_tags; tags[0] = ff_codec_movaudio_tags;
else else
return; return;
tag = av_codec_get_tag(tags, codec->codec_id); tag = av_codec_get_tag(tags, par->codec_id);
if (!tag) if (!tag)
return; return;
if (size < 5) if (size < 5)
@ -128,17 +128,17 @@ static void set_codec_str(AVFormatContext *s, AVCodecContext *codec,
if (!strcmp(str, "mp4a") || !strcmp(str, "mp4v")) { if (!strcmp(str, "mp4a") || !strcmp(str, "mp4v")) {
uint32_t oti; uint32_t oti;
tags[0] = ff_mp4_obj_type; tags[0] = ff_mp4_obj_type;
oti = av_codec_get_tag(tags, codec->codec_id); oti = av_codec_get_tag(tags, par->codec_id);
if (oti) if (oti)
av_strlcatf(str, size, ".%02x", oti); av_strlcatf(str, size, ".%02x", oti);
else else
return; return;
if (tag == MKTAG('m', 'p', '4', 'a')) { if (tag == MKTAG('m', 'p', '4', 'a')) {
if (codec->extradata_size >= 2) { if (par->extradata_size >= 2) {
int aot = codec->extradata[0] >> 3; int aot = par->extradata[0] >> 3;
if (aot == 31) if (aot == 31)
aot = ((AV_RB16(codec->extradata) >> 5) & 0x3f) + 32; aot = ((AV_RB16(par->extradata) >> 5) & 0x3f) + 32;
av_strlcatf(str, size, ".%d", aot); av_strlcatf(str, size, ".%d", aot);
} }
} else if (tag == MKTAG('m', 'p', '4', 'v')) { } else if (tag == MKTAG('m', 'p', '4', 'v')) {
@ -147,8 +147,8 @@ static void set_codec_str(AVFormatContext *s, AVCodecContext *codec,
} }
} else if (!strcmp(str, "avc1")) { } else if (!strcmp(str, "avc1")) {
uint8_t *tmpbuf = NULL; uint8_t *tmpbuf = NULL;
uint8_t *extradata = codec->extradata; uint8_t *extradata = par->extradata;
int extradata_size = codec->extradata_size; int extradata_size = par->extradata_size;
if (!extradata_size) if (!extradata_size)
return; return;
if (extradata[0] != 1) { if (extradata[0] != 1) {
@ -506,9 +506,9 @@ static int write_manifest(AVFormatContext *s, int final)
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
OutputStream *os = &c->streams[i]; OutputStream *os = &c->streams[i];
if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO) if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
continue; continue;
avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/mp4\" codecs=\"%s\"%s width=\"%d\" height=\"%d\">\n", i, os->codec_str, os->bandwidth_str, st->codec->width, st->codec->height); avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/mp4\" codecs=\"%s\"%s width=\"%d\" height=\"%d\">\n", i, os->codec_str, os->bandwidth_str, st->codecpar->width, st->codecpar->height);
output_segment_list(&c->streams[i], out, c); output_segment_list(&c->streams[i], out, c);
avio_printf(out, "\t\t\t</Representation>\n"); avio_printf(out, "\t\t\t</Representation>\n");
} }
@ -519,10 +519,10 @@ static int write_manifest(AVFormatContext *s, int final)
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
OutputStream *os = &c->streams[i]; OutputStream *os = &c->streams[i];
if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
continue; continue;
avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/mp4\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n", i, os->codec_str, os->bandwidth_str, st->codec->sample_rate); avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/mp4\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n", i, os->codec_str, os->bandwidth_str, st->codecpar->sample_rate);
avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n", st->codec->channels); avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n", st->codecpar->channels);
output_segment_list(&c->streams[i], out, c); output_segment_list(&c->streams[i], out, c);
avio_printf(out, "\t\t\t</Representation>\n"); avio_printf(out, "\t\t\t</Representation>\n");
} }
@ -581,7 +581,7 @@ static int dash_write_header(AVFormatContext *s)
AVDictionary *opts = NULL; AVDictionary *opts = NULL;
char filename[1024]; char filename[1024];
os->bit_rate = s->streams[i]->codec->bit_rate; os->bit_rate = s->streams[i]->codecpar->bit_rate;
if (os->bit_rate) { if (os->bit_rate) {
snprintf(os->bandwidth_str, sizeof(os->bandwidth_str), snprintf(os->bandwidth_str, sizeof(os->bandwidth_str),
" bandwidth=\"%d\"", os->bit_rate); " bandwidth=\"%d\"", os->bit_rate);
@ -611,7 +611,7 @@ static int dash_write_header(AVFormatContext *s)
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
} }
avcodec_copy_context(st->codec, s->streams[i]->codec); avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio; st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
st->time_base = s->streams[i]->time_base; st->time_base = s->streams[i]->time_base;
ctx->avoid_negative_ts = s->avoid_negative_ts; ctx->avoid_negative_ts = s->avoid_negative_ts;
@ -651,12 +651,12 @@ static int dash_write_header(AVFormatContext *s)
// already before being handed to this muxer, so we don't have mismatches // already before being handed to this muxer, so we don't have mismatches
// between the MPD and the actual segments. // between the MPD and the actual segments.
s->avoid_negative_ts = ctx->avoid_negative_ts; s->avoid_negative_ts = ctx->avoid_negative_ts;
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
c->has_video = 1; c->has_video = 1;
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
c->has_audio = 1; c->has_audio = 1;
set_codec_str(s, st->codec, os->codec_str, sizeof(os->codec_str)); set_codec_str(s, st->codecpar, os->codec_str, sizeof(os->codec_str));
os->first_pts = AV_NOPTS_VALUE; os->first_pts = AV_NOPTS_VALUE;
os->max_pts = AV_NOPTS_VALUE; os->max_pts = AV_NOPTS_VALUE;
os->last_dts = AV_NOPTS_VALUE; os->last_dts = AV_NOPTS_VALUE;
@ -745,24 +745,24 @@ static void find_index_range(AVFormatContext *s, const char *full_path,
} }
static int update_stream_extradata(AVFormatContext *s, OutputStream *os, static int update_stream_extradata(AVFormatContext *s, OutputStream *os,
AVCodecContext *codec) AVCodecParameters *par)
{ {
uint8_t *extradata; uint8_t *extradata;
if (os->ctx->streams[0]->codec->extradata_size || !codec->extradata_size) if (os->ctx->streams[0]->codecpar->extradata_size || !par->extradata_size)
return 0; return 0;
extradata = av_malloc(codec->extradata_size); extradata = av_malloc(par->extradata_size);
if (!extradata) if (!extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
memcpy(extradata, codec->extradata, codec->extradata_size); memcpy(extradata, par->extradata, par->extradata_size);
os->ctx->streams[0]->codec->extradata = extradata; os->ctx->streams[0]->codecpar->extradata = extradata;
os->ctx->streams[0]->codec->extradata_size = codec->extradata_size; os->ctx->streams[0]->codecpar->extradata_size = par->extradata_size;
set_codec_str(s, codec, os->codec_str, sizeof(os->codec_str)); set_codec_str(s, par, os->codec_str, sizeof(os->codec_str));
return 0; return 0;
} }
@ -788,7 +788,7 @@ static int dash_flush(AVFormatContext *s, int final, int stream)
// Flush all audio streams as well, in sync with video keyframes, // Flush all audio streams as well, in sync with video keyframes,
// but not the other video streams. // but not the other video streams.
if (stream >= 0 && i != stream) { if (stream >= 0 && i != stream) {
if (s->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO) if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
continue; continue;
// Make sure we don't flush audio streams multiple times, when // Make sure we don't flush audio streams multiple times, when
// all video streams are flushed one at a time. // all video streams are flushed one at a time.
@ -867,7 +867,7 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
int64_t seg_end_duration = (os->segment_index) * (int64_t) c->min_seg_duration; int64_t seg_end_duration = (os->segment_index) * (int64_t) c->min_seg_duration;
int ret; int ret;
ret = update_stream_extradata(s, os, st->codec); ret = update_stream_extradata(s, os, st->codecpar);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -892,7 +892,7 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
if (os->first_pts == AV_NOPTS_VALUE) if (os->first_pts == AV_NOPTS_VALUE)
os->first_pts = pkt->pts; os->first_pts = pkt->pts;
if ((!c->has_video || st->codec->codec_type == AVMEDIA_TYPE_VIDEO) && if ((!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
pkt->flags & AV_PKT_FLAG_KEY && os->packets_written && pkt->flags & AV_PKT_FLAG_KEY && os->packets_written &&
av_compare_ts(pkt->pts - os->first_pts, st->time_base, av_compare_ts(pkt->pts - os->first_pts, st->time_base,
seg_end_duration, AV_TIME_BASE_Q) >= 0) { seg_end_duration, AV_TIME_BASE_Q) >= 0) {

18
libavformat/dauddec.c
Unescape View File

@ -26,15 +26,15 @@ static int daud_header(AVFormatContext *s) {
AVStream *st = avformat_new_stream(s, NULL); AVStream *st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_PCM_S24DAUD; st->codecpar->codec_id = AV_CODEC_ID_PCM_S24DAUD;
st->codec->codec_tag = MKTAG('d', 'a', 'u', 'd'); st->codecpar->codec_tag = MKTAG('d', 'a', 'u', 'd');
st->codec->channels = 6; st->codecpar->channels = 6;
st->codec->channel_layout = AV_CH_LAYOUT_5POINT1; st->codecpar->channel_layout = AV_CH_LAYOUT_5POINT1;
st->codec->sample_rate = 96000; st->codecpar->sample_rate = 96000;
st->codec->bit_rate = 3 * 6 * 96000 * 8; st->codecpar->bit_rate = 3 * 6 * 96000 * 8;
st->codec->block_align = 3 * 6; st->codecpar->block_align = 3 * 6;
st->codec->bits_per_coded_sample = 24; st->codecpar->bits_per_coded_sample = 24;
return 0; return 0;
} }

4
libavformat/daudenc.c
Unescape View File

@ -23,8 +23,8 @@
static int daud_write_header(struct AVFormatContext *s) static int daud_write_header(struct AVFormatContext *s)
{ {
AVCodecContext *codec = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if (codec->channels!=6 || codec->sample_rate!=96000) if (par->channels!=6 || par->sample_rate!=96000)
return -1; return -1;
return 0; return 0;
} }

8
libavformat/dfa.c
Unescape View File

@ -51,10 +51,10 @@ static int dfa_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_DFA; st->codecpar->codec_id = AV_CODEC_ID_DFA;
st->codec->width = avio_rl16(pb); st->codecpar->width = avio_rl16(pb);
st->codec->height = avio_rl16(pb); st->codecpar->height = avio_rl16(pb);
mspf = avio_rl32(pb); mspf = avio_rl32(pb);
if (!mspf) { if (!mspf) {
av_log(s, AV_LOG_WARNING, "Zero FPS reported, defaulting to 10\n"); av_log(s, AV_LOG_WARNING, "Zero FPS reported, defaulting to 10\n");

26
libavformat/dsicin.c
Unescape View File

@ -115,11 +115,11 @@ static int cin_read_header(AVFormatContext *s)
avpriv_set_pts_info(st, 32, 1, 12); avpriv_set_pts_info(st, 32, 1, 12);
cin->video_stream_index = st->index; cin->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_DSICINVIDEO; st->codecpar->codec_id = AV_CODEC_ID_DSICINVIDEO;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = hdr->video_frame_width; st->codecpar->width = hdr->video_frame_width;
st->codec->height = hdr->video_frame_height; st->codecpar->height = hdr->video_frame_height;
/* initialize the audio decoder stream */ /* initialize the audio decoder stream */
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
@ -128,14 +128,14 @@ static int cin_read_header(AVFormatContext *s)
avpriv_set_pts_info(st, 32, 1, 22050); avpriv_set_pts_info(st, 32, 1, 22050);
cin->audio_stream_index = st->index; cin->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_DSICINAUDIO; st->codecpar->codec_id = AV_CODEC_ID_DSICINAUDIO;
st->codec->codec_tag = 0; /* no tag */ st->codecpar->codec_tag = 0; /* no tag */
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->sample_rate = 22050; st->codecpar->sample_rate = 22050;
st->codec->bits_per_coded_sample = 8; st->codecpar->bits_per_coded_sample = 8;
st->codec->bit_rate = st->codec->sample_rate * st->codec->bits_per_coded_sample * st->codec->channels; st->codecpar->bit_rate = st->codecpar->sample_rate * st->codecpar->bits_per_coded_sample * st->codecpar->channels;
return 0; return 0;
} }

16
libavformat/dss.c
Unescape View File

@ -141,22 +141,22 @@ static int dss_read_header(AVFormatContext *s)
ctx->audio_codec = avio_r8(pb); ctx->audio_codec = avio_r8(pb);
if (ctx->audio_codec == DSS_ACODEC_DSS_SP) { if (ctx->audio_codec == DSS_ACODEC_DSS_SP) {
st->codec->codec_id = AV_CODEC_ID_DSS_SP; st->codecpar->codec_id = AV_CODEC_ID_DSS_SP;
st->codec->sample_rate = 12000; st->codecpar->sample_rate = 12000;
} else if (ctx->audio_codec == DSS_ACODEC_G723_1) { } else if (ctx->audio_codec == DSS_ACODEC_G723_1) {
st->codec->codec_id = AV_CODEC_ID_G723_1; st->codecpar->codec_id = AV_CODEC_ID_G723_1;
st->codec->sample_rate = 8000; st->codecpar->sample_rate = 8000;
} else { } else {
avpriv_request_sample(s, "Support for codec %x in DSS", avpriv_request_sample(s, "Support for codec %x in DSS",
ctx->audio_codec); ctx->audio_codec);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->channels = 1; st->codecpar->channels = 1;
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
st->start_time = 0; st->start_time = 0;
/* Jump over header */ /* Jump over header */

34
libavformat/dump.c
Unescape View File

@ -400,8 +400,22 @@ static void dump_stream_format(AVFormatContext *ic, int i,
int flags = (is_output ? ic->oformat->flags : ic->iformat->flags); int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
AVStream *st = ic->streams[i]; AVStream *st = ic->streams[i];
AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0); AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
AVCodecContext *avctx;
int ret;
avctx = avcodec_alloc_context3(NULL);
if (!avctx)
return;
ret = avcodec_parameters_to_context(avctx, st->codecpar);
if (ret < 0) {
avcodec_free_context(&avctx);
return;
}
avcodec_string(buf, sizeof(buf), avctx, is_output);
avcodec_free_context(&avctx);
avcodec_string(buf, sizeof(buf), st->codec, is_output);
av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i); av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
/* the pid is an important information, so we display it */ /* the pid is an important information, so we display it */
@ -414,31 +428,27 @@ static void dump_stream_format(AVFormatContext *ic, int i,
st->time_base.num, st->time_base.den); st->time_base.num, st->time_base.den);
av_log(NULL, AV_LOG_INFO, ": %s", buf); av_log(NULL, AV_LOG_INFO, ": %s", buf);
if (st->sample_aspect_ratio.num && // default if (st->sample_aspect_ratio.num) {
av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
AVRational display_aspect_ratio; AVRational display_aspect_ratio;
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den, av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
st->codec->width * st->sample_aspect_ratio.num, st->codecpar->width * st->sample_aspect_ratio.num,
st->codec->height * st->sample_aspect_ratio.den, st->codecpar->height * st->sample_aspect_ratio.den,
1024 * 1024); 1024 * 1024);
av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d", av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
display_aspect_ratio.num, display_aspect_ratio.den); display_aspect_ratio.num, display_aspect_ratio.den);
} }
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
int fps = st->avg_frame_rate.den && st->avg_frame_rate.num; int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
int tbn = st->time_base.den && st->time_base.num; int tbn = st->time_base.den && st->time_base.num;
int tbc = st->codec->time_base.den && st->codec->time_base.num;
if (fps || tbn || tbc) if (fps || tbn)
av_log(NULL, AV_LOG_INFO, "\n "); av_log(NULL, AV_LOG_INFO, "\n ");
if (fps) if (fps)
print_fps(av_q2d(st->avg_frame_rate), tbn || tbc ? "fps, " : "fps"); print_fps(av_q2d(st->avg_frame_rate), tbn ? "fps, " : "fps");
if (tbn) if (tbn)
print_fps(1 / av_q2d(st->time_base), tbc ? "tbn, " : "tbn"); print_fps(1 / av_q2d(st->time_base), "tbn");
if (tbc)
print_fps(1 / av_q2d(st->codec->time_base), "tbc");
} }
if (st->disposition & AV_DISPOSITION_DEFAULT) if (st->disposition & AV_DISPOSITION_DEFAULT)

43
libavformat/dv.c
Unescape View File

@ -245,8 +245,8 @@ static int dv_extract_audio_info(DVDemuxContext *c, uint8_t *frame)
if (!c->ast[i]) if (!c->ast[i])
break; break;
avpriv_set_pts_info(c->ast[i], 64, 1, 30000); avpriv_set_pts_info(c->ast[i], 64, 1, 30000);
c->ast[i]->codec->codec_type = AVMEDIA_TYPE_AUDIO; c->ast[i]->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
c->ast[i]->codec->codec_id = AV_CODEC_ID_PCM_S16LE; c->ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
av_init_packet(&c->audio_pkt[i]); av_init_packet(&c->audio_pkt[i]);
c->audio_pkt[i].size = 0; c->audio_pkt[i].size = 0;
@ -254,10 +254,10 @@ static int dv_extract_audio_info(DVDemuxContext *c, uint8_t *frame)
c->audio_pkt[i].stream_index = c->ast[i]->index; c->audio_pkt[i].stream_index = c->ast[i]->index;
c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY; c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY;
} }
c->ast[i]->codec->sample_rate = dv_audio_frequency[freq]; c->ast[i]->codecpar->sample_rate = dv_audio_frequency[freq];
c->ast[i]->codec->channels = 2; c->ast[i]->codecpar->channels = 2;
c->ast[i]->codec->channel_layout = AV_CH_LAYOUT_STEREO; c->ast[i]->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16; c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
c->ast[i]->start_time = 0; c->ast[i]->start_time = 0;
} }
c->ach = i; c->ach = i;
@ -268,21 +268,20 @@ static int dv_extract_audio_info(DVDemuxContext *c, uint8_t *frame)
static int dv_extract_video_info(DVDemuxContext *c, uint8_t *frame) static int dv_extract_video_info(DVDemuxContext *c, uint8_t *frame)
{ {
const uint8_t *vsc_pack; const uint8_t *vsc_pack;
AVCodecContext *avctx;
int apt, is16_9; int apt, is16_9;
int size = 0; int size = 0;
if (c->sys) { if (c->sys) {
avctx = c->vst->codec; AVCodecParameters *par = c->vst->codecpar;
avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num, avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
c->sys->time_base.den); c->sys->time_base.den);
c->vst->avg_frame_rate = av_inv_q(c->vst->time_base); c->vst->avg_frame_rate = av_inv_q(c->vst->time_base);
if (!avctx->width) { if (!par->width) {
avctx->width = c->sys->width; par->width = c->sys->width;
avctx->height = c->sys->height; par->height = c->sys->height;
} }
avctx->pix_fmt = c->sys->pix_fmt; par->format = c->sys->pix_fmt;
/* finding out SAR is a little bit messy */ /* finding out SAR is a little bit messy */
vsc_pack = dv_extract_pack(frame, dv_video_control); vsc_pack = dv_extract_pack(frame, dv_video_control);
@ -290,9 +289,9 @@ static int dv_extract_video_info(DVDemuxContext *c, uint8_t *frame)
is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
(!apt && (vsc_pack[2] & 0x07) == 0x07))); (!apt && (vsc_pack[2] & 0x07) == 0x07)));
c->vst->sample_aspect_ratio = c->sys->sar[is16_9]; c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
avctx->bit_rate = av_rescale_q(c->sys->frame_size, par->bit_rate = av_rescale_q(c->sys->frame_size,
(AVRational) { 8, 1 }, (AVRational) { 8, 1 },
c->sys->time_base); c->sys->time_base);
size = c->sys->frame_size; size = c->sys->frame_size;
} }
return size; return size;
@ -315,9 +314,9 @@ DVDemuxContext *avpriv_dv_init_demux(AVFormatContext *s)
} }
c->fctx = s; c->fctx = s;
c->vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; c->vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
c->vst->codec->codec_id = AV_CODEC_ID_DVVIDEO; c->vst->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
c->vst->codec->bit_rate = 25000000; c->vst->codecpar->bit_rate = 25000000;
c->vst->start_time = 0; c->vst->start_time = 0;
return c; return c;
@ -358,7 +357,7 @@ int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
for (i = 0; i < c->ach; i++) { for (i = 0; i < c->ach; i++) {
c->audio_pkt[i].size = size; c->audio_pkt[i].size = size;
c->audio_pkt[i].pts = c->abytes * 30000 * 8 / c->audio_pkt[i].pts = c->abytes * 30000 * 8 /
c->ast[i]->codec->bit_rate; c->ast[i]->codecpar->bit_rate;
ppcm[i] = c->audio_buf[i]; ppcm[i] = c->audio_buf[i];
} }
if (c->ach) if (c->ach)
@ -395,8 +394,8 @@ static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c,
int64_t timestamp, int flags) int64_t timestamp, int flags)
{ {
// FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk) // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
const AVDVProfile *sys = av_dv_codec_profile(c->vst->codec->width, c->vst->codec->height, const AVDVProfile *sys = av_dv_codec_profile(c->vst->codecpar->width, c->vst->codecpar->height,
c->vst->codec->pix_fmt); c->vst->codecpar->format);
int64_t offset; int64_t offset;
int64_t size = avio_size(s->pb) - s->internal->data_offset; int64_t size = avio_size(s->pb) - s->internal->data_offset;
int64_t max_offset = ((size - 1) / sys->frame_size) * sys->frame_size; int64_t max_offset = ((size - 1) / sys->frame_size) * sys->frame_size;
@ -416,7 +415,7 @@ void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
c->frames = frame_offset; c->frames = frame_offset;
if (c->ach) if (c->ach)
c->abytes = av_rescale_q(c->frames, c->sys->time_base, c->abytes = av_rescale_q(c->frames, c->sys->time_base,
(AVRational) { 8, c->ast[0]->codec->bit_rate }); (AVRational) { 8, c->ast[0]->codecpar->bit_rate });
c->audio_pkt[0].size = c->audio_pkt[1].size = 0; c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
c->audio_pkt[2].size = c->audio_pkt[3].size = 0; c->audio_pkt[2].size = c->audio_pkt[3].size = 0;

25
libavformat/dvenc.c
Unescape View File

@ -236,7 +236,8 @@ static void dv_inject_metadata(DVMuxContext *c, uint8_t* frame)
* The following 3 functions constitute our interface to the world * The following 3 functions constitute our interface to the world
*/ */
static int dv_assemble_frame(DVMuxContext *c, AVStream* st, static int dv_assemble_frame(AVFormatContext *s,
DVMuxContext *c, AVStream* st,
uint8_t* data, int data_size, uint8_t** frame) uint8_t* data, int data_size, uint8_t** frame)
{ {
int i, reqasize; int i, reqasize;
@ -244,13 +245,13 @@ static int dv_assemble_frame(DVMuxContext *c, AVStream* st,
*frame = &c->frame_buf[0]; *frame = &c->frame_buf[0];
reqasize = 4 * dv_audio_frame_size(c->sys, c->frames); reqasize = 4 * dv_audio_frame_size(c->sys, c->frames);
switch (st->codec->codec_type) { switch (st->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
/* FIXME: we have to have more sensible approach than this one */ /* FIXME: we have to have more sensible approach than this one */
if (c->has_video) if (c->has_video)
av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames); av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
if (data_size != c->sys->frame_size) { if (data_size != c->sys->frame_size) {
av_log(st->codec, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n", av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
data_size, c->sys->frame_size); data_size, c->sys->frame_size);
return AVERROR(ENOSYS); return AVERROR(ENOSYS);
} }
@ -263,7 +264,7 @@ static int dv_assemble_frame(DVMuxContext *c, AVStream* st,
/* FIXME: we have to have more sensible approach than this one */ /* FIXME: we have to have more sensible approach than this one */
if (av_fifo_size(c->audio_data[i]) + data_size >= 100*MAX_AUDIO_FRAME_SIZE) if (av_fifo_size(c->audio_data[i]) + data_size >= 100*MAX_AUDIO_FRAME_SIZE)
av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames); av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
av_fifo_generic_write(c->audio_data[i], data, data_size, NULL); av_fifo_generic_write(c->audio_data[i], data, data_size, NULL);
/* Let us see if we've got enough audio for one DV frame. */ /* Let us see if we've got enough audio for one DV frame. */
@ -310,7 +311,7 @@ static DVMuxContext* dv_init_mux(AVFormatContext* s)
/* We have to sort out where audio and where video stream is */ /* We have to sort out where audio and where video stream is */
for (i=0; i<s->nb_streams; i++) { for (i=0; i<s->nb_streams; i++) {
switch (s->streams[i]->codec->codec_type) { switch (s->streams[i]->codecpar->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
if (vst) return NULL; if (vst) return NULL;
vst = s->streams[i]; vst = s->streams[i];
@ -325,15 +326,15 @@ static DVMuxContext* dv_init_mux(AVFormatContext* s)
} }
/* Some checks -- DV format is very picky about its incoming streams */ /* Some checks -- DV format is very picky about its incoming streams */
if (!vst || vst->codec->codec_id != AV_CODEC_ID_DVVIDEO) if (!vst || vst->codecpar->codec_id != AV_CODEC_ID_DVVIDEO)
goto bail_out; goto bail_out;
for (i=0; i<c->n_ast; i++) { for (i=0; i<c->n_ast; i++) {
if (c->ast[i] && (c->ast[i]->codec->codec_id != AV_CODEC_ID_PCM_S16LE || if (c->ast[i] && (c->ast[i]->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE ||
c->ast[i]->codec->sample_rate != 48000 || c->ast[i]->codecpar->sample_rate != 48000 ||
c->ast[i]->codec->channels != 2)) c->ast[i]->codecpar->channels != 2))
goto bail_out; goto bail_out;
} }
c->sys = av_dv_codec_profile(vst->codec->width, vst->codec->height, vst->codec->pix_fmt); c->sys = av_dv_codec_profile(vst->codecpar->width, vst->codecpar->height, vst->codecpar->format);
if (!c->sys) if (!c->sys)
goto bail_out; goto bail_out;
@ -389,7 +390,7 @@ static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
uint8_t* frame; uint8_t* frame;
int fsize; int fsize;
fsize = dv_assemble_frame(s->priv_data, s->streams[pkt->stream_index], fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
pkt->data, pkt->size, &frame); pkt->data, pkt->size, &frame);
if (fsize > 0) { if (fsize > 0) {
avio_write(s->pb, frame, fsize); avio_write(s->pb, frame, fsize);

20
libavformat/dxa.c
Unescape View File

@ -106,11 +106,11 @@ static int dxa_read_header(AVFormatContext *s)
ast = avformat_new_stream(s, NULL); ast = avformat_new_stream(s, NULL);
if (!ast) if (!ast)
return -1; return -1;
ret = ff_get_wav_header(s, pb, ast->codec, fsize); ret = ff_get_wav_header(s, pb, ast->codecpar, fsize);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (ast->codec->sample_rate > 0) if (ast->codecpar->sample_rate > 0)
avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate); avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
// find 'data' chunk // find 'data' chunk
while(avio_tell(pb) < c->vidpos && !pb->eof_reached){ while(avio_tell(pb) < c->vidpos && !pb->eof_reached){
tag = avio_rl32(pb); tag = avio_rl32(pb);
@ -119,18 +119,18 @@ static int dxa_read_header(AVFormatContext *s)
avio_skip(pb, fsize); avio_skip(pb, fsize);
} }
c->bpc = (fsize + c->frames - 1) / c->frames; c->bpc = (fsize + c->frames - 1) / c->frames;
if(ast->codec->block_align) if(ast->codecpar->block_align)
c->bpc = ((c->bpc + ast->codec->block_align - 1) / ast->codec->block_align) * ast->codec->block_align; c->bpc = ((c->bpc + ast->codecpar->block_align - 1) / ast->codecpar->block_align) * ast->codecpar->block_align;
c->bytes_left = fsize; c->bytes_left = fsize;
c->wavpos = avio_tell(pb); c->wavpos = avio_tell(pb);
avio_seek(pb, c->vidpos, SEEK_SET); avio_seek(pb, c->vidpos, SEEK_SET);
} }
/* now we are ready: build format streams */ /* now we are ready: build format streams */
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_DXA; st->codecpar->codec_id = AV_CODEC_ID_DXA;
st->codec->width = w; st->codecpar->width = w;
st->codec->height = h; st->codecpar->height = h;
av_reduce(&den, &num, den, num, (1UL<<31)-1); av_reduce(&den, &num, den, num, (1UL<<31)-1);
avpriv_set_pts_info(st, 33, num, den); avpriv_set_pts_info(st, 33, num, den);
/* flags & 0x80 means that image is interlaced, /* flags & 0x80 means that image is interlaced,
@ -138,7 +138,7 @@ static int dxa_read_header(AVFormatContext *s)
* either way set true height * either way set true height
*/ */
if(flags & 0xC0){ if(flags & 0xC0){
st->codec->height >>= 1; st->codecpar->height >>= 1;
} }
c->readvid = !c->has_sound; c->readvid = !c->has_sound;
c->vidpos = avio_tell(pb); c->vidpos = avio_tell(pb);

10
libavformat/eacdata.c
Unescape View File

@ -68,11 +68,11 @@ static int cdata_read_header(AVFormatContext *s)
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->codec_id = AV_CODEC_ID_ADPCM_EA_XAS; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_EA_XAS;
st->codec->channels = cdata->channels; st->codecpar->channels = cdata->channels;
st->codec->sample_rate = sample_rate; st->codecpar->sample_rate = sample_rate;
avpriv_set_pts_info(st, 64, 1, sample_rate); avpriv_set_pts_info(st, 64, 1, sample_rate);
cdata->audio_pts = 0; cdata->audio_pts = 0;

32
libavformat/electronicarts.c
Unescape View File

@ -462,11 +462,11 @@ static int ea_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ea->video_stream_index = st->index; ea->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = ea->video_codec; st->codecpar->codec_id = ea->video_codec;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = ea->width; st->codecpar->width = ea->width;
st->codec->height = ea->height; st->codecpar->height = ea->height;
avpriv_set_pts_info(st, 33, ea->time_base.num, ea->time_base.den); avpriv_set_pts_info(st, 33, ea->time_base.num, ea->time_base.den);
st->avg_frame_rate = (AVRational) { ea->time_base.den, st->avg_frame_rate = (AVRational) { ea->time_base.den,
ea->time_base.num }; ea->time_base.num };
@ -497,17 +497,17 @@ static int ea_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 33, 1, ea->sample_rate); avpriv_set_pts_info(st, 33, 1, ea->sample_rate);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ea->audio_codec; st->codecpar->codec_id = ea->audio_codec;
st->codec->codec_tag = 0; /* no tag */ st->codecpar->codec_tag = 0; /* no tag */
st->codec->channels = ea->num_channels; st->codecpar->channels = ea->num_channels;
st->codec->sample_rate = ea->sample_rate; st->codecpar->sample_rate = ea->sample_rate;
st->codec->bits_per_coded_sample = ea->bytes * 8; st->codecpar->bits_per_coded_sample = ea->bytes * 8;
st->codec->bit_rate = st->codec->channels * st->codecpar->bit_rate = st->codecpar->channels *
st->codec->sample_rate * st->codecpar->sample_rate *
st->codec->bits_per_coded_sample / 4; st->codecpar->bits_per_coded_sample / 4;
st->codec->block_align = st->codec->channels * st->codecpar->block_align = st->codecpar->channels *
st->codec->bits_per_coded_sample; st->codecpar->bits_per_coded_sample;
ea->audio_stream_index = st->index; ea->audio_stream_index = st->index;
st->start_time = 0; st->start_time = 0;
} }

4
libavformat/ffmetadec.c
Unescape View File

@ -137,8 +137,8 @@ static int read_header(AVFormatContext *s)
if (!st) if (!st)
return -1; return -1;
st->codec->codec_type = AVMEDIA_TYPE_DATA; st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
st->codec->codec_id = AV_CODEC_ID_FFMETADATA; st->codecpar->codec_id = AV_CODEC_ID_FFMETADATA;
m = &st->metadata; m = &st->metadata;
} else if (!memcmp(line, ID_CHAPTER, strlen(ID_CHAPTER))) { } else if (!memcmp(line, ID_CHAPTER, strlen(ID_CHAPTER))) {

20
libavformat/filmstripdec.c
Unescape View File

@ -60,12 +60,12 @@ static int read_header(AVFormatContext *s)
} }
avio_skip(pb, 2); avio_skip(pb, 2);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->pix_fmt = AV_PIX_FMT_RGBA; st->codecpar->format = AV_PIX_FMT_RGBA;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = avio_rb16(pb); st->codecpar->width = avio_rb16(pb);
st->codec->height = avio_rb16(pb); st->codecpar->height = avio_rb16(pb);
film->leading = avio_rb16(pb); film->leading = avio_rb16(pb);
avpriv_set_pts_info(st, 64, 1, avio_rb16(pb)); avpriv_set_pts_info(st, 64, 1, avio_rb16(pb));
@ -82,9 +82,9 @@ static int read_packet(AVFormatContext *s,
if (s->pb->eof_reached) if (s->pb->eof_reached)
return AVERROR(EIO); return AVERROR(EIO);
pkt->dts = avio_tell(s->pb) / (st->codec->width * (st->codec->height + film->leading) * 4); pkt->dts = avio_tell(s->pb) / (st->codecpar->width * (st->codecpar->height + film->leading) * 4);
pkt->size = av_get_packet(s->pb, pkt, st->codec->width * st->codec->height * 4); pkt->size = av_get_packet(s->pb, pkt, st->codecpar->width * st->codecpar->height * 4);
avio_skip(s->pb, st->codec->width * (int64_t) film->leading * 4); avio_skip(s->pb, st->codecpar->width * (int64_t) film->leading * 4);
if (pkt->size < 0) if (pkt->size < 0)
return pkt->size; return pkt->size;
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
@ -94,7 +94,7 @@ static int read_packet(AVFormatContext *s,
static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
{ {
AVStream *st = s->streams[stream_index]; AVStream *st = s->streams[stream_index];
if (avio_seek(s->pb, FFMAX(timestamp, 0) * st->codec->width * st->codec->height * 4, SEEK_SET) < 0) if (avio_seek(s->pb, FFMAX(timestamp, 0) * st->codecpar->width * st->codecpar->height * 4, SEEK_SET) < 0)
return -1; return -1;
return 0; return 0;
} }

6
libavformat/filmstripenc.c
Unescape View File

@ -35,7 +35,7 @@ typedef struct FilmstripMuxContext {
static int write_header(AVFormatContext *s) static int write_header(AVFormatContext *s)
{ {
if (s->streams[0]->codec->pix_fmt != AV_PIX_FMT_RGBA) { if (s->streams[0]->codecpar->format != AV_PIX_FMT_RGBA) {
av_log(s, AV_LOG_ERROR, "only AV_PIX_FMT_RGBA is supported\n"); av_log(s, AV_LOG_ERROR, "only AV_PIX_FMT_RGBA is supported\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -61,8 +61,8 @@ static int write_trailer(AVFormatContext *s)
avio_wb32(pb, film->nb_frames); avio_wb32(pb, film->nb_frames);
avio_wb16(pb, 0); // packing method avio_wb16(pb, 0); // packing method
avio_wb16(pb, 0); // reserved avio_wb16(pb, 0); // reserved
avio_wb16(pb, st->codec->width); avio_wb16(pb, st->codecpar->width);
avio_wb16(pb, st->codec->height); avio_wb16(pb, st->codecpar->height);
avio_wb16(pb, 0); // leading avio_wb16(pb, 0); // leading
// TODO: should be avg_frame_rate // TODO: should be avg_frame_rate
avio_wb16(pb, 1/av_q2d(st->time_base)); avio_wb16(pb, 1/av_q2d(st->time_base));

8
libavformat/flac_picture.c
Unescape View File

@ -131,10 +131,10 @@ int ff_flac_parse_picture(AVFormatContext *s, uint8_t *buf, int buf_size)
st->attached_pic.flags |= AV_PKT_FLAG_KEY; st->attached_pic.flags |= AV_PKT_FLAG_KEY;
st->disposition |= AV_DISPOSITION_ATTACHED_PIC; st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = id; st->codecpar->codec_id = id;
st->codec->width = width; st->codecpar->width = width;
st->codec->height = height; st->codecpar->height = height;
av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0); av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0);
if (desc) if (desc)
av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL); av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL);

14
libavformat/flacdec.c
Unescape View File

@ -36,8 +36,8 @@ static int flac_read_header(AVFormatContext *s)
AVStream *st = avformat_new_stream(s, NULL); AVStream *st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_FLAC; st->codecpar->codec_id = AV_CODEC_ID_FLAC;
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
/* the parameters will be extracted from the compressed bitstream */ /* the parameters will be extracted from the compressed bitstream */
@ -88,14 +88,14 @@ static int flac_read_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
found_streaminfo = 1; found_streaminfo = 1;
st->codec->extradata = buffer; st->codecpar->extradata = buffer;
st->codec->extradata_size = metadata_size; st->codecpar->extradata_size = metadata_size;
buffer = NULL; buffer = NULL;
/* get sample rate and sample count from STREAMINFO header; /* get sample rate and sample count from STREAMINFO header;
* other parameters will be extracted by the parser */ * other parameters will be extracted by the parser */
samplerate = AV_RB24(st->codec->extradata + 10) >> 4; samplerate = AV_RB24(st->codecpar->extradata + 10) >> 4;
samples = (AV_RB64(st->codec->extradata + 13) >> 24) & ((1ULL << 36) - 1); samples = (AV_RB64(st->codecpar->extradata + 13) >> 24) & ((1ULL << 36) - 1);
/* set time base and duration */ /* set time base and duration */
if (samplerate > 0) { if (samplerate > 0) {
@ -159,7 +159,7 @@ static int flac_read_header(AVFormatContext *s)
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
"Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n"); "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
} else { } else {
st->codec->channel_layout = mask; st->codecpar->channel_layout = mask;
av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0); av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
} }
} }

16
libavformat/flacenc.c
Unescape View File

@ -77,21 +77,21 @@ static int flac_write_block_comment(AVIOContext *pb, AVDictionary **m,
static int flac_write_header(struct AVFormatContext *s) static int flac_write_header(struct AVFormatContext *s)
{ {
int ret; int ret;
AVCodecContext *codec = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
FlacMuxerContext *c = s->priv_data; FlacMuxerContext *c = s->priv_data;
if (!c->write_header) if (!c->write_header)
return 0; return 0;
ret = ff_flac_write_header(s->pb, codec->extradata, ret = ff_flac_write_header(s->pb, par->extradata,
codec->extradata_size, 0); par->extradata_size, 0);
if (ret) if (ret)
return ret; return ret;
/* add the channel layout tag */ /* add the channel layout tag */
if (codec->channel_layout && if (par->channel_layout &&
!(codec->channel_layout & ~0x3ffffULL) && !(par->channel_layout & ~0x3ffffULL) &&
!ff_flac_is_native_layout(codec->channel_layout)) { !ff_flac_is_native_layout(par->channel_layout)) {
AVDictionaryEntry *chmask = av_dict_get(s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", AVDictionaryEntry *chmask = av_dict_get(s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK",
NULL, 0); NULL, 0);
@ -100,7 +100,7 @@ static int flac_write_header(struct AVFormatContext *s)
"already present, this muxer will not overwrite it.\n"); "already present, this muxer will not overwrite it.\n");
} else { } else {
uint8_t buf[32]; uint8_t buf[32];
snprintf(buf, sizeof(buf), "0x%"PRIx64, codec->channel_layout); snprintf(buf, sizeof(buf), "0x%"PRIx64, par->channel_layout);
av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0); av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
} }
} }
@ -125,7 +125,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
int64_t file_size; int64_t file_size;
FlacMuxerContext *c = s->priv_data; FlacMuxerContext *c = s->priv_data;
uint8_t *streaminfo = c->streaminfo ? c->streaminfo : uint8_t *streaminfo = c->streaminfo ? c->streaminfo :
s->streams[0]->codec->extradata; s->streams[0]->codecpar->extradata;
if (!c->write_header || !streaminfo) if (!c->write_header || !streaminfo)
return 0; return 0;

54
libavformat/flic.c
Unescape View File

@ -109,25 +109,25 @@ static int flic_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
flic->video_stream_index = st->index; flic->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_FLIC; st->codecpar->codec_id = AV_CODEC_ID_FLIC;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = AV_RL16(&header[0x08]); st->codecpar->width = AV_RL16(&header[0x08]);
st->codec->height = AV_RL16(&header[0x0A]); st->codecpar->height = AV_RL16(&header[0x0A]);
if (!st->codec->width || !st->codec->height) { if (!st->codecpar->width || !st->codecpar->height) {
/* Ugly hack needed for the following sample: */ /* Ugly hack needed for the following sample: */
/* http://samples.libav.org/fli-flc/fli-bugs/specular.flc */ /* http://samples.libav.org/fli-flc/fli-bugs/specular.flc */
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
"File with no specified width/height. Trying 640x480.\n"); "File with no specified width/height. Trying 640x480.\n");
st->codec->width = 640; st->codecpar->width = 640;
st->codec->height = 480; st->codecpar->height = 480;
} }
/* send over the whole 128-byte FLIC header */ /* send over the whole 128-byte FLIC header */
st->codec->extradata_size = FLIC_HEADER_SIZE; st->codecpar->extradata_size = FLIC_HEADER_SIZE;
st->codec->extradata = av_malloc(FLIC_HEADER_SIZE); st->codecpar->extradata = av_malloc(FLIC_HEADER_SIZE);
memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE); memcpy(st->codecpar->extradata, header, FLIC_HEADER_SIZE);
/* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */ /* peek at the preamble to detect TFTD videos - they seem to always start with an audio chunk */
if (avio_read(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) { if (avio_read(pb, preamble, FLIC_PREAMBLE_SIZE) != FLIC_PREAMBLE_SIZE) {
@ -152,22 +152,22 @@ static int flic_read_header(AVFormatContext *s)
flic->audio_stream_index = ast->index; flic->audio_stream_index = ast->index;
/* all audio frames are the same size, so use the size of the first chunk for block_align */ /* all audio frames are the same size, so use the size of the first chunk for block_align */
ast->codec->block_align = AV_RL32(&preamble[0]); ast->codecpar->block_align = AV_RL32(&preamble[0]);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO; ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = AV_CODEC_ID_PCM_U8; ast->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
ast->codec->codec_tag = 0; ast->codecpar->codec_tag = 0;
ast->codec->sample_rate = FLIC_TFTD_SAMPLE_RATE; ast->codecpar->sample_rate = FLIC_TFTD_SAMPLE_RATE;
ast->codec->channels = 1; ast->codecpar->channels = 1;
ast->codec->sample_fmt = AV_SAMPLE_FMT_U8; ast->codecpar->format = AV_SAMPLE_FMT_U8;
ast->codec->bit_rate = st->codec->sample_rate * 8; ast->codecpar->bit_rate = st->codecpar->sample_rate * 8;
ast->codec->bits_per_coded_sample = 8; ast->codecpar->bits_per_coded_sample = 8;
ast->codec->channel_layout = AV_CH_LAYOUT_MONO; ast->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
ast->codec->extradata_size = 0; ast->codecpar->extradata_size = 0;
/* Since the header information is incorrect we have to figure out the /* Since the header information is incorrect we have to figure out the
* framerate using block_align and the fact that the audio is 22050 Hz. * framerate using block_align and the fact that the audio is 22050 Hz.
* We usually have two cases: 2205 -> 10 fps and 1470 -> 15 fps */ * We usually have two cases: 2205 -> 10 fps and 1470 -> 15 fps */
avpriv_set_pts_info(st, 64, ast->codec->block_align, FLIC_TFTD_SAMPLE_RATE); avpriv_set_pts_info(st, 64, ast->codecpar->block_align, FLIC_TFTD_SAMPLE_RATE);
avpriv_set_pts_info(ast, 64, 1, FLIC_TFTD_SAMPLE_RATE); avpriv_set_pts_info(ast, 64, 1, FLIC_TFTD_SAMPLE_RATE);
} else if (AV_RL16(&header[0x10]) == FLIC_CHUNK_MAGIC_1) { } else if (AV_RL16(&header[0x10]) == FLIC_CHUNK_MAGIC_1) {
avpriv_set_pts_info(st, 64, FLIC_MC_SPEED, 70); avpriv_set_pts_info(st, 64, FLIC_MC_SPEED, 70);
@ -176,10 +176,10 @@ static int flic_read_header(AVFormatContext *s)
avio_seek(pb, 12, SEEK_SET); avio_seek(pb, 12, SEEK_SET);
/* send over abbreviated FLIC header chunk */ /* send over abbreviated FLIC header chunk */
av_free(st->codec->extradata); av_free(st->codecpar->extradata);
st->codec->extradata_size = 12; st->codecpar->extradata_size = 12;
st->codec->extradata = av_malloc(12); st->codecpar->extradata = av_malloc(12);
memcpy(st->codec->extradata, header, 12); memcpy(st->codecpar->extradata, header, 12);
} else if (magic_number == FLIC_FILE_MAGIC_1) { } else if (magic_number == FLIC_FILE_MAGIC_1) {
avpriv_set_pts_info(st, 64, speed, 70); avpriv_set_pts_info(st, 64, speed, 70);

249
libavformat/flvdec.c
Unescape View File

@ -80,21 +80,21 @@ static AVStream *create_stream(AVFormatContext *s, int codec_type)
AVStream *st = avformat_new_stream(s, NULL); AVStream *st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return NULL; return NULL;
st->codec->codec_type = codec_type; st->codecpar->codec_type = codec_type;
avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
return st; return st;
} }
static int flv_same_audio_codec(AVCodecContext *acodec, int flags) static int flv_same_audio_codec(AVCodecParameters *apar, int flags)
{ {
int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8; int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
int flv_codecid = flags & FLV_AUDIO_CODECID_MASK; int flv_codecid = flags & FLV_AUDIO_CODECID_MASK;
int codec_id; int codec_id;
if (!acodec->codec_id && !acodec->codec_tag) if (!apar->codec_id && !apar->codec_tag)
return 1; return 1;
if (acodec->bits_per_coded_sample != bits_per_coded_sample) if (apar->bits_per_coded_sample != bits_per_coded_sample)
return 0; return 0;
switch (flv_codecid) { switch (flv_codecid) {
@ -107,42 +107,42 @@ static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
#else #else
: AV_CODEC_ID_PCM_S16LE; : AV_CODEC_ID_PCM_S16LE;
#endif #endif
return codec_id == acodec->codec_id; return codec_id == apar->codec_id;
case FLV_CODECID_PCM_LE: case FLV_CODECID_PCM_LE:
codec_id = bits_per_coded_sample == 8 codec_id = bits_per_coded_sample == 8
? AV_CODEC_ID_PCM_U8 ? AV_CODEC_ID_PCM_U8
: AV_CODEC_ID_PCM_S16LE; : AV_CODEC_ID_PCM_S16LE;
return codec_id == acodec->codec_id; return codec_id == apar->codec_id;
case FLV_CODECID_AAC: case FLV_CODECID_AAC:
return acodec->codec_id == AV_CODEC_ID_AAC; return apar->codec_id == AV_CODEC_ID_AAC;
case FLV_CODECID_ADPCM: case FLV_CODECID_ADPCM:
return acodec->codec_id == AV_CODEC_ID_ADPCM_SWF; return apar->codec_id == AV_CODEC_ID_ADPCM_SWF;
case FLV_CODECID_SPEEX: case FLV_CODECID_SPEEX:
return acodec->codec_id == AV_CODEC_ID_SPEEX; return apar->codec_id == AV_CODEC_ID_SPEEX;
case FLV_CODECID_MP3: case FLV_CODECID_MP3:
return acodec->codec_id == AV_CODEC_ID_MP3; return apar->codec_id == AV_CODEC_ID_MP3;
case FLV_CODECID_NELLYMOSER_8KHZ_MONO: case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
case FLV_CODECID_NELLYMOSER_16KHZ_MONO: case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
case FLV_CODECID_NELLYMOSER: case FLV_CODECID_NELLYMOSER:
return acodec->codec_id == AV_CODEC_ID_NELLYMOSER; return apar->codec_id == AV_CODEC_ID_NELLYMOSER;
case FLV_CODECID_PCM_MULAW: case FLV_CODECID_PCM_MULAW:
return acodec->sample_rate == 8000 && return apar->sample_rate == 8000 &&
acodec->codec_id == AV_CODEC_ID_PCM_MULAW; apar->codec_id == AV_CODEC_ID_PCM_MULAW;
case FLV_CODECID_PCM_ALAW: case FLV_CODECID_PCM_ALAW:
return acodec->sample_rate == 8000 && return apar->sample_rate == 8000 &&
acodec->codec_id == AV_CODEC_ID_PCM_ALAW; apar->codec_id == AV_CODEC_ID_PCM_ALAW;
default: default:
return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET); return apar->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
} }
} }
static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream,
AVCodecContext *acodec, int flv_codecid) AVCodecParameters *apar, int flv_codecid)
{ {
switch (flv_codecid) { switch (flv_codecid) {
// no distinction between S16 and S8 PCM codec flags // no distinction between S16 and S8 PCM codec flags
case FLV_CODECID_PCM: case FLV_CODECID_PCM:
acodec->codec_id = acodec->bits_per_coded_sample == 8 apar->codec_id = apar->bits_per_coded_sample == 8
? AV_CODEC_ID_PCM_U8 ? AV_CODEC_ID_PCM_U8
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
: AV_CODEC_ID_PCM_S16BE; : AV_CODEC_ID_PCM_S16BE;
@ -151,113 +151,113 @@ static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream,
#endif #endif
break; break;
case FLV_CODECID_PCM_LE: case FLV_CODECID_PCM_LE:
acodec->codec_id = acodec->bits_per_coded_sample == 8 apar->codec_id = apar->bits_per_coded_sample == 8
? AV_CODEC_ID_PCM_U8 ? AV_CODEC_ID_PCM_U8
: AV_CODEC_ID_PCM_S16LE; : AV_CODEC_ID_PCM_S16LE;
break; break;
case FLV_CODECID_AAC: case FLV_CODECID_AAC:
acodec->codec_id = AV_CODEC_ID_AAC; apar->codec_id = AV_CODEC_ID_AAC;
break; break;
case FLV_CODECID_ADPCM: case FLV_CODECID_ADPCM:
acodec->codec_id = AV_CODEC_ID_ADPCM_SWF; apar->codec_id = AV_CODEC_ID_ADPCM_SWF;
break; break;
case FLV_CODECID_SPEEX: case FLV_CODECID_SPEEX:
acodec->codec_id = AV_CODEC_ID_SPEEX; apar->codec_id = AV_CODEC_ID_SPEEX;
acodec->sample_rate = 16000; apar->sample_rate = 16000;
break; break;
case FLV_CODECID_MP3: case FLV_CODECID_MP3:
acodec->codec_id = AV_CODEC_ID_MP3; apar->codec_id = AV_CODEC_ID_MP3;
astream->need_parsing = AVSTREAM_PARSE_FULL; astream->need_parsing = AVSTREAM_PARSE_FULL;
break; break;
case FLV_CODECID_NELLYMOSER_8KHZ_MONO: case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
// in case metadata does not otherwise declare samplerate // in case metadata does not otherwise declare samplerate
acodec->sample_rate = 8000; apar->sample_rate = 8000;
acodec->codec_id = AV_CODEC_ID_NELLYMOSER; apar->codec_id = AV_CODEC_ID_NELLYMOSER;
break; break;
case FLV_CODECID_NELLYMOSER_16KHZ_MONO: case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
acodec->sample_rate = 16000; apar->sample_rate = 16000;
acodec->codec_id = AV_CODEC_ID_NELLYMOSER; apar->codec_id = AV_CODEC_ID_NELLYMOSER;
break; break;
case FLV_CODECID_NELLYMOSER: case FLV_CODECID_NELLYMOSER:
acodec->codec_id = AV_CODEC_ID_NELLYMOSER; apar->codec_id = AV_CODEC_ID_NELLYMOSER;
break; break;
case FLV_CODECID_PCM_MULAW: case FLV_CODECID_PCM_MULAW:
acodec->sample_rate = 8000; apar->sample_rate = 8000;
acodec->codec_id = AV_CODEC_ID_PCM_MULAW; apar->codec_id = AV_CODEC_ID_PCM_MULAW;
break; break;
case FLV_CODECID_PCM_ALAW: case FLV_CODECID_PCM_ALAW:
acodec->sample_rate = 8000; apar->sample_rate = 8000;
acodec->codec_id = AV_CODEC_ID_PCM_ALAW; apar->codec_id = AV_CODEC_ID_PCM_ALAW;
break; break;
default: default:
av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n",
flv_codecid >> FLV_AUDIO_CODECID_OFFSET); flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET; apar->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
} }
} }
static int flv_same_video_codec(AVCodecContext *vcodec, int flags) static int flv_same_video_codec(AVCodecParameters *vpar, int flags)
{ {
int flv_codecid = flags & FLV_VIDEO_CODECID_MASK; int flv_codecid = flags & FLV_VIDEO_CODECID_MASK;
if (!vcodec->codec_id && !vcodec->codec_tag) if (!vpar->codec_id && !vpar->codec_tag)
return 1; return 1;
switch (flv_codecid) { switch (flv_codecid) {
case FLV_CODECID_H263: case FLV_CODECID_H263:
return vcodec->codec_id == AV_CODEC_ID_FLV1; return vpar->codec_id == AV_CODEC_ID_FLV1;
case FLV_CODECID_SCREEN: case FLV_CODECID_SCREEN:
return vcodec->codec_id == AV_CODEC_ID_FLASHSV; return vpar->codec_id == AV_CODEC_ID_FLASHSV;
case FLV_CODECID_SCREEN2: case FLV_CODECID_SCREEN2:
return vcodec->codec_id == AV_CODEC_ID_FLASHSV2; return vpar->codec_id == AV_CODEC_ID_FLASHSV2;
case FLV_CODECID_VP6: case FLV_CODECID_VP6:
return vcodec->codec_id == AV_CODEC_ID_VP6F; return vpar->codec_id == AV_CODEC_ID_VP6F;
case FLV_CODECID_VP6A: case FLV_CODECID_VP6A:
return vcodec->codec_id == AV_CODEC_ID_VP6A; return vpar->codec_id == AV_CODEC_ID_VP6A;
case FLV_CODECID_H264: case FLV_CODECID_H264:
return vcodec->codec_id == AV_CODEC_ID_H264; return vpar->codec_id == AV_CODEC_ID_H264;
default: default:
return vcodec->codec_tag == flv_codecid; return vpar->codec_tag == flv_codecid;
} }
} }
static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
int flv_codecid, int read) int flv_codecid, int read)
{ {
AVCodecContext *vcodec = vstream->codec; AVCodecParameters *par = vstream->codecpar;
switch (flv_codecid) { switch (flv_codecid) {
case FLV_CODECID_H263: case FLV_CODECID_H263:
vcodec->codec_id = AV_CODEC_ID_FLV1; par->codec_id = AV_CODEC_ID_FLV1;
break; break;
case FLV_CODECID_SCREEN: case FLV_CODECID_SCREEN:
vcodec->codec_id = AV_CODEC_ID_FLASHSV; par->codec_id = AV_CODEC_ID_FLASHSV;
break; break;
case FLV_CODECID_SCREEN2: case FLV_CODECID_SCREEN2:
vcodec->codec_id = AV_CODEC_ID_FLASHSV2; par->codec_id = AV_CODEC_ID_FLASHSV2;
break; break;
case FLV_CODECID_VP6: case FLV_CODECID_VP6:
vcodec->codec_id = AV_CODEC_ID_VP6F; par->codec_id = AV_CODEC_ID_VP6F;
case FLV_CODECID_VP6A: case FLV_CODECID_VP6A:
if (flv_codecid == FLV_CODECID_VP6A) if (flv_codecid == FLV_CODECID_VP6A)
vcodec->codec_id = AV_CODEC_ID_VP6A; par->codec_id = AV_CODEC_ID_VP6A;
if (read) { if (read) {
if (vcodec->extradata_size != 1) { if (par->extradata_size != 1) {
vcodec->extradata = av_malloc(1); par->extradata = av_malloc(1);
if (vcodec->extradata) if (par->extradata)
vcodec->extradata_size = 1; par->extradata_size = 1;
} }
if (vcodec->extradata) if (par->extradata)
vcodec->extradata[0] = avio_r8(s->pb); par->extradata[0] = avio_r8(s->pb);
else else
avio_skip(s->pb, 1); avio_skip(s->pb, 1);
} }
return 1; // 1 byte body size adjustment for flv_read_packet() return 1; // 1 byte body size adjustment for flv_read_packet()
case FLV_CODECID_H264: case FLV_CODECID_H264:
vcodec->codec_id = AV_CODEC_ID_H264; par->codec_id = AV_CODEC_ID_H264;
return 3; // not 4, reading packet type will consume one byte return 3; // not 4, reading packet type will consume one byte
default: default:
av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid); av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
vcodec->codec_tag = flv_codecid; par->codec_tag = flv_codecid;
} }
return 0; return 0;
@ -368,7 +368,7 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream,
AVStream *vstream, const char *key, AVStream *vstream, const char *key,
int64_t max_pos, int depth) int64_t max_pos, int depth)
{ {
AVCodecContext *acodec, *vcodec; AVCodecParameters *apar, *vpar;
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
AVIOContext *ioc; AVIOContext *ioc;
AMFDataType amf_type; AMFDataType amf_type;
@ -442,43 +442,43 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream,
if (key) { if (key) {
// stream info doesn't live any deeper than the first object // stream info doesn't live any deeper than the first object
if (depth == 1) { if (depth == 1) {
acodec = astream ? astream->codec : NULL; apar = astream ? astream->codecpar : NULL;
vcodec = vstream ? vstream->codec : NULL; vpar = vstream ? vstream->codecpar : NULL;
if (amf_type == AMF_DATA_TYPE_NUMBER || if (amf_type == AMF_DATA_TYPE_NUMBER ||
amf_type == AMF_DATA_TYPE_BOOL) { amf_type == AMF_DATA_TYPE_BOOL) {
if (!strcmp(key, "duration")) if (!strcmp(key, "duration"))
s->duration = num_val * AV_TIME_BASE; s->duration = num_val * AV_TIME_BASE;
else if (!strcmp(key, "videodatarate") && vcodec && else if (!strcmp(key, "videodatarate") && vpar &&
0 <= (int)(num_val * 1024.0)) 0 <= (int)(num_val * 1024.0))
vcodec->bit_rate = num_val * 1024.0; vpar->bit_rate = num_val * 1024.0;
else if (!strcmp(key, "audiodatarate") && acodec && else if (!strcmp(key, "audiodatarate") && apar &&
0 <= (int)(num_val * 1024.0)) 0 <= (int)(num_val * 1024.0))
acodec->bit_rate = num_val * 1024.0; apar->bit_rate = num_val * 1024.0;
else if (!strcmp(key, "datastream")) { else if (!strcmp(key, "datastream")) {
AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA); AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_TEXT; st->codecpar->codec_id = AV_CODEC_ID_TEXT;
} else if (flv->trust_metadata) { } else if (flv->trust_metadata) {
if (!strcmp(key, "videocodecid") && vcodec) { if (!strcmp(key, "videocodecid") && vpar) {
flv_set_video_codec(s, vstream, num_val, 0); flv_set_video_codec(s, vstream, num_val, 0);
} else if (!strcmp(key, "audiocodecid") && acodec) { } else if (!strcmp(key, "audiocodecid") && apar) {
int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET; int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
flv_set_audio_codec(s, astream, acodec, id); flv_set_audio_codec(s, astream, apar, id);
} else if (!strcmp(key, "audiosamplerate") && acodec) { } else if (!strcmp(key, "audiosamplerate") && apar) {
acodec->sample_rate = num_val; apar->sample_rate = num_val;
} else if (!strcmp(key, "audiosamplesize") && acodec) { } else if (!strcmp(key, "audiosamplesize") && apar) {
acodec->bits_per_coded_sample = num_val; apar->bits_per_coded_sample = num_val;
} else if (!strcmp(key, "stereo") && acodec) { } else if (!strcmp(key, "stereo") && apar) {
acodec->channels = num_val + 1; apar->channels = num_val + 1;
acodec->channel_layout = acodec->channels == 2 ? apar->channel_layout = apar->channels == 2 ?
AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_STEREO :
AV_CH_LAYOUT_MONO; AV_CH_LAYOUT_MONO;
} else if (!strcmp(key, "width") && vcodec) { } else if (!strcmp(key, "width") && vpar) {
vcodec->width = num_val; vpar->width = num_val;
} else if (!strcmp(key, "height") && vcodec) { } else if (!strcmp(key, "height") && vpar) {
vcodec->height = num_val; vpar->height = num_val;
} }
} }
} }
@ -544,9 +544,9 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
// the lookup every time it is called. // the lookup every time it is called.
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
stream = s->streams[i]; stream = s->streams[i];
if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
astream = stream; astream = stream;
else if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) else if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
vstream = stream; vstream = stream;
} }
@ -585,12 +585,12 @@ static int flv_read_close(AVFormatContext *s)
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size) static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
{ {
av_free(st->codec->extradata); av_free(st->codecpar->extradata);
st->codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = size; st->codecpar->extradata_size = size;
avio_read(s->pb, st->codec->extradata, st->codec->extradata_size); avio_read(s->pb, st->codecpar->extradata, st->codecpar->extradata_size);
return 0; return 0;
} }
@ -704,7 +704,7 @@ static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i]; st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_DATA) if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
break; break;
} }
@ -712,7 +712,7 @@ static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
st = create_stream(s, AVMEDIA_TYPE_DATA); st = create_stream(s, AVMEDIA_TYPE_DATA);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_TEXT; st->codecpar->codec_id = AV_CODEC_ID_TEXT;
} }
pkt->dts = dts; pkt->dts = dts;
@ -803,12 +803,12 @@ skip:
/* now find stream */ /* now find stream */
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i]; st = s->streams[i];
if (is_audio && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (is_audio && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if (flv_same_audio_codec(st->codec, flags)) if (flv_same_audio_codec(st->codecpar, flags))
break; break;
} else if (!is_audio && } else if (!is_audio &&
st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (flv_same_video_codec(st->codec, flags)) if (flv_same_video_codec(st->codecpar, flags))
break; break;
} }
} }
@ -866,38 +866,43 @@ skip:
sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
FLV_AUDIO_SAMPLERATE_OFFSET) >> 3; FLV_AUDIO_SAMPLERATE_OFFSET) >> 3;
bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8; bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
if (!st->codec->channels || !st->codec->sample_rate || if (!st->codecpar->channels || !st->codecpar->sample_rate ||
!st->codec->bits_per_coded_sample) { !st->codecpar->bits_per_coded_sample) {
st->codec->channels = channels; st->codecpar->channels = channels;
st->codec->channel_layout = channels == 1 st->codecpar->channel_layout = channels == 1
? AV_CH_LAYOUT_MONO ? AV_CH_LAYOUT_MONO
: AV_CH_LAYOUT_STEREO; : AV_CH_LAYOUT_STEREO;
st->codec->sample_rate = sample_rate; st->codecpar->sample_rate = sample_rate;
st->codec->bits_per_coded_sample = bits_per_coded_sample; st->codecpar->bits_per_coded_sample = bits_per_coded_sample;
} }
if (!st->codec->codec_id) { if (!st->codecpar->codec_id) {
flv_set_audio_codec(s, st, st->codec, flv_set_audio_codec(s, st, st->codecpar,
flags & FLV_AUDIO_CODECID_MASK); flags & FLV_AUDIO_CODECID_MASK);
flv->last_sample_rate = flv->last_sample_rate =
sample_rate = st->codec->sample_rate; sample_rate = st->codecpar->sample_rate;
flv->last_channels = flv->last_channels =
channels = st->codec->channels; channels = st->codecpar->channels;
} else { } else {
AVCodecContext ctx; AVCodecParameters *par = avcodec_parameters_alloc();
ctx.sample_rate = sample_rate; if (!par) {
ctx.bits_per_coded_sample = bits_per_coded_sample; ret = AVERROR(ENOMEM);
flv_set_audio_codec(s, st, &ctx, flags & FLV_AUDIO_CODECID_MASK); goto leave;
sample_rate = ctx.sample_rate; }
par->sample_rate = sample_rate;
par->bits_per_coded_sample = bits_per_coded_sample;
flv_set_audio_codec(s, st, par, flags & FLV_AUDIO_CODECID_MASK);
sample_rate = par->sample_rate;
avcodec_parameters_free(&par);
} }
} else { } else {
size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1); size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
} }
if (st->codec->codec_id == AV_CODEC_ID_AAC || if (st->codecpar->codec_id == AV_CODEC_ID_AAC ||
st->codec->codec_id == AV_CODEC_ID_H264) { st->codecpar->codec_id == AV_CODEC_ID_H264) {
int type = avio_r8(s->pb); int type = avio_r8(s->pb);
size--; size--;
if (st->codec->codec_id == AV_CODEC_ID_H264) { if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
// sign extension // sign extension
int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000; int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
pts = dts + cts; pts = dts + cts;
@ -908,7 +913,7 @@ skip:
} }
} }
if (type == 0) { if (type == 0) {
if (st->codec->extradata) { if (st->codecpar->extradata) {
if ((ret = flv_queue_extradata(flv, s->pb, is_audio, size)) < 0) if ((ret = flv_queue_extradata(flv, s->pb, is_audio, size)) < 0)
return ret; return ret;
ret = AVERROR(EAGAIN); ret = AVERROR(EAGAIN);
@ -916,24 +921,24 @@ skip:
} }
if ((ret = flv_get_extradata(s, st, size)) < 0) if ((ret = flv_get_extradata(s, st, size)) < 0)
return ret; return ret;
if (st->codec->codec_id == AV_CODEC_ID_AAC) { if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
MPEG4AudioConfig cfg; MPEG4AudioConfig cfg;
/* Workaround for buggy Omnia A/XE encoder */ /* Workaround for buggy Omnia A/XE encoder */
AVDictionaryEntry *t = av_dict_get(s->metadata, "Encoder", NULL, 0); AVDictionaryEntry *t = av_dict_get(s->metadata, "Encoder", NULL, 0);
if (t && !strcmp(t->value, "Omnia A/XE")) if (t && !strcmp(t->value, "Omnia A/XE"))
st->codec->extradata_size = 2; st->codecpar->extradata_size = 2;
avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata, avpriv_mpeg4audio_get_config(&cfg, st->codecpar->extradata,
st->codec->extradata_size * 8, 1); st->codecpar->extradata_size * 8, 1);
st->codec->channels = cfg.channels; st->codecpar->channels = cfg.channels;
st->codec->channel_layout = 0; st->codecpar->channel_layout = 0;
if (cfg.ext_sample_rate) if (cfg.ext_sample_rate)
st->codec->sample_rate = cfg.ext_sample_rate; st->codecpar->sample_rate = cfg.ext_sample_rate;
else else
st->codec->sample_rate = cfg.sample_rate; st->codecpar->sample_rate = cfg.sample_rate;
av_log(s, AV_LOG_TRACE, "mp4a config channels %d sample rate %d\n", av_log(s, AV_LOG_TRACE, "mp4a config channels %d sample rate %d\n",
st->codec->channels, st->codec->sample_rate); st->codecpar->channels, st->codecpar->sample_rate);
} }
ret = AVERROR(EAGAIN); ret = AVERROR(EAGAIN);

152
libavformat/flvenc.c
Unescape View File

@ -61,37 +61,37 @@ typedef struct FLVContext {
int64_t duration; int64_t duration;
int64_t delay; ///< first dts delay (needed for AVC & Speex) int64_t delay; ///< first dts delay (needed for AVC & Speex)
AVCodecContext *audio_enc; AVCodecParameters *audio_par;
AVCodecContext *video_enc; AVCodecParameters *video_par;
double framerate; double framerate;
AVCodecContext *data_enc; AVCodecParameters *data_par;
} FLVContext; } FLVContext;
typedef struct FLVStreamContext { typedef struct FLVStreamContext {
int64_t last_ts; ///< last timestamp for each stream int64_t last_ts; ///< last timestamp for each stream
} FLVStreamContext; } FLVStreamContext;
static int get_audio_flags(AVFormatContext *s, AVCodecContext *enc) static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
{ {
int flags = (enc->bits_per_coded_sample == 16) ? FLV_SAMPLESSIZE_16BIT int flags = (par->bits_per_coded_sample == 16) ? FLV_SAMPLESSIZE_16BIT
: FLV_SAMPLESSIZE_8BIT; : FLV_SAMPLESSIZE_8BIT;
if (enc->codec_id == AV_CODEC_ID_AAC) // specs force these parameters if (par->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
return FLV_CODECID_AAC | FLV_SAMPLERATE_44100HZ | return FLV_CODECID_AAC | FLV_SAMPLERATE_44100HZ |
FLV_SAMPLESSIZE_16BIT | FLV_STEREO; FLV_SAMPLESSIZE_16BIT | FLV_STEREO;
else if (enc->codec_id == AV_CODEC_ID_SPEEX) { else if (par->codec_id == AV_CODEC_ID_SPEEX) {
if (enc->sample_rate != 16000) { if (par->sample_rate != 16000) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"flv only supports wideband (16kHz) Speex audio\n"); "flv only supports wideband (16kHz) Speex audio\n");
return -1; return -1;
} }
if (enc->channels != 1) { if (par->channels != 1) {
av_log(s, AV_LOG_ERROR, "flv only supports mono Speex audio\n"); av_log(s, AV_LOG_ERROR, "flv only supports mono Speex audio\n");
return -1; return -1;
} }
return FLV_CODECID_SPEEX | FLV_SAMPLERATE_11025HZ | FLV_SAMPLESSIZE_16BIT; return FLV_CODECID_SPEEX | FLV_SAMPLERATE_11025HZ | FLV_SAMPLESSIZE_16BIT;
} else { } else {
switch (enc->sample_rate) { switch (par->sample_rate) {
case 44100: case 44100:
flags |= FLV_SAMPLERATE_44100HZ; flags |= FLV_SAMPLERATE_44100HZ;
break; break;
@ -104,7 +104,7 @@ static int get_audio_flags(AVFormatContext *s, AVCodecContext *enc)
case 16000: // nellymoser only case 16000: // nellymoser only
case 8000: // nellymoser only case 8000: // nellymoser only
case 5512: // not MP3 case 5512: // not MP3
if (enc->codec_id != AV_CODEC_ID_MP3) { if (par->codec_id != AV_CODEC_ID_MP3) {
flags |= FLV_SAMPLERATE_SPECIAL; flags |= FLV_SAMPLERATE_SPECIAL;
break; break;
} }
@ -116,10 +116,10 @@ static int get_audio_flags(AVFormatContext *s, AVCodecContext *enc)
} }
} }
if (enc->channels > 1) if (par->channels > 1)
flags |= FLV_STEREO; flags |= FLV_STEREO;
switch (enc->codec_id) { switch (par->codec_id) {
case AV_CODEC_ID_MP3: case AV_CODEC_ID_MP3:
flags |= FLV_CODECID_MP3 | FLV_SAMPLESSIZE_16BIT; flags |= FLV_CODECID_MP3 | FLV_SAMPLESSIZE_16BIT;
break; break;
@ -136,9 +136,9 @@ static int get_audio_flags(AVFormatContext *s, AVCodecContext *enc)
flags |= FLV_CODECID_ADPCM | FLV_SAMPLESSIZE_16BIT; flags |= FLV_CODECID_ADPCM | FLV_SAMPLESSIZE_16BIT;
break; break;
case AV_CODEC_ID_NELLYMOSER: case AV_CODEC_ID_NELLYMOSER:
if (enc->sample_rate == 8000) if (par->sample_rate == 8000)
flags |= FLV_CODECID_NELLYMOSER_8KHZ_MONO | FLV_SAMPLESSIZE_16BIT; flags |= FLV_CODECID_NELLYMOSER_8KHZ_MONO | FLV_SAMPLESSIZE_16BIT;
else if (enc->sample_rate == 16000) else if (par->sample_rate == 16000)
flags |= FLV_CODECID_NELLYMOSER_16KHZ_MONO | FLV_SAMPLESSIZE_16BIT; flags |= FLV_CODECID_NELLYMOSER_16KHZ_MONO | FLV_SAMPLESSIZE_16BIT;
else else
flags |= FLV_CODECID_NELLYMOSER | FLV_SAMPLESSIZE_16BIT; flags |= FLV_CODECID_NELLYMOSER | FLV_SAMPLESSIZE_16BIT;
@ -150,7 +150,7 @@ static int get_audio_flags(AVFormatContext *s, AVCodecContext *enc)
flags = FLV_CODECID_PCM_ALAW | FLV_SAMPLERATE_SPECIAL | FLV_SAMPLESSIZE_16BIT; flags = FLV_CODECID_PCM_ALAW | FLV_SAMPLERATE_SPECIAL | FLV_SAMPLESSIZE_16BIT;
break; break;
case 0: case 0:
flags |= enc->codec_tag << 4; flags |= par->codec_tag << 4;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n"); av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n");
@ -216,9 +216,9 @@ static void write_metadata(AVFormatContext *s, unsigned int ts)
/* mixed array (hash) with size and string/type/data tuples */ /* mixed array (hash) with size and string/type/data tuples */
avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY); avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
metadata_count_pos = avio_tell(pb); metadata_count_pos = avio_tell(pb);
metadata_count = 4 * !!flv->video_enc + metadata_count = 4 * !!flv->video_par +
5 * !!flv->audio_enc + 5 * !!flv->audio_par +
1 * !!flv->data_enc + 1 * !!flv->data_par +
2; // +2 for duration and file size 2; // +2 for duration and file size
avio_wb32(pb, metadata_count); avio_wb32(pb, metadata_count);
@ -229,15 +229,15 @@ static void write_metadata(AVFormatContext *s, unsigned int ts)
// fill in the guessed duration, it'll be corrected later if incorrect // fill in the guessed duration, it'll be corrected later if incorrect
put_amf_double(pb, s->duration / AV_TIME_BASE); put_amf_double(pb, s->duration / AV_TIME_BASE);
if (flv->video_enc) { if (flv->video_par) {
put_amf_string(pb, "width"); put_amf_string(pb, "width");
put_amf_double(pb, flv->video_enc->width); put_amf_double(pb, flv->video_par->width);
put_amf_string(pb, "height"); put_amf_string(pb, "height");
put_amf_double(pb, flv->video_enc->height); put_amf_double(pb, flv->video_par->height);
put_amf_string(pb, "videodatarate"); put_amf_string(pb, "videodatarate");
put_amf_double(pb, flv->video_enc->bit_rate / 1024.0); put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
if (flv->framerate != 0.0) { if (flv->framerate != 0.0) {
put_amf_string(pb, "framerate"); put_amf_string(pb, "framerate");
@ -246,27 +246,27 @@ static void write_metadata(AVFormatContext *s, unsigned int ts)
} }
put_amf_string(pb, "videocodecid"); put_amf_string(pb, "videocodecid");
put_amf_double(pb, flv->video_enc->codec_tag); put_amf_double(pb, flv->video_par->codec_tag);
} }
if (flv->audio_enc) { if (flv->audio_par) {
put_amf_string(pb, "audiodatarate"); put_amf_string(pb, "audiodatarate");
put_amf_double(pb, flv->audio_enc->bit_rate / 1024.0); put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
put_amf_string(pb, "audiosamplerate"); put_amf_string(pb, "audiosamplerate");
put_amf_double(pb, flv->audio_enc->sample_rate); put_amf_double(pb, flv->audio_par->sample_rate);
put_amf_string(pb, "audiosamplesize"); put_amf_string(pb, "audiosamplesize");
put_amf_double(pb, flv->audio_enc->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16); put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
put_amf_string(pb, "stereo"); put_amf_string(pb, "stereo");
put_amf_bool(pb, flv->audio_enc->channels == 2); put_amf_bool(pb, flv->audio_par->channels == 2);
put_amf_string(pb, "audiocodecid"); put_amf_string(pb, "audiocodecid");
put_amf_double(pb, flv->audio_enc->codec_tag); put_amf_double(pb, flv->audio_par->codec_tag);
} }
if (flv->data_enc) { if (flv->data_par) {
put_amf_string(pb, "datastream"); put_amf_string(pb, "datastream");
put_amf_double(pb, 0.0); put_amf_double(pb, 0.0);
} }
@ -316,37 +316,37 @@ static int flv_write_header(AVFormatContext *s)
int64_t data_size; int64_t data_size;
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVCodecContext *enc = s->streams[i]->codec; AVCodecParameters *par = s->streams[i]->codecpar;
FLVStreamContext *sc; FLVStreamContext *sc;
switch (enc->codec_type) { switch (par->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
if (s->streams[i]->avg_frame_rate.den && if (s->streams[i]->avg_frame_rate.den &&
s->streams[i]->avg_frame_rate.num) { s->streams[i]->avg_frame_rate.num) {
flv->framerate = av_q2d(s->streams[i]->avg_frame_rate); flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
} }
if (flv->video_enc) { if (flv->video_par) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"at most one video stream is supported in flv\n"); "at most one video stream is supported in flv\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
flv->video_enc = enc; flv->video_par = par;
if (!ff_codec_get_tag(flv_video_codec_ids, enc->codec_id)) if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
return unsupported_codec(s, "Video", enc->codec_id); return unsupported_codec(s, "Video", par->codec_id);
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
if (flv->audio_enc) { if (flv->audio_par) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"at most one audio stream is supported in flv\n"); "at most one audio stream is supported in flv\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
flv->audio_enc = enc; flv->audio_par = par;
if (get_audio_flags(s, enc) < 0) if (get_audio_flags(s, par) < 0)
return unsupported_codec(s, "Audio", enc->codec_id); return unsupported_codec(s, "Audio", par->codec_id);
break; break;
case AVMEDIA_TYPE_DATA: case AVMEDIA_TYPE_DATA:
if (enc->codec_id != AV_CODEC_ID_TEXT) if (par->codec_id != AV_CODEC_ID_TEXT)
return unsupported_codec(s, "Data", enc->codec_id); return unsupported_codec(s, "Data", par->codec_id);
flv->data_enc = enc; flv->data_par = par;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n"); av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n");
@ -365,13 +365,13 @@ static int flv_write_header(AVFormatContext *s)
avio_write(pb, "FLV", 3); avio_write(pb, "FLV", 3);
avio_w8(pb, 1); avio_w8(pb, 1);
avio_w8(pb, FLV_HEADER_FLAG_HASAUDIO * !!flv->audio_enc + avio_w8(pb, FLV_HEADER_FLAG_HASAUDIO * !!flv->audio_par +
FLV_HEADER_FLAG_HASVIDEO * !!flv->video_enc); FLV_HEADER_FLAG_HASVIDEO * !!flv->video_par);
avio_wb32(pb, 9); avio_wb32(pb, 9);
avio_wb32(pb, 0); avio_wb32(pb, 0);
for (i = 0; i < s->nb_streams; i++) for (i = 0; i < s->nb_streams; i++)
if (s->streams[i]->codec->codec_tag == 5) { if (s->streams[i]->codecpar->codec_tag == 5) {
avio_w8(pb, 8); // message type avio_w8(pb, 8); // message type
avio_wb24(pb, 0); // include flags avio_wb24(pb, 0); // include flags
avio_wb24(pb, 0); // time stamp avio_wb24(pb, 0); // time stamp
@ -383,25 +383,25 @@ static int flv_write_header(AVFormatContext *s)
write_metadata(s, 0); write_metadata(s, 0);
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVCodecContext *enc = s->streams[i]->codec; AVCodecParameters *par = s->streams[i]->codecpar;
if (enc->codec_id == AV_CODEC_ID_AAC || enc->codec_id == AV_CODEC_ID_H264) { if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264) {
int64_t pos; int64_t pos;
avio_w8(pb, enc->codec_type == AVMEDIA_TYPE_VIDEO ? avio_w8(pb, par->codec_type == AVMEDIA_TYPE_VIDEO ?
FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO); FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
avio_wb24(pb, 0); // size patched later avio_wb24(pb, 0); // size patched later
avio_wb24(pb, 0); // ts avio_wb24(pb, 0); // ts
avio_w8(pb, 0); // ts ext avio_w8(pb, 0); // ts ext
avio_wb24(pb, 0); // streamid avio_wb24(pb, 0); // streamid
pos = avio_tell(pb); pos = avio_tell(pb);
if (enc->codec_id == AV_CODEC_ID_AAC) { if (par->codec_id == AV_CODEC_ID_AAC) {
avio_w8(pb, get_audio_flags(s, enc)); avio_w8(pb, get_audio_flags(s, par));
avio_w8(pb, 0); // AAC sequence header avio_w8(pb, 0); // AAC sequence header
avio_write(pb, enc->extradata, enc->extradata_size); avio_write(pb, par->extradata, par->extradata_size);
} else { } else {
avio_w8(pb, enc->codec_tag | FLV_FRAME_KEY); // flags avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
avio_w8(pb, 0); // AVC sequence header avio_w8(pb, 0); // AVC sequence header
avio_wb24(pb, 0); // composition time avio_wb24(pb, 0); // composition time
ff_isom_write_avcc(pb, enc->extradata, enc->extradata_size); ff_isom_write_avcc(pb, par->extradata, par->extradata_size);
} }
data_size = avio_tell(pb) - pos; data_size = avio_tell(pb) - pos;
avio_seek(pb, -data_size - 10, SEEK_CUR); avio_seek(pb, -data_size - 10, SEEK_CUR);
@ -424,10 +424,10 @@ static int flv_write_trailer(AVFormatContext *s)
/* Add EOS tag */ /* Add EOS tag */
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVCodecContext *enc = s->streams[i]->codec; AVCodecParameters *par = s->streams[i]->codecpar;
FLVStreamContext *sc = s->streams[i]->priv_data; FLVStreamContext *sc = s->streams[i]->priv_data;
if (enc->codec_type == AVMEDIA_TYPE_VIDEO && if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
enc->codec_id == AV_CODEC_ID_H264) par->codec_id == AV_CODEC_ID_H264)
put_avc_eos_tag(pb, sc->last_ts); put_avc_eos_tag(pb, sc->last_ts);
} }
@ -450,7 +450,7 @@ static int flv_write_trailer(AVFormatContext *s)
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt) static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[pkt->stream_index]->codec; AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data; FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
unsigned ts; unsigned ts;
@ -458,10 +458,10 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
uint8_t *data = NULL; uint8_t *data = NULL;
int flags = 0, flags_size; int flags = 0, flags_size;
if (enc->codec_id == AV_CODEC_ID_VP6F || enc->codec_id == AV_CODEC_ID_VP6A || if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
enc->codec_id == AV_CODEC_ID_AAC) par->codec_id == AV_CODEC_ID_AAC)
flags_size = 2; flags_size = 2;
else if (enc->codec_id == AV_CODEC_ID_H264) else if (par->codec_id == AV_CODEC_ID_H264)
flags_size = 5; flags_size = 5;
else else
flags_size = 1; flags_size = 1;
@ -482,16 +482,16 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED; s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
} }
switch (enc->codec_type) { switch (par->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
avio_w8(pb, FLV_TAG_TYPE_VIDEO); avio_w8(pb, FLV_TAG_TYPE_VIDEO);
flags = ff_codec_get_tag(flv_video_codec_ids, enc->codec_id); flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
flags |= pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER; flags |= pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
flags = get_audio_flags(s, enc); flags = get_audio_flags(s, par);
assert(size); assert(size);
@ -504,14 +504,14 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (enc->codec_id == AV_CODEC_ID_H264) if (par->codec_id == AV_CODEC_ID_H264)
/* check if extradata looks like MP4 */ /* check if extradata looks like MP4 */
if (enc->extradata_size > 0 && *(uint8_t*)enc->extradata != 1) if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
if (ff_avc_parse_nal_units_buf(pkt->data, &data, &size) < 0) if (ff_avc_parse_nal_units_buf(pkt->data, &data, &size) < 0)
return -1; return -1;
/* check Speex packet duration */ /* check Speex packet duration */
if (enc->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160) if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than " av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
"8 frames per packet. Adobe Flash " "8 frames per packet. Adobe Flash "
"Player cannot handle this!\n"); "Player cannot handle this!\n");
@ -524,7 +524,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
avio_w8(pb, (ts >> 24) & 0x7F); // timestamps are 32 bits _signed_ avio_w8(pb, (ts >> 24) & 0x7F); // timestamps are 32 bits _signed_
avio_wb24(pb, flv->reserved); avio_wb24(pb, flv->reserved);
if (enc->codec_type == AVMEDIA_TYPE_DATA) { if (par->codec_type == AVMEDIA_TYPE_DATA) {
int data_size; int data_size;
int64_t metadata_size_pos = avio_tell(pb); int64_t metadata_size_pos = avio_tell(pb);
avio_w8(pb, AMF_DATA_TYPE_STRING); avio_w8(pb, AMF_DATA_TYPE_STRING);
@ -547,15 +547,15 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
avio_wb32(pb, data_size + 11); avio_wb32(pb, data_size + 11);
} else { } else {
avio_w8(pb,flags); avio_w8(pb,flags);
if (enc->codec_id == AV_CODEC_ID_VP6F || enc->codec_id == AV_CODEC_ID_VP6A) { if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
if (enc->extradata_size) if (par->extradata_size)
avio_w8(pb, enc->extradata[0]); avio_w8(pb, par->extradata[0]);
else else
avio_w8(pb, ((FFALIGN(enc->width, 16) - enc->width) << 4) | avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
(FFALIGN(enc->height, 16) - enc->height)); (FFALIGN(par->height, 16) - par->height));
} else if (enc->codec_id == AV_CODEC_ID_AAC) } else if (par->codec_id == AV_CODEC_ID_AAC)
avio_w8(pb, 1); // AAC raw avio_w8(pb, 1); // AAC raw
else if (enc->codec_id == AV_CODEC_ID_H264) { else if (par->codec_id == AV_CODEC_ID_H264) {
avio_w8(pb, 1); // AVC NALU avio_w8(pb, 1); // AVC NALU
avio_wb24(pb, pkt->pts - pkt->dts); avio_wb24(pb, pkt->pts - pkt->dts);
} }

16
libavformat/g722.c
Unescape View File

@ -31,17 +31,17 @@ static int g722_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ADPCM_G722; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_G722;
st->codec->sample_rate = 16000; st->codecpar->sample_rate = 16000;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->bits_per_coded_sample = st->codecpar->bits_per_coded_sample =
av_get_bits_per_sample(st->codec->codec_id); av_get_bits_per_sample(st->codecpar->codec_id);
assert(st->codec->bits_per_coded_sample > 0); assert(st->codecpar->bits_per_coded_sample > 0);
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
return 0; return 0;
} }

12
libavformat/g723_1.c
Unescape View File

@ -39,13 +39,13 @@ static av_cold int g723_1_init(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_G723_1; st->codecpar->codec_id = AV_CODEC_ID_G723_1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->sample_rate = 8000; st->codecpar->sample_rate = 8000;
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
st->start_time = 0; st->start_time = 0;
return 0; return 0;

33
libavformat/gif.c
Unescape View File

@ -264,7 +264,7 @@ static int gif_write_header(AVFormatContext *s)
{ {
GIFContext *gif = s->priv_data; GIFContext *gif = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc, *video_enc; AVCodecParameters *par, *video_par;
int i, width, height /*, rate*/; int i, width, height /*, rate*/;
/* XXX: do we reject audio streams or just ignore them ? /* XXX: do we reject audio streams or just ignore them ?
@ -274,23 +274,23 @@ static int gif_write_header(AVFormatContext *s)
gif->time = 0; gif->time = 0;
gif->file_time = 0; gif->file_time = 0;
video_enc = NULL; video_par = NULL;
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
enc = s->streams[i]->codec; par = s->streams[i]->codecpar;
if (enc->codec_type != AVMEDIA_TYPE_AUDIO) if (par->codec_type != AVMEDIA_TYPE_AUDIO)
video_enc = enc; video_par = par;
} }
if (!video_enc) { if (!video_par) {
av_free(gif); av_free(gif);
return -1; return -1;
} else { } else {
width = video_enc->width; width = video_par->width;
height = video_enc->height; height = video_par->height;
// rate = video_enc->time_base.den; // rate = video_enc->time_base.den;
} }
if (video_enc->pix_fmt != AV_PIX_FMT_RGB24) { if (video_par->format != AV_PIX_FMT_RGB24) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"ERROR: gif only handles the rgb24 pixel format. Use -pix_fmt rgb24.\n"); "ERROR: gif only handles the rgb24 pixel format. Use -pix_fmt rgb24.\n");
return AVERROR(EIO); return AVERROR(EIO);
@ -302,9 +302,10 @@ static int gif_write_header(AVFormatContext *s)
return 0; return 0;
} }
static int gif_write_video(AVFormatContext *s, AVCodecContext *enc, static int gif_write_video(AVFormatContext *s, AVStream *st,
const uint8_t *buf, int size) const uint8_t *buf, int size)
{ {
AVCodecParameters *par = st->codecpar;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int jiffies; int jiffies;
@ -319,26 +320,26 @@ static int gif_write_video(AVFormatContext *s, AVCodecContext *enc,
/* XXX: should use delay, in order to be more accurate */ /* XXX: should use delay, in order to be more accurate */
/* instead of using the same rounded value each time */ /* instead of using the same rounded value each time */
/* XXX: don't even remember if I really use it for now */ /* XXX: don't even remember if I really use it for now */
jiffies = (70 * enc->time_base.num / enc->time_base.den) - 1; jiffies = (70 * st->time_base.num / st->time_base.den) - 1;
avio_wl16(pb, jiffies); avio_wl16(pb, jiffies);
avio_w8(pb, 0x1f); /* transparent color index */ avio_w8(pb, 0x1f); /* transparent color index */
avio_w8(pb, 0x00); avio_w8(pb, 0x00);
gif_image_write_image(pb, 0, 0, enc->width, enc->height, gif_image_write_image(pb, 0, 0, par->width, par->height,
buf, enc->width * 3, AV_PIX_FMT_RGB24); buf, par->width * 3, AV_PIX_FMT_RGB24);
return 0; return 0;
} }
static int gif_write_packet(AVFormatContext *s, AVPacket *pkt) static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVCodecContext *codec = s->streams[pkt->stream_index]->codec; AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
if (codec->codec_type == AVMEDIA_TYPE_AUDIO) if (par->codec_type == AVMEDIA_TYPE_AUDIO)
return 0; /* just ignore audio */ return 0; /* just ignore audio */
else else
return gif_write_video(s, codec, pkt->data, pkt->size); return gif_write_video(s, s->streams[pkt->stream_index], pkt->data, pkt->size);
} }
static int gif_write_trailer(AVFormatContext *s) static int gif_write_trailer(AVFormatContext *s)

12
libavformat/gsmdec.c
Unescape View File

@ -62,12 +62,12 @@ static int gsm_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->iformat->raw_codec_id; st->codecpar->codec_id = s->iformat->raw_codec_id;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->sample_rate = c->sample_rate; st->codecpar->sample_rate = c->sample_rate;
st->codec->bit_rate = GSM_BLOCK_SIZE * 8 * c->sample_rate / GSM_BLOCK_SAMPLES; st->codecpar->bit_rate = GSM_BLOCK_SIZE * 8 * c->sample_rate / GSM_BLOCK_SAMPLES;
avpriv_set_pts_info(st, 64, GSM_BLOCK_SAMPLES, GSM_SAMPLE_RATE); avpriv_set_pts_info(st, 64, GSM_BLOCK_SAMPLES, GSM_SAMPLE_RATE);

78
libavformat/gxf.c
Unescape View File

@ -92,69 +92,69 @@ static int get_sindex(AVFormatContext *s, int id, int format) {
switch (format) { switch (format) {
case 3: case 3:
case 4: case 4:
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MJPEG; st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
break; break;
case 13: case 13:
case 15: case 15:
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_DVVIDEO; st->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
break; break;
case 14: case 14:
case 16: case 16:
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_DVVIDEO; st->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
break; break;
case 11: case 11:
case 12: case 12:
case 20: case 20:
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MPEG2VIDEO; st->codecpar->codec_id = AV_CODEC_ID_MPEG2VIDEO;
st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc. st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
break; break;
case 22: case 22:
case 23: case 23:
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MPEG1VIDEO; st->codecpar->codec_id = AV_CODEC_ID_MPEG1VIDEO;
st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc. st->need_parsing = AVSTREAM_PARSE_HEADERS; //get keyframe flag etc.
break; break;
case 9: case 9:
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_PCM_S24LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->sample_rate = 48000; st->codecpar->sample_rate = 48000;
st->codec->bit_rate = 3 * 1 * 48000 * 8; st->codecpar->bit_rate = 3 * 1 * 48000 * 8;
st->codec->block_align = 3 * 1; st->codecpar->block_align = 3 * 1;
st->codec->bits_per_coded_sample = 24; st->codecpar->bits_per_coded_sample = 24;
break; break;
case 10: case 10:
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
st->codec->sample_rate = 48000; st->codecpar->sample_rate = 48000;
st->codec->bit_rate = 2 * 1 * 48000 * 8; st->codecpar->bit_rate = 2 * 1 * 48000 * 8;
st->codec->block_align = 2 * 1; st->codecpar->block_align = 2 * 1;
st->codec->bits_per_coded_sample = 16; st->codecpar->bits_per_coded_sample = 16;
break; break;
case 17: case 17:
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_AC3; st->codecpar->codec_id = AV_CODEC_ID_AC3;
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
st->codec->sample_rate = 48000; st->codecpar->sample_rate = 48000;
break; break;
// timecode tracks: // timecode tracks:
case 7: case 7:
case 8: case 8:
case 24: case 24:
st->codec->codec_type = AVMEDIA_TYPE_DATA; st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
st->codec->codec_id = AV_CODEC_ID_NONE; st->codecpar->codec_id = AV_CODEC_ID_NONE;
break; break;
default: default:
st->codec->codec_type = AVMEDIA_TYPE_UNKNOWN; st->codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
st->codec->codec_id = AV_CODEC_ID_NONE; st->codecpar->codec_id = AV_CODEC_ID_NONE;
break; break;
} }
return s->nb_streams - 1; return s->nb_streams - 1;
@ -479,11 +479,11 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
avio_rb32(pb); // "timeline" field number avio_rb32(pb); // "timeline" field number
avio_r8(pb); // flags avio_r8(pb); // flags
avio_r8(pb); // reserved avio_r8(pb); // reserved
if (st->codec->codec_id == AV_CODEC_ID_PCM_S24LE || if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE ||
st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) { st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
int first = field_info >> 16; int first = field_info >> 16;
int last = field_info & 0xffff; // last is exclusive int last = field_info & 0xffff; // last is exclusive
int bps = av_get_bits_per_sample(st->codec->codec_id)>>3; int bps = av_get_bits_per_sample(st->codecpar->codec_id)>>3;
if (first <= last && last*bps <= pkt_len) { if (first <= last && last*bps <= pkt_len) {
avio_skip(pb, first*bps); avio_skip(pb, first*bps);
skip = pkt_len - last*bps; skip = pkt_len - last*bps;
@ -498,7 +498,7 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
pkt->dts = field_nr; pkt->dts = field_nr;
//set duration manually for DV or else lavf misdetects the frame rate //set duration manually for DV or else lavf misdetects the frame rate
if (st->codec->codec_id == AV_CODEC_ID_DVVIDEO) if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)
pkt->duration = si->fields_per_frame; pkt->duration = si->fields_per_frame;
return ret; return ret;

62
libavformat/gxfenc.c
Unescape View File

@ -107,7 +107,7 @@ static int gxf_find_lines_index(AVStream *st)
int i; int i;
for (i = 0; i < 6; ++i) { for (i = 0; i < 6; ++i) {
if (st->codec->height == gxf_lines_tab[i].height) { if (st->codecpar->height == gxf_lines_tab[i].height) {
sc->lines_index = gxf_lines_tab[i].index; sc->lines_index = gxf_lines_tab[i].index;
return 0; return 0;
} }
@ -181,18 +181,18 @@ static int gxf_write_mpeg_auxiliary(AVIOContext *pb, AVStream *st)
if (sc->b_per_i_or_p > 9) if (sc->b_per_i_or_p > 9)
sc->b_per_i_or_p = 9; /* ensure value won't take more than one char */ sc->b_per_i_or_p = 9; /* ensure value won't take more than one char */
} }
if (st->codec->height == 512 || st->codec->height == 608) if (st->codecpar->height == 512 || st->codecpar->height == 608)
starting_line = 7; // VBI starting_line = 7; // VBI
else if (st->codec->height == 480) else if (st->codecpar->height == 480)
starting_line = 20; starting_line = 20;
else else
starting_line = 23; // default PAL starting_line = 23; // default PAL
size = snprintf(buffer, 1024, "Ver 1\nBr %.6f\nIpg 1\nPpi %d\nBpiop %d\n" size = snprintf(buffer, 1024, "Ver 1\nBr %.6f\nIpg 1\nPpi %d\nBpiop %d\n"
"Pix 0\nCf %d\nCg %d\nSl %d\nnl16 %d\nVi 1\nf1 1\n", "Pix 0\nCf %d\nCg %d\nSl %d\nnl16 %d\nVi 1\nf1 1\n",
(float)st->codec->bit_rate, sc->p_per_gop, sc->b_per_i_or_p, (float)st->codecpar->bit_rate, sc->p_per_gop, sc->b_per_i_or_p,
st->codec->pix_fmt == AV_PIX_FMT_YUV422P ? 2 : 1, sc->first_gop_closed == 1, st->codecpar->format == AV_PIX_FMT_YUV422P ? 2 : 1, sc->first_gop_closed == 1,
starting_line, (st->codec->height + 15) / 16); starting_line, (st->codecpar->height + 15) / 16);
avio_w8(pb, TRACK_MPG_AUX); avio_w8(pb, TRACK_MPG_AUX);
avio_w8(pb, size + 1); avio_w8(pb, size + 1);
avio_write(pb, (uint8_t *)buffer, size + 1); avio_write(pb, (uint8_t *)buffer, size + 1);
@ -472,7 +472,7 @@ static int gxf_write_umf_media_mpeg(AVIOContext *pb, AVStream *st)
{ {
GXFStreamContext *sc = st->priv_data; GXFStreamContext *sc = st->priv_data;
if (st->codec->pix_fmt == AV_PIX_FMT_YUV422P) if (st->codecpar->format == AV_PIX_FMT_YUV422P)
avio_wl32(pb, 2); avio_wl32(pb, 2);
else else
avio_wl32(pb, 1); /* default to 420 */ avio_wl32(pb, 1); /* default to 420 */
@ -481,9 +481,9 @@ static int gxf_write_umf_media_mpeg(AVIOContext *pb, AVStream *st)
avio_wl32(pb, 1); /* I picture per GOP */ avio_wl32(pb, 1); /* I picture per GOP */
avio_wl32(pb, sc->p_per_gop); avio_wl32(pb, sc->p_per_gop);
avio_wl32(pb, sc->b_per_i_or_p); avio_wl32(pb, sc->b_per_i_or_p);
if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO)
avio_wl32(pb, 2); avio_wl32(pb, 2);
else if (st->codec->codec_id == AV_CODEC_ID_MPEG1VIDEO) else if (st->codecpar->codec_id == AV_CODEC_ID_MPEG1VIDEO)
avio_wl32(pb, 1); avio_wl32(pb, 1);
else else
avio_wl32(pb, 0); avio_wl32(pb, 0);
@ -565,7 +565,7 @@ static int gxf_write_umf_media_description(AVFormatContext *s)
gxf_write_umf_media_timecode(pb, sc); /* 8 0bytes */ gxf_write_umf_media_timecode(pb, sc); /* 8 0bytes */
else { else {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
switch (st->codec->codec_id) { switch (st->codecpar->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO: case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO: case AV_CODEC_ID_MPEG2VIDEO:
gxf_write_umf_media_mpeg(pb, st); gxf_write_umf_media_mpeg(pb, st);
@ -646,22 +646,22 @@ static int gxf_write_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->priv_data = sc; st->priv_data = sc;
sc->media_type = ff_codec_get_tag(gxf_media_types, st->codec->codec_id); sc->media_type = ff_codec_get_tag(gxf_media_types, st->codecpar->codec_id);
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if (st->codec->codec_id != AV_CODEC_ID_PCM_S16LE) { if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE) {
av_log(s, AV_LOG_ERROR, "only 16 BIT PCM LE allowed for now\n"); av_log(s, AV_LOG_ERROR, "only 16 BIT PCM LE allowed for now\n");
return -1; return -1;
} }
if (st->codec->sample_rate != 48000) { if (st->codecpar->sample_rate != 48000) {
av_log(s, AV_LOG_ERROR, "only 48000hz sampling rate is allowed\n"); av_log(s, AV_LOG_ERROR, "only 48000hz sampling rate is allowed\n");
return -1; return -1;
} }
if (st->codec->channels != 1) { if (st->codecpar->channels != 1) {
av_log(s, AV_LOG_ERROR, "only mono tracks are allowed\n"); av_log(s, AV_LOG_ERROR, "only mono tracks are allowed\n");
return -1; return -1;
} }
sc->track_type = 2; sc->track_type = 2;
sc->sample_rate = st->codec->sample_rate; sc->sample_rate = st->codecpar->sample_rate;
avpriv_set_pts_info(st, 64, 1, sc->sample_rate); avpriv_set_pts_info(st, 64, 1, sc->sample_rate);
sc->sample_size = 16; sc->sample_size = 16;
sc->frame_rate_index = -2; sc->frame_rate_index = -2;
@ -670,18 +670,18 @@ static int gxf_write_header(AVFormatContext *s)
gxf->audio_tracks++; gxf->audio_tracks++;
gxf->flags |= 0x04000000; /* audio is 16 bit pcm */ gxf->flags |= 0x04000000; /* audio is 16 bit pcm */
media_info = 'A'; media_info = 'A';
} else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (i != 0) { if (i != 0) {
av_log(s, AV_LOG_ERROR, "video stream must be the first track\n"); av_log(s, AV_LOG_ERROR, "video stream must be the first track\n");
return -1; return -1;
} }
/* FIXME check from time_base ? */ /* FIXME check from time_base ? */
if (st->codec->height == 480 || st->codec->height == 512) { /* NTSC or NTSC+VBI */ if (st->codecpar->height == 480 || st->codecpar->height == 512) { /* NTSC or NTSC+VBI */
sc->frame_rate_index = 5; sc->frame_rate_index = 5;
sc->sample_rate = 60; sc->sample_rate = 60;
gxf->flags |= 0x00000080; gxf->flags |= 0x00000080;
gxf->time_base = (AVRational){ 1001, 60000 }; gxf->time_base = (AVRational){ 1001, 60000 };
} else if (st->codec->height == 576 || st->codec->height == 608) { /* PAL or PAL+VBI */ } else if (st->codecpar->height == 576 || st->codecpar->height == 608) { /* PAL or PAL+VBI */
sc->frame_rate_index = 6; sc->frame_rate_index = 6;
sc->media_type++; sc->media_type++;
sc->sample_rate = 50; sc->sample_rate = 50;
@ -695,12 +695,12 @@ static int gxf_write_header(AVFormatContext *s)
avpriv_set_pts_info(st, 64, gxf->time_base.num, gxf->time_base.den); avpriv_set_pts_info(st, 64, gxf->time_base.num, gxf->time_base.den);
if (gxf_find_lines_index(st) < 0) if (gxf_find_lines_index(st) < 0)
sc->lines_index = -1; sc->lines_index = -1;
sc->sample_size = st->codec->bit_rate; sc->sample_size = st->codecpar->bit_rate;
sc->fields = 2; /* interlaced */ sc->fields = 2; /* interlaced */
vsc = sc; vsc = sc;
switch (st->codec->codec_id) { switch (st->codecpar->codec_id) {
case AV_CODEC_ID_MJPEG: case AV_CODEC_ID_MJPEG:
sc->track_type = 1; sc->track_type = 1;
gxf->flags |= 0x00004000; gxf->flags |= 0x00004000;
@ -719,7 +719,7 @@ static int gxf_write_header(AVFormatContext *s)
media_info = 'M'; media_info = 'M';
break; break;
case AV_CODEC_ID_DVVIDEO: case AV_CODEC_ID_DVVIDEO:
if (st->codec->pix_fmt == AV_PIX_FMT_YUV422P) { if (st->codecpar->format == AV_PIX_FMT_YUV422P) {
sc->media_type += 2; sc->media_type += 2;
sc->track_type = 6; sc->track_type = 6;
gxf->flags |= 0x00002000; gxf->flags |= 0x00002000;
@ -818,7 +818,7 @@ static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
/* If the video is frame-encoded, the frame numbers shall be represented by /* If the video is frame-encoded, the frame numbers shall be represented by
* even field numbers. * even field numbers.
* see SMPTE360M-2004 6.4.2.1.3 Media field number */ * see SMPTE360M-2004 6.4.2.1.3 Media field number */
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
field_nb = gxf->nb_fields; field_nb = gxf->nb_fields;
} else { } else {
field_nb = av_rescale_rnd(pkt->dts, gxf->time_base.den, field_nb = av_rescale_rnd(pkt->dts, gxf->time_base.den,
@ -828,10 +828,10 @@ static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
avio_w8(pb, sc->media_type); avio_w8(pb, sc->media_type);
avio_w8(pb, st->index); avio_w8(pb, st->index);
avio_wb32(pb, field_nb); avio_wb32(pb, field_nb);
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
avio_wb16(pb, 0); avio_wb16(pb, 0);
avio_wb16(pb, size / 2); avio_wb16(pb, size / 2);
} else if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) { } else if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size); int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size);
if (frame_type == AV_PICTURE_TYPE_I) { if (frame_type == AV_PICTURE_TYPE_I) {
avio_w8(pb, 0x0d); avio_w8(pb, 0x0d);
@ -844,7 +844,7 @@ static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
sc->pframes++; sc->pframes++;
} }
avio_wb24(pb, size); avio_wb24(pb, size);
} else if (st->codec->codec_id == AV_CODEC_ID_DVVIDEO) { } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
avio_w8(pb, size / 4096); avio_w8(pb, size / 4096);
avio_wb24(pb, 0); avio_wb24(pb, 0);
} else } else
@ -865,15 +865,15 @@ static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
int packet_start_offset = avio_tell(pb) / 1024; int packet_start_offset = avio_tell(pb) / 1024;
gxf_write_packet_header(pb, PKT_MEDIA); gxf_write_packet_header(pb, PKT_MEDIA);
if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */ if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
padding = 4 - pkt->size % 4; padding = 4 - pkt->size % 4;
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
padding = GXF_AUDIO_PACKET_SIZE - pkt->size; padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
gxf_write_media_preamble(s, pkt, pkt->size + padding); gxf_write_media_preamble(s, pkt, pkt->size + padding);
avio_write(pb, pkt->data, pkt->size); avio_write(pb, pkt->data, pkt->size);
gxf_write_padding(pb, padding); gxf_write_padding(pb, padding);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (!(gxf->flt_entries_nb % 500)) { if (!(gxf->flt_entries_nb % 500)) {
int err; int err;
if ((err = av_reallocp_array(&gxf->flt_entries, if ((err = av_reallocp_array(&gxf->flt_entries,
@ -909,7 +909,7 @@ static int gxf_compare_field_nb(AVFormatContext *s, AVPacket *next, AVPacket *cu
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
AVStream *st = s->streams[pkt[i]->stream_index]; AVStream *st = s->streams[pkt[i]->stream_index];
sc[i] = st->priv_data; sc[i] = st->priv_data;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
field_nb[i] = av_rescale_rnd(pkt[i]->dts, gxf->time_base.den, field_nb[i] = av_rescale_rnd(pkt[i]->dts, gxf->time_base.den,
(int64_t)48000*gxf->time_base.num, AV_ROUND_UP); (int64_t)48000*gxf->time_base.num, AV_ROUND_UP);
field_nb[i] &= ~1; // compare against even field number because audio must be before video field_nb[i] &= ~1; // compare against even field number because audio must be before video
@ -923,7 +923,7 @@ static int gxf_compare_field_nb(AVFormatContext *s, AVPacket *next, AVPacket *cu
static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush) static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
{ {
if (pkt && s->streams[pkt->stream_index]->codec->codec_type == AVMEDIA_TYPE_VIDEO) if (pkt && s->streams[pkt->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
pkt->duration = 2; // enforce 2 fields pkt->duration = 2; // enforce 2 fields
return ff_audio_rechunk_interleave(s, out, pkt, flush, return ff_audio_rechunk_interleave(s, out, pkt, flush,
ff_interleave_packet_per_dts, gxf_compare_field_nb); ff_interleave_packet_per_dts, gxf_compare_field_nb);

14
libavformat/hdsenc.c
Unescape View File

@ -338,18 +338,18 @@ static int hds_write_header(AVFormatContext *s)
AVFormatContext *ctx; AVFormatContext *ctx;
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
if (!st->codec->bit_rate) { if (!st->codecpar->bit_rate) {
av_log(s, AV_LOG_ERROR, "No bit rate set for stream %d\n", i); av_log(s, AV_LOG_ERROR, "No bit rate set for stream %d\n", i);
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto fail; goto fail;
} }
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (os->has_video) { if (os->has_video) {
c->nb_streams++; c->nb_streams++;
os++; os++;
} }
os->has_video = 1; os->has_video = 1;
} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if (os->has_audio) { if (os->has_audio) {
c->nb_streams++; c->nb_streams++;
os++; os++;
@ -360,7 +360,7 @@ static int hds_write_header(AVFormatContext *s)
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto fail; goto fail;
} }
os->bitrate += s->streams[i]->codec->bit_rate; os->bitrate += s->streams[i]->codecpar->bit_rate;
if (!os->ctx) { if (!os->ctx) {
os->first_stream = i; os->first_stream = i;
@ -389,8 +389,8 @@ static int hds_write_header(AVFormatContext *s)
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
} }
avcodec_copy_context(st->codec, s->streams[i]->codec); avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio; st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
st->time_base = s->streams[i]->time_base; st->time_base = s->streams[i]->time_base;
} }
@ -517,7 +517,7 @@ static int hds_write_packet(AVFormatContext *s, AVPacket *pkt)
if (st->first_dts == AV_NOPTS_VALUE) if (st->first_dts == AV_NOPTS_VALUE)
st->first_dts = pkt->dts; st->first_dts = pkt->dts;
if ((!os->has_video || st->codec->codec_type == AVMEDIA_TYPE_VIDEO) && if ((!os->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
av_compare_ts(pkt->dts - st->first_dts, st->time_base, av_compare_ts(pkt->dts - st->first_dts, st->time_base,
end_dts, AV_TIME_BASE_Q) >= 0 && end_dts, AV_TIME_BASE_Q) >= 0 &&
pkt->flags & AV_PKT_FLAG_KEY && os->packets_written) { pkt->flags & AV_PKT_FLAG_KEY && os->packets_written) {

2
libavformat/hls.c
Unescape View File

@ -617,7 +617,7 @@ static int hls_read_header(AVFormatContext *s)
ff_program_add_stream_index(s, i, stream_offset + j); ff_program_add_stream_index(s, i, stream_offset + j);
st->id = i; st->id = i;
avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den); avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
avcodec_copy_context(st->codec, v->ctx->streams[j]->codec); avcodec_parameters_copy(st->codecpar, v->ctx->streams[j]->codecpar);
if (v->bandwidth) if (v->bandwidth)
av_dict_set(&st->metadata, "variant_bitrate", bitrate_str, av_dict_set(&st->metadata, "variant_bitrate", bitrate_str,
0); 0);

6
libavformat/hlsenc.c
Unescape View File

@ -82,7 +82,7 @@ static int hls_mux_init(AVFormatContext *s)
AVStream *st; AVStream *st;
if (!(st = avformat_new_stream(oc, NULL))) if (!(st = avformat_new_stream(oc, NULL)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avcodec_copy_context(st->codec, s->streams[i]->codec); avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio; st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
st->time_base = s->streams[i]->time_base; st->time_base = s->streams[i]->time_base;
} }
@ -220,7 +220,7 @@ static int hls_write_header(AVFormatContext *s)
for (i = 0; i < s->nb_streams; i++) for (i = 0; i < s->nb_streams; i++)
hls->has_video += hls->has_video +=
s->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO; s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
if (hls->has_video > 1) if (hls->has_video > 1)
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
@ -284,7 +284,7 @@ static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
} }
if (hls->has_video) { if (hls->has_video) {
can_split = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && can_split = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
pkt->flags & AV_PKT_FLAG_KEY; pkt->flags & AV_PKT_FLAG_KEY;
} }
if (pkt->pts == AV_NOPTS_VALUE) if (pkt->pts == AV_NOPTS_VALUE)

18
libavformat/hnm.c
Unescape View File

@ -108,15 +108,15 @@ static int hnm_read_header(AVFormatContext *s)
if (!(vst = avformat_new_stream(s, NULL))) if (!(vst = avformat_new_stream(s, NULL)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_HNM4_VIDEO; vst->codecpar->codec_id = AV_CODEC_ID_HNM4_VIDEO;
vst->codec->codec_tag = 0; vst->codecpar->codec_tag = 0;
vst->codec->width = hnm->width; vst->codecpar->width = hnm->width;
vst->codec->height = hnm->height; vst->codecpar->height = hnm->height;
vst->codec->extradata = av_mallocz(1); vst->codecpar->extradata = av_mallocz(1);
vst->codec->extradata_size = 1; vst->codecpar->extradata_size = 1;
memcpy(vst->codec->extradata, &hnm->version, 1); memcpy(vst->codecpar->extradata, &hnm->version, 1);
vst->start_time = 0; vst->start_time = 0;

4
libavformat/id3v2.c
Unescape View File

@ -761,8 +761,8 @@ int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->disposition |= AV_DISPOSITION_ATTACHED_PIC; st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = apic->id; st->codecpar->codec_id = apic->id;
if (apic->description[0]) if (apic->description[0])
av_dict_set(&st->metadata, "title", apic->description, 0); av_dict_set(&st->metadata, "title", apic->description, 0);

2
libavformat/id3v2enc.c
Unescape View File

@ -171,7 +171,7 @@ int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt)
/* get the mimetype*/ /* get the mimetype*/
while (mime->id != AV_CODEC_ID_NONE) { while (mime->id != AV_CODEC_ID_NONE) {
if (mime->id == st->codec->codec_id) { if (mime->id == st->codecpar->codec_id) {
mimetype = mime->str; mimetype = mime->str;
break; break;
} }

38
libavformat/idcin.c
Unescape View File

@ -189,16 +189,16 @@ static int idcin_read_header(AVFormatContext *s)
avpriv_set_pts_info(st, 33, 1, IDCIN_FPS); avpriv_set_pts_info(st, 33, 1, IDCIN_FPS);
st->start_time = 0; st->start_time = 0;
idcin->video_stream_index = st->index; idcin->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_IDCIN; st->codecpar->codec_id = AV_CODEC_ID_IDCIN;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = width; st->codecpar->width = width;
st->codec->height = height; st->codecpar->height = height;
/* load up the Huffman tables into extradata */ /* load up the Huffman tables into extradata */
st->codec->extradata_size = HUFFMAN_TABLE_SIZE; st->codecpar->extradata_size = HUFFMAN_TABLE_SIZE;
st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE); st->codecpar->extradata = av_malloc(HUFFMAN_TABLE_SIZE);
ret = avio_read(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE); ret = avio_read(pb, st->codecpar->extradata, HUFFMAN_TABLE_SIZE);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} else if (ret != HUFFMAN_TABLE_SIZE) { } else if (ret != HUFFMAN_TABLE_SIZE) {
@ -214,19 +214,19 @@ static int idcin_read_header(AVFormatContext *s)
avpriv_set_pts_info(st, 63, 1, sample_rate); avpriv_set_pts_info(st, 63, 1, sample_rate);
st->start_time = 0; st->start_time = 0;
idcin->audio_stream_index = st->index; idcin->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_tag = 1; st->codecpar->codec_tag = 1;
st->codec->channels = channels; st->codecpar->channels = channels;
st->codec->channel_layout = channels > 1 ? AV_CH_LAYOUT_STEREO : st->codecpar->channel_layout = channels > 1 ? AV_CH_LAYOUT_STEREO :
AV_CH_LAYOUT_MONO; AV_CH_LAYOUT_MONO;
st->codec->sample_rate = sample_rate; st->codecpar->sample_rate = sample_rate;
st->codec->bits_per_coded_sample = bytes_per_sample * 8; st->codecpar->bits_per_coded_sample = bytes_per_sample * 8;
st->codec->bit_rate = sample_rate * bytes_per_sample * 8 * channels; st->codecpar->bit_rate = sample_rate * bytes_per_sample * 8 * channels;
st->codec->block_align = idcin->block_align = bytes_per_sample * channels; st->codecpar->block_align = idcin->block_align = bytes_per_sample * channels;
if (bytes_per_sample == 1) if (bytes_per_sample == 1)
st->codec->codec_id = AV_CODEC_ID_PCM_U8; st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
else else
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
if (sample_rate % 14 != 0) { if (sample_rate % 14 != 0) {
idcin->audio_chunk_size1 = (sample_rate / 14) * idcin->audio_chunk_size1 = (sample_rate / 14) *

36
libavformat/idroqdec.c
Unescape View File

@ -127,14 +127,14 @@ static int roq_read_packet(AVFormatContext *s,
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 63, 1, roq->frame_rate); avpriv_set_pts_info(st, 63, 1, roq->frame_rate);
roq->video_stream_index = st->index; roq->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_ROQ; st->codecpar->codec_id = AV_CODEC_ID_ROQ;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE) if (avio_read(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) != RoQ_CHUNK_PREAMBLE_SIZE)
return AVERROR(EIO); return AVERROR(EIO);
st->codec->width = roq->width = AV_RL16(preamble); st->codecpar->width = roq->width = AV_RL16(preamble);
st->codec->height = roq->height = AV_RL16(preamble + 2); st->codecpar->height = roq->height = AV_RL16(preamble + 2);
break; break;
} }
/* don't care about this chunk anymore */ /* don't care about this chunk anymore */
@ -175,22 +175,22 @@ static int roq_read_packet(AVFormatContext *s,
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 32, 1, RoQ_AUDIO_SAMPLE_RATE); avpriv_set_pts_info(st, 32, 1, RoQ_AUDIO_SAMPLE_RATE);
roq->audio_stream_index = st->index; roq->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ROQ_DPCM; st->codecpar->codec_id = AV_CODEC_ID_ROQ_DPCM;
st->codec->codec_tag = 0; /* no tag */ st->codecpar->codec_tag = 0; /* no tag */
if (chunk_type == RoQ_SOUND_STEREO) { if (chunk_type == RoQ_SOUND_STEREO) {
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
} else { } else {
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
} }
roq->audio_channels = st->codec->channels; roq->audio_channels = st->codecpar->channels;
st->codec->sample_rate = RoQ_AUDIO_SAMPLE_RATE; st->codecpar->sample_rate = RoQ_AUDIO_SAMPLE_RATE;
st->codec->bits_per_coded_sample = 16; st->codecpar->bits_per_coded_sample = 16;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codecpar->bit_rate = st->codecpar->channels * st->codecpar->sample_rate *
st->codec->bits_per_coded_sample; st->codecpar->bits_per_coded_sample;
st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; st->codecpar->block_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample;
} }
case RoQ_QUAD_VQ: case RoQ_QUAD_VQ:
if (chunk_type == RoQ_QUAD_VQ) { if (chunk_type == RoQ_QUAD_VQ) {

54
libavformat/iff.c
Unescape View File

@ -122,11 +122,11 @@ static int iff_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
avio_skip(pb, 8); avio_skip(pb, 8);
// codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content
st->codec->codec_tag = avio_rl32(pb); st->codecpar->codec_tag = avio_rl32(pb);
while(!pb->eof_reached) { while(!pb->eof_reached) {
uint64_t orig_pos; uint64_t orig_pos;
@ -138,12 +138,12 @@ static int iff_read_header(AVFormatContext *s)
switch(chunk_id) { switch(chunk_id) {
case ID_VHDR: case ID_VHDR:
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
if (data_size < 14) if (data_size < 14)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
avio_skip(pb, 12); avio_skip(pb, 12);
st->codec->sample_rate = avio_rb16(pb); st->codecpar->sample_rate = avio_rb16(pb);
if (data_size >= 16) { if (data_size >= 16) {
avio_skip(pb, 1); avio_skip(pb, 1);
compression = avio_r8(pb); compression = avio_r8(pb);
@ -159,11 +159,11 @@ static int iff_read_header(AVFormatContext *s)
if (data_size < 4) if (data_size < 4)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (avio_rb32(pb) < 6) { if (avio_rb32(pb) < 6) {
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
} else { } else {
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
} }
break; break;
@ -173,22 +173,22 @@ static int iff_read_header(AVFormatContext *s)
data_size); data_size);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->extradata_size = data_size; st->codecpar->extradata_size = data_size;
st->codec->extradata = av_malloc(data_size); st->codecpar->extradata = av_malloc(data_size);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (avio_read(pb, st->codec->extradata, data_size) < 0) if (avio_read(pb, st->codecpar->extradata, data_size) < 0)
return AVERROR(EIO); return AVERROR(EIO);
break; break;
case ID_BMHD: case ID_BMHD:
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
if (data_size <= 8) if (data_size <= 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->codec->width = avio_rb16(pb); st->codecpar->width = avio_rb16(pb);
st->codec->height = avio_rb16(pb); st->codecpar->height = avio_rb16(pb);
avio_skip(pb, 4); // x, y offset avio_skip(pb, 4); // x, y offset
st->codec->bits_per_coded_sample = avio_r8(pb); st->codecpar->bits_per_coded_sample = avio_r8(pb);
if (data_size >= 11) { if (data_size >= 11) {
avio_skip(pb, 1); // masking avio_skip(pb, 1); // masking
compression = avio_r8(pb); compression = avio_r8(pb);
@ -229,37 +229,37 @@ static int iff_read_header(AVFormatContext *s)
avio_seek(pb, iff->body_pos, SEEK_SET); avio_seek(pb, iff->body_pos, SEEK_SET);
switch(st->codec->codec_type) { switch(st->codecpar->codec_type) {
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
switch(compression) { switch(compression) {
case COMP_NONE: case COMP_NONE:
st->codec->codec_id = AV_CODEC_ID_PCM_S8_PLANAR; st->codecpar->codec_id = AV_CODEC_ID_PCM_S8_PLANAR;
break; break;
case COMP_FIB: case COMP_FIB:
st->codec->codec_id = AV_CODEC_ID_8SVX_FIB; st->codecpar->codec_id = AV_CODEC_ID_8SVX_FIB;
break; break;
case COMP_EXP: case COMP_EXP:
st->codec->codec_id = AV_CODEC_ID_8SVX_EXP; st->codecpar->codec_id = AV_CODEC_ID_8SVX_EXP;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, "unknown compression method\n"); av_log(s, AV_LOG_ERROR, "unknown compression method\n");
return -1; return -1;
} }
st->codec->bits_per_coded_sample = 8; st->codecpar->bits_per_coded_sample = 8;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codec->bits_per_coded_sample; st->codecpar->bit_rate = st->codecpar->channels * st->codecpar->sample_rate * st->codecpar->bits_per_coded_sample;
st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; st->codecpar->block_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample;
break; break;
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
switch (compression) { switch (compression) {
case BITMAP_RAW: case BITMAP_RAW:
st->codec->codec_id = AV_CODEC_ID_IFF_ILBM; st->codecpar->codec_id = AV_CODEC_ID_IFF_ILBM;
break; break;
case BITMAP_BYTERUN1: case BITMAP_BYTERUN1:
st->codec->codec_id = AV_CODEC_ID_IFF_BYTERUN1; st->codecpar->codec_id = AV_CODEC_ID_IFF_BYTERUN1;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, "unknown compression method\n"); av_log(s, AV_LOG_ERROR, "unknown compression method\n");

36
libavformat/ilbc.c
Unescape View File

@ -28,22 +28,22 @@ static const char mode30_header[] = "#!iLBC30\n";
static int ilbc_write_header(AVFormatContext *s) static int ilbc_write_header(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc; AVCodecParameters *par;
if (s->nb_streams != 1) { if (s->nb_streams != 1) {
av_log(s, AV_LOG_ERROR, "Unsupported number of streams\n"); av_log(s, AV_LOG_ERROR, "Unsupported number of streams\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
enc = s->streams[0]->codec; par = s->streams[0]->codecpar;
if (enc->codec_id != AV_CODEC_ID_ILBC) { if (par->codec_id != AV_CODEC_ID_ILBC) {
av_log(s, AV_LOG_ERROR, "Unsupported codec\n"); av_log(s, AV_LOG_ERROR, "Unsupported codec\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (enc->block_align == 50) { if (par->block_align == 50) {
avio_write(pb, mode30_header, sizeof(mode30_header) - 1); avio_write(pb, mode30_header, sizeof(mode30_header) - 1);
} else if (enc->block_align == 38) { } else if (par->block_align == 38) {
avio_write(pb, mode20_header, sizeof(mode20_header) - 1); avio_write(pb, mode20_header, sizeof(mode20_header) - 1);
} else { } else {
av_log(s, AV_LOG_ERROR, "Unsupported mode\n"); av_log(s, AV_LOG_ERROR, "Unsupported mode\n");
@ -79,18 +79,18 @@ static int ilbc_read_header(AVFormatContext *s)
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_ILBC; st->codecpar->codec_id = AV_CODEC_ID_ILBC;
st->codec->sample_rate = 8000; st->codecpar->sample_rate = 8000;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->start_time = 0; st->start_time = 0;
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
if (!memcmp(header, mode20_header, sizeof(mode20_header) - 1)) { if (!memcmp(header, mode20_header, sizeof(mode20_header) - 1)) {
st->codec->block_align = 38; st->codecpar->block_align = 38;
st->codec->bit_rate = 15200; st->codecpar->bit_rate = 15200;
} else if (!memcmp(header, mode30_header, sizeof(mode30_header) - 1)) { } else if (!memcmp(header, mode30_header, sizeof(mode30_header) - 1)) {
st->codec->block_align = 50; st->codecpar->block_align = 50;
st->codec->bit_rate = 13333; st->codecpar->bit_rate = 13333;
} else { } else {
av_log(s, AV_LOG_ERROR, "Unrecognized iLBC file header\n"); av_log(s, AV_LOG_ERROR, "Unrecognized iLBC file header\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -102,16 +102,16 @@ static int ilbc_read_header(AVFormatContext *s)
static int ilbc_read_packet(AVFormatContext *s, static int ilbc_read_packet(AVFormatContext *s,
AVPacket *pkt) AVPacket *pkt)
{ {
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
int ret; int ret;
if ((ret = av_new_packet(pkt, enc->block_align)) < 0) if ((ret = av_new_packet(pkt, par->block_align)) < 0)
return ret; return ret;
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->pos = avio_tell(s->pb); pkt->pos = avio_tell(s->pb);
pkt->duration = enc->block_align == 38 ? 160 : 240; pkt->duration = par->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, par->block_align)) != par->block_align) {
av_packet_unref(pkt); av_packet_unref(pkt);
return ret < 0 ? ret : AVERROR(EIO); return ret < 0 ? ret : AVERROR(EIO);
} }

28
libavformat/img2dec.c
Unescape View File

@ -184,8 +184,8 @@ static int img_read_header(AVFormatContext *s1)
avpriv_set_pts_info(st, 60, framerate.den, framerate.num); avpriv_set_pts_info(st, 60, framerate.den, framerate.num);
if (width && height) { if (width && height) {
st->codec->width = width; st->codecpar->width = width;
st->codec->height = height; st->codecpar->height = height;
} }
if (!s->is_pipe) { if (!s->is_pipe) {
@ -201,18 +201,18 @@ static int img_read_header(AVFormatContext *s1)
} }
if (s1->video_codec_id) { if (s1->video_codec_id) {
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = s1->video_codec_id; st->codecpar->codec_id = s1->video_codec_id;
} else if (s1->audio_codec_id) { } else if (s1->audio_codec_id) {
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s1->audio_codec_id; st->codecpar->codec_id = s1->audio_codec_id;
} else { } else {
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = ff_guess_image2_codec(s->path); st->codecpar->codec_id = ff_guess_image2_codec(s->path);
} }
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
pix_fmt != AV_PIX_FMT_NONE) pix_fmt != AV_PIX_FMT_NONE)
st->codec->pix_fmt = pix_fmt; st->codecpar->format = pix_fmt;
return 0; return 0;
} }
@ -224,7 +224,7 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
int i, res; int i, res;
int size[3] = { 0 }, ret[3] = { 0 }; int size[3] = { 0 }, ret[3] = { 0 };
AVIOContext *f[3] = { NULL }; AVIOContext *f[3] = { NULL };
AVCodecContext *codec = s1->streams[0]->codec; AVCodecParameters *par = s1->streams[0]->codecpar;
if (!s->is_pipe) { if (!s->is_pipe) {
/* loop over input */ /* loop over input */
@ -247,13 +247,13 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
} }
size[i] = avio_size(f[i]); size[i] = avio_size(f[i]);
if (codec->codec_id != AV_CODEC_ID_RAWVIDEO) if (par->codec_id != AV_CODEC_ID_RAWVIDEO)
break; break;
filename[strlen(filename) - 1] = 'U' + i; filename[strlen(filename) - 1] = 'U' + i;
} }
if (codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width) if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->width)
infer_size(&codec->width, &codec->height, size[0]); infer_size(&par->width, &par->height, size[0]);
} else { } else {
f[0] = s1->pb; f[0] = s1->pb;
if (f[0]->eof_reached) if (f[0]->eof_reached)

16
libavformat/img2enc.c
Unescape View File

@ -58,7 +58,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
VideoMuxData *img = s->priv_data; VideoMuxData *img = s->priv_data;
AVIOContext *pb[3]; AVIOContext *pb[3];
char filename[1024]; char filename[1024];
AVCodecContext *codec = s->streams[pkt->stream_index]->codec; AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
int i; int i;
if (!img->is_pipe) { if (!img->is_pipe) {
@ -77,7 +77,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR(EIO); return AVERROR(EIO);
} }
if (codec->codec_id != AV_CODEC_ID_RAWVIDEO) if (par->codec_id != AV_CODEC_ID_RAWVIDEO)
break; break;
filename[strlen(filename) - 1] = 'U' + i; filename[strlen(filename) - 1] = 'U' + i;
} }
@ -85,8 +85,8 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
pb[0] = s->pb; pb[0] = s->pb;
} }
if (codec->codec_id == AV_CODEC_ID_RAWVIDEO) { if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
int ysize = codec->width * codec->height; int ysize = par->width * par->height;
avio_write(pb[0], pkt->data, ysize); avio_write(pb[0], pkt->data, ysize);
avio_write(pb[1], pkt->data + ysize, (pkt->size - ysize) / 2); avio_write(pb[1], pkt->data + ysize, (pkt->size - ysize) / 2);
avio_write(pb[2], pkt->data + ysize + (pkt->size - ysize) / 2, (pkt->size - ysize) / 2); avio_write(pb[2], pkt->data + ysize + (pkt->size - ysize) / 2, (pkt->size - ysize) / 2);
@ -95,8 +95,8 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
} else { } else {
if (ff_guess_image2_codec(s->filename) == AV_CODEC_ID_JPEG2000) { if (ff_guess_image2_codec(s->filename) == AV_CODEC_ID_JPEG2000) {
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
if (st->codec->extradata_size > 8 && if (st->codecpar->extradata_size > 8 &&
AV_RL32(st->codec->extradata + 4) == MKTAG('j', 'p', '2', 'h')) { AV_RL32(st->codecpar->extradata + 4) == MKTAG('j', 'p', '2', 'h')) {
if (pkt->size < 8 || if (pkt->size < 8 ||
AV_RL32(pkt->data + 4) != MKTAG('j', 'p', '2', 'c')) AV_RL32(pkt->data + 4) != MKTAG('j', 'p', '2', 'c'))
goto error; goto error;
@ -108,9 +108,9 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
ffio_wfourcc(pb[0], "jp2 "); ffio_wfourcc(pb[0], "jp2 ");
avio_wb32(pb[0], 0); avio_wb32(pb[0], 0);
ffio_wfourcc(pb[0], "jp2 "); ffio_wfourcc(pb[0], "jp2 ");
avio_write(pb[0], st->codec->extradata, st->codec->extradata_size); avio_write(pb[0], st->codecpar->extradata, st->codecpar->extradata_size);
} else if (pkt->size < 8 || } else if (pkt->size < 8 ||
(!st->codec->extradata_size && (!st->codecpar->extradata_size &&
AV_RL32(pkt->data + 4) != MKTAG('j', 'P', ' ', ' '))) { // signature AV_RL32(pkt->data + 4) != MKTAG('j', 'P', ' ', ' '))) { // signature
error: error:
av_log(s, AV_LOG_ERROR, "malformed JPEG 2000 codestream\n"); av_log(s, AV_LOG_ERROR, "malformed JPEG 2000 codestream\n");

16
libavformat/internal.h
Unescape View File

@ -102,6 +102,22 @@ struct AVStreamInternal {
* from dts. * from dts.
*/ */
int reorder; int reorder;
/**
* The codec context used by avformat_find_stream_info, the parser, etc.
*/
AVCodecContext *avctx;
/**
* 1 if avctx has been initialized with the values from the codec parameters
*/
int avctx_inited;
enum AVCodecID orig_codec_id;
#if FF_API_LAVF_AVCTX
// whether the deprecated stream codec context needs
// to be filled from the codec parameters
int need_codec_update;
#endif
}; };
void ff_dynarray_add(intptr_t **tab_ptr, int *nb_ptr, intptr_t elem); void ff_dynarray_add(intptr_t **tab_ptr, int *nb_ptr, intptr_t elem);

38
libavformat/ipmovie.c
Unescape View File

@ -584,12 +584,12 @@ static int ipmovie_read_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 63, 1, 1000000); avpriv_set_pts_info(st, 63, 1, 1000000);
ipmovie->video_stream_index = st->index; ipmovie->video_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_INTERPLAY_VIDEO; st->codecpar->codec_id = AV_CODEC_ID_INTERPLAY_VIDEO;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = ipmovie->video_width; st->codecpar->width = ipmovie->video_width;
st->codec->height = ipmovie->video_height; st->codecpar->height = ipmovie->video_height;
st->codec->bits_per_coded_sample = ipmovie->video_bpp; st->codecpar->bits_per_coded_sample = ipmovie->video_bpp;
if (ipmovie->audio_type) { if (ipmovie->audio_type) {
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
@ -597,19 +597,19 @@ static int ipmovie_read_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 32, 1, ipmovie->audio_sample_rate); avpriv_set_pts_info(st, 32, 1, ipmovie->audio_sample_rate);
ipmovie->audio_stream_index = st->index; ipmovie->audio_stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ipmovie->audio_type; st->codecpar->codec_id = ipmovie->audio_type;
st->codec->codec_tag = 0; /* no tag */ st->codecpar->codec_tag = 0; /* no tag */
st->codec->channels = ipmovie->audio_channels; st->codecpar->channels = ipmovie->audio_channels;
st->codec->channel_layout = st->codec->channels == 1 ? AV_CH_LAYOUT_MONO : st->codecpar->channel_layout = st->codecpar->channels == 1 ? AV_CH_LAYOUT_MONO :
AV_CH_LAYOUT_STEREO; AV_CH_LAYOUT_STEREO;
st->codec->sample_rate = ipmovie->audio_sample_rate; st->codecpar->sample_rate = ipmovie->audio_sample_rate;
st->codec->bits_per_coded_sample = ipmovie->audio_bits; st->codecpar->bits_per_coded_sample = ipmovie->audio_bits;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codecpar->bit_rate = st->codecpar->channels * st->codecpar->sample_rate *
st->codec->bits_per_coded_sample; st->codecpar->bits_per_coded_sample;
if (st->codec->codec_id == AV_CODEC_ID_INTERPLAY_DPCM) if (st->codecpar->codec_id == AV_CODEC_ID_INTERPLAY_DPCM)
st->codec->bit_rate /= 2; st->codecpar->bit_rate /= 2;
st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; st->codecpar->block_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample;
} }
return 0; return 0;

32
libavformat/isom.c
Unescape View File

@ -449,37 +449,37 @@ int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext
avio_rb32(pb); /* max bitrate */ avio_rb32(pb); /* max bitrate */
avio_rb32(pb); /* avg bitrate */ avio_rb32(pb); /* avg bitrate */
st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id); st->codecpar->codec_id = ff_codec_get_id(ff_mp4_obj_type, object_type_id);
av_log(fc, AV_LOG_TRACE, "esds object type id 0x%02x\n", object_type_id); av_log(fc, AV_LOG_TRACE, "esds object type id 0x%02x\n", object_type_id);
len = ff_mp4_read_descr(fc, pb, &tag); len = ff_mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecSpecificDescrTag) { if (tag == MP4DecSpecificDescrTag) {
av_log(fc, AV_LOG_TRACE, "Specific MPEG4 header len=%d\n", len); av_log(fc, AV_LOG_TRACE, "Specific MPEG4 header len=%d\n", len);
if (!len || (uint64_t)len > (1<<30)) if (!len || (uint64_t)len > (1<<30))
return -1; return -1;
av_free(st->codec->extradata); av_free(st->codecpar->extradata);
st->codec->extradata = av_mallocz(len + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_mallocz(len + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_read(pb, st->codec->extradata, len); avio_read(pb, st->codecpar->extradata, len);
st->codec->extradata_size = len; st->codecpar->extradata_size = len;
if (st->codec->codec_id == AV_CODEC_ID_AAC) { if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
MPEG4AudioConfig cfg; MPEG4AudioConfig cfg;
avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata, avpriv_mpeg4audio_get_config(&cfg, st->codecpar->extradata,
st->codec->extradata_size * 8, 1); st->codecpar->extradata_size * 8, 1);
st->codec->channels = cfg.channels; st->codecpar->channels = cfg.channels;
if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4 if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
st->codec->sample_rate = avpriv_mpa_freq_tab[cfg.sampling_index]; st->codecpar->sample_rate = avpriv_mpa_freq_tab[cfg.sampling_index];
else if (cfg.ext_sample_rate) else if (cfg.ext_sample_rate)
st->codec->sample_rate = cfg.ext_sample_rate; st->codecpar->sample_rate = cfg.ext_sample_rate;
else else
st->codec->sample_rate = cfg.sample_rate; st->codecpar->sample_rate = cfg.sample_rate;
av_log(fc, AV_LOG_TRACE, "mp4a config channels %d obj %d ext obj %d " av_log(fc, AV_LOG_TRACE, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels, "sample rate %d ext sample rate %d\n", st->codecpar->channels,
cfg.object_type, cfg.ext_object_type, cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate); cfg.sample_rate, cfg.ext_sample_rate);
if (!(st->codec->codec_id = ff_codec_get_id(mp4_audio_types, if (!(st->codecpar->codec_id = ff_codec_get_id(mp4_audio_types,
cfg.object_type))) cfg.object_type)))
st->codec->codec_id = AV_CODEC_ID_AAC; st->codecpar->codec_id = AV_CODEC_ID_AAC;
} }
} }
return 0; return 0;

30
libavformat/iss.c
Unescape View File

@ -93,23 +93,23 @@ static av_cold int iss_read_header(AVFormatContext *s)
st = avformat_new_stream(s, NULL); st = avformat_new_stream(s, NULL);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_ISS; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_IMA_ISS;
if (stereo) { if (stereo) {
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
} else { } else {
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->channel_layout = AV_CH_LAYOUT_MONO; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
} }
st->codec->sample_rate = 44100; st->codecpar->sample_rate = 44100;
if(rate_divisor > 0) if(rate_divisor > 0)
st->codec->sample_rate /= rate_divisor; st->codecpar->sample_rate /= rate_divisor;
st->codec->bits_per_coded_sample = 4; st->codecpar->bits_per_coded_sample = 4;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate st->codecpar->bit_rate = st->codecpar->channels * st->codecpar->sample_rate
* st->codec->bits_per_coded_sample; * st->codecpar->bits_per_coded_sample;
st->codec->block_align = iss->packet_size; st->codecpar->block_align = iss->packet_size;
avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
return 0; return 0;
} }
@ -124,8 +124,8 @@ static int iss_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->pts = avio_tell(s->pb) - iss->sample_start_pos; pkt->pts = avio_tell(s->pb) - iss->sample_start_pos;
if(s->streams[0]->codec->channels > 0) if(s->streams[0]->codecpar->channels > 0)
pkt->pts /= s->streams[0]->codec->channels*2; pkt->pts /= s->streams[0]->codecpar->channels*2;
return 0; return 0;
} }

4
libavformat/iv8.c
Unescape View File

@ -45,8 +45,8 @@ static int read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MPEG4; st->codecpar->codec_id = AV_CODEC_ID_MPEG4;
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
avpriv_set_pts_info(st, 64, 1, 90000); avpriv_set_pts_info(st, 64, 1, 90000);

10
libavformat/ivfdec.c
Unescape View File

@ -46,11 +46,11 @@ static int read_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_tag = avio_rl32(s->pb); st->codecpar->codec_tag = avio_rl32(s->pb);
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codec->codec_tag); st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codecpar->codec_tag);
st->codec->width = avio_rl16(s->pb); st->codecpar->width = avio_rl16(s->pb);
st->codec->height = avio_rl16(s->pb); st->codecpar->height = avio_rl16(s->pb);
time_base.den = avio_rl32(s->pb); time_base.den = avio_rl32(s->pb);
time_base.num = avio_rl32(s->pb); time_base.num = avio_rl32(s->pb);
st->duration = avio_rl64(s->pb); st->duration = avio_rl64(s->pb);

12
libavformat/ivfenc.c
Unescape View File

@ -22,24 +22,24 @@
static int ivf_write_header(AVFormatContext *s) static int ivf_write_header(AVFormatContext *s)
{ {
AVCodecContext *ctx; AVCodecParameters *par;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
if (s->nb_streams != 1) { if (s->nb_streams != 1) {
av_log(s, AV_LOG_ERROR, "Format supports only exactly one video stream\n"); av_log(s, AV_LOG_ERROR, "Format supports only exactly one video stream\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
ctx = s->streams[0]->codec; par = s->streams[0]->codecpar;
if (ctx->codec_type != AVMEDIA_TYPE_VIDEO || ctx->codec_id != AV_CODEC_ID_VP8) { if (par->codec_type != AVMEDIA_TYPE_VIDEO || par->codec_id != AV_CODEC_ID_VP8) {
av_log(s, AV_LOG_ERROR, "Currently only VP8 is supported!\n"); av_log(s, AV_LOG_ERROR, "Currently only VP8 is supported!\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
avio_write(pb, "DKIF", 4); avio_write(pb, "DKIF", 4);
avio_wl16(pb, 0); // version avio_wl16(pb, 0); // version
avio_wl16(pb, 32); // header length avio_wl16(pb, 32); // header length
avio_wl32(pb, ctx->codec_tag ? ctx->codec_tag : AV_RL32("VP80")); avio_wl32(pb, par->codec_tag ? par->codec_tag : AV_RL32("VP80"));
avio_wl16(pb, ctx->width); avio_wl16(pb, par->width);
avio_wl16(pb, ctx->height); avio_wl16(pb, par->height);
avio_wl32(pb, s->streams[0]->time_base.den); avio_wl32(pb, s->streams[0]->time_base.den);
avio_wl32(pb, s->streams[0]->time_base.num); avio_wl32(pb, s->streams[0]->time_base.num);
avio_wl64(pb, s->streams[0]->duration); // TODO: duration or number of frames?!? avio_wl64(pb, s->streams[0]->duration); // TODO: duration or number of frames?!?

24
libavformat/jvdec.c
Unescape View File

@ -85,11 +85,11 @@ static int read_header(AVFormatContext *s)
if (!ast || !vst) if (!ast || !vst)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codec->codec_id = AV_CODEC_ID_JV; vst->codecpar->codec_id = AV_CODEC_ID_JV;
vst->codec->codec_tag = 0; /* no fourcc */ vst->codecpar->codec_tag = 0; /* no fourcc */
vst->codec->width = avio_rl16(pb); vst->codecpar->width = avio_rl16(pb);
vst->codec->height = avio_rl16(pb); vst->codecpar->height = avio_rl16(pb);
vst->duration = vst->duration =
vst->nb_frames = vst->nb_frames =
ast->nb_index_entries = avio_rl16(pb); ast->nb_index_entries = avio_rl16(pb);
@ -97,13 +97,13 @@ static int read_header(AVFormatContext *s)
avio_skip(pb, 4); avio_skip(pb, 4);
ast->codec->codec_type = AVMEDIA_TYPE_AUDIO; ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
ast->codec->codec_id = AV_CODEC_ID_PCM_U8; ast->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
ast->codec->codec_tag = 0; /* no fourcc */ ast->codecpar->codec_tag = 0; /* no fourcc */
ast->codec->sample_rate = avio_rl16(pb); ast->codecpar->sample_rate = avio_rl16(pb);
ast->codec->channels = 1; ast->codecpar->channels = 1;
ast->codec->channel_layout = AV_CH_LAYOUT_MONO; ast->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
avpriv_set_pts_info(ast, 64, 1, ast->codec->sample_rate); avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
avio_skip(pb, 10); avio_skip(pb, 10);

16
libavformat/latmenc.c
Unescape View File

@ -74,10 +74,10 @@ static int latm_decode_extradata(LATMContext *ctx, uint8_t *buf, int size)
static int latm_write_header(AVFormatContext *s) static int latm_write_header(AVFormatContext *s)
{ {
LATMContext *ctx = s->priv_data; LATMContext *ctx = s->priv_data;
AVCodecContext *avctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if (avctx->extradata_size > 0 && if (par->extradata_size > 0 &&
latm_decode_extradata(ctx, avctx->extradata, avctx->extradata_size) < 0) latm_decode_extradata(ctx, par->extradata, par->extradata_size) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
return 0; return 0;
@ -86,7 +86,7 @@ static int latm_write_header(AVFormatContext *s)
static int latm_write_frame_header(AVFormatContext *s, PutBitContext *bs) static int latm_write_frame_header(AVFormatContext *s, PutBitContext *bs)
{ {
LATMContext *ctx = s->priv_data; LATMContext *ctx = s->priv_data;
AVCodecContext *avctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
GetBitContext gb; GetBitContext gb;
int header_size; int header_size;
@ -94,7 +94,7 @@ static int latm_write_frame_header(AVFormatContext *s, PutBitContext *bs)
put_bits(bs, 1, !!ctx->counter); put_bits(bs, 1, !!ctx->counter);
if (!ctx->counter) { if (!ctx->counter) {
init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8); init_get_bits(&gb, par->extradata, par->extradata_size * 8);
/* StreamMuxConfig */ /* StreamMuxConfig */
put_bits(bs, 1, 0); /* audioMuxVersion */ put_bits(bs, 1, 0); /* audioMuxVersion */
@ -105,10 +105,10 @@ static int latm_write_frame_header(AVFormatContext *s, PutBitContext *bs)
/* AudioSpecificConfig */ /* AudioSpecificConfig */
if (ctx->object_type == AOT_ALS) { if (ctx->object_type == AOT_ALS) {
header_size = avctx->extradata_size-(ctx->off + 7) >> 3; header_size = par->extradata_size-(ctx->off + 7) >> 3;
avpriv_copy_bits(bs, &avctx->extradata[ctx->off], header_size); avpriv_copy_bits(bs, &par->extradata[ctx->off], header_size);
} else { } else {
avpriv_copy_bits(bs, avctx->extradata, ctx->off + 3); avpriv_copy_bits(bs, par->extradata, ctx->off + 3);
if (!ctx->channel_conf) { if (!ctx->channel_conf) {
avpriv_copy_pce_data(bs, &gb); avpriv_copy_pce_data(bs, &gb);

8
libavformat/lmlm4.c
Unescape View File

@ -65,15 +65,15 @@ static int lmlm4_read_header(AVFormatContext *s)
if (!(st = avformat_new_stream(s, NULL))) if (!(st = avformat_new_stream(s, NULL)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MPEG4; st->codecpar->codec_id = AV_CODEC_ID_MPEG4;
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
avpriv_set_pts_info(st, 64, 1001, 30000); avpriv_set_pts_info(st, 64, 1001, 30000);
if (!(st = avformat_new_stream(s, NULL))) if (!(st = avformat_new_stream(s, NULL)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = AV_CODEC_ID_MP2; st->codecpar->codec_id = AV_CODEC_ID_MP2;
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
/* the parameters will be extracted from the compressed bitstream */ /* the parameters will be extracted from the compressed bitstream */

32
libavformat/lxfdec.c
Unescape View File

@ -177,25 +177,25 @@ static int get_packet_header(AVFormatContext *s)
//set codec based on specified audio bitdepth //set codec based on specified audio bitdepth
//we only support tightly packed 16-, 20-, 24- and 32-bit PCM at the moment //we only support tightly packed 16-, 20-, 24- and 32-bit PCM at the moment
st->codec->bits_per_coded_sample = (audio_format >> 6) & 0x3F; st->codecpar->bits_per_coded_sample = (audio_format >> 6) & 0x3F;
if (st->codec->bits_per_coded_sample != (audio_format & 0x3F)) { if (st->codecpar->bits_per_coded_sample != (audio_format & 0x3F)) {
av_log(s, AV_LOG_WARNING, "only tightly packed PCM currently supported\n"); av_log(s, AV_LOG_WARNING, "only tightly packed PCM currently supported\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
switch (st->codec->bits_per_coded_sample) { switch (st->codecpar->bits_per_coded_sample) {
case 16: st->codec->codec_id = AV_CODEC_ID_PCM_S16LE_PLANAR; break; case 16: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE_PLANAR; break;
case 20: st->codec->codec_id = AV_CODEC_ID_PCM_LXF; break; case 20: st->codecpar->codec_id = AV_CODEC_ID_PCM_LXF; break;
case 24: st->codec->codec_id = AV_CODEC_ID_PCM_S24LE_PLANAR; break; case 24: st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE_PLANAR; break;
case 32: st->codec->codec_id = AV_CODEC_ID_PCM_S32LE_PLANAR; break; case 32: st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE_PLANAR; break;
default: default:
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
"only 16-, 20-, 24- and 32-bit PCM currently supported\n"); "only 16-, 20-, 24- and 32-bit PCM currently supported\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
samples = track_size * 8 / st->codec->bits_per_coded_sample; samples = track_size * 8 / st->codecpar->bits_per_coded_sample;
//use audio packet size to determine video standard //use audio packet size to determine video standard
//for NTSC we have one 8008-sample audio frame per five video frames //for NTSC we have one 8008-sample audio frame per five video frames
@ -256,10 +256,10 @@ static int lxf_read_header(AVFormatContext *s)
expiration_date = AV_RL16(&header_data[58]); expiration_date = AV_RL16(&header_data[58]);
disk_params = AV_RL32(&header_data[116]); disk_params = AV_RL32(&header_data[116]);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->bit_rate = 1000000 * ((video_params >> 14) & 0xFF); st->codecpar->bit_rate = 1000000 * ((video_params >> 14) & 0xFF);
st->codec->codec_tag = video_params & 0xF; st->codecpar->codec_tag = video_params & 0xF;
st->codec->codec_id = ff_codec_get_id(lxf_tags, st->codec->codec_tag); st->codecpar->codec_id = ff_codec_get_id(lxf_tags, st->codecpar->codec_tag);
av_log(s, AV_LOG_DEBUG, "record: %x = %i-%02i-%02i\n", av_log(s, AV_LOG_DEBUG, "record: %x = %i-%02i-%02i\n",
record_date, 1900 + (record_date & 0x7F), (record_date >> 7) & 0xF, record_date, 1900 + (record_date & 0x7F), (record_date >> 7) & 0xF,
@ -276,11 +276,11 @@ static int lxf_read_header(AVFormatContext *s)
if (!(st = avformat_new_stream(s, NULL))) if (!(st = avformat_new_stream(s, NULL)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->sample_rate = LXF_SAMPLERATE; st->codecpar->sample_rate = LXF_SAMPLERATE;
st->codec->channels = lxf->channels; st->codecpar->channels = lxf->channels;
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
} }
avio_skip(s->pb, lxf->extended_size); avio_skip(s->pb, lxf->extended_size);

118
libavformat/matroskadec.c
Unescape View File

@ -1513,7 +1513,7 @@ static int matroska_parse_flac(AVFormatContext *s,
av_log(s, AV_LOG_WARNING, av_log(s, AV_LOG_WARNING,
"Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n"); "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
} else } else
st->codec->channel_layout = mask; st->codecpar->channel_layout = mask;
} }
av_dict_free(&dict); av_dict_free(&dict);
} }
@ -1653,10 +1653,10 @@ static int matroska_parse_tracks(AVFormatContext *s)
ffio_init_context(&b, track->codec_priv.data, ffio_init_context(&b, track->codec_priv.data,
track->codec_priv.size, track->codec_priv.size,
0, NULL, NULL, NULL, NULL); 0, NULL, NULL, NULL, NULL);
ret = ff_get_wav_header(s, &b, st->codec, track->codec_priv.size); ret = ff_get_wav_header(s, &b, st->codecpar, track->codec_priv.size);
if (ret < 0) if (ret < 0)
return ret; return ret;
codec_id = st->codec->codec_id; codec_id = st->codecpar->codec_id;
extradata_offset = FFMIN(track->codec_priv.size, 18); extradata_offset = FFMIN(track->codec_priv.size, 18);
} else if (!strcmp(track->codec_id, "V_QUICKTIME") && } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
(track->codec_priv.size >= 86) && (track->codec_priv.size >= 86) &&
@ -1775,15 +1775,15 @@ static int matroska_parse_tracks(AVFormatContext *s)
if (!track->audio.buf) if (!track->audio.buf)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (codec_id == AV_CODEC_ID_RA_288) { if (codec_id == AV_CODEC_ID_RA_288) {
st->codec->block_align = track->audio.coded_framesize; st->codecpar->block_align = track->audio.coded_framesize;
track->codec_priv.size = 0; track->codec_priv.size = 0;
} else { } else {
if (codec_id == AV_CODEC_ID_SIPR && flavor < 4) { if (codec_id == AV_CODEC_ID_SIPR && flavor < 4) {
const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 }; const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
track->audio.sub_packet_size = ff_sipr_subpk_size[flavor]; track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
st->codec->bit_rate = sipr_bit_rate[flavor]; st->codecpar->bit_rate = sipr_bit_rate[flavor];
} }
st->codec->block_align = track->audio.sub_packet_size; st->codecpar->block_align = track->audio.sub_packet_size;
extradata_offset = 78; extradata_offset = 78;
} }
} else if (codec_id == AV_CODEC_ID_FLAC && track->codec_priv.size) { } else if (codec_id == AV_CODEC_ID_FLAC && track->codec_priv.size) {
@ -1807,7 +1807,7 @@ static int matroska_parse_tracks(AVFormatContext *s)
(AVRational){ 1, 1000000000 }, (AVRational){ 1, 1000000000 },
st->time_base); st->time_base);
st->codec->codec_id = codec_id; st->codecpar->codec_id = codec_id;
st->start_time = 0; st->start_time = 0;
if (strcmp(track->language, "und")) if (strcmp(track->language, "und"))
av_dict_set(&st->metadata, "language", track->language, 0); av_dict_set(&st->metadata, "language", track->language, 0);
@ -1818,17 +1818,17 @@ static int matroska_parse_tracks(AVFormatContext *s)
if (track->flag_forced) if (track->flag_forced)
st->disposition |= AV_DISPOSITION_FORCED; st->disposition |= AV_DISPOSITION_FORCED;
if (!st->codec->extradata) { if (!st->codecpar->extradata) {
if (extradata) { if (extradata) {
st->codec->extradata = extradata; st->codecpar->extradata = extradata;
st->codec->extradata_size = extradata_size; st->codecpar->extradata_size = extradata_size;
} else if (track->codec_priv.data && track->codec_priv.size > 0) { } else if (track->codec_priv.data && track->codec_priv.size > 0) {
st->codec->extradata = av_mallocz(track->codec_priv.size + st->codecpar->extradata = av_mallocz(track->codec_priv.size +
AV_INPUT_BUFFER_PADDING_SIZE); AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = track->codec_priv.size; st->codecpar->extradata_size = track->codec_priv.size;
memcpy(st->codec->extradata, memcpy(st->codecpar->extradata,
track->codec_priv.data + extradata_offset, track->codec_priv.data + extradata_offset,
track->codec_priv.size); track->codec_priv.size);
} }
@ -1838,21 +1838,21 @@ static int matroska_parse_tracks(AVFormatContext *s)
int display_width_mul = 1; int display_width_mul = 1;
int display_height_mul = 1; int display_height_mul = 1;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_tag = track->video.fourcc; st->codecpar->codec_tag = track->video.fourcc;
st->codec->width = track->video.pixel_width; st->codecpar->width = track->video.pixel_width;
st->codec->height = track->video.pixel_height; st->codecpar->height = track->video.pixel_height;
if (track->video.stereo_mode && track->video.stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB) if (track->video.stereo_mode && track->video.stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
mkv_stereo_mode_display_mul(track->video.stereo_mode, &display_width_mul, &display_height_mul); mkv_stereo_mode_display_mul(track->video.stereo_mode, &display_width_mul, &display_height_mul);
av_reduce(&st->sample_aspect_ratio.num, av_reduce(&st->sample_aspect_ratio.num,
&st->sample_aspect_ratio.den, &st->sample_aspect_ratio.den,
st->codec->height * track->video.display_width * display_width_mul, st->codecpar->height * track->video.display_width * display_width_mul,
st->codec->width * track->video.display_height * display_height_mul, st->codecpar->width * track->video.display_height * display_height_mul,
255); 255);
if (st->codec->codec_id != AV_CODEC_ID_H264 && if (st->codecpar->codec_id != AV_CODEC_ID_H264 &&
st->codec->codec_id != AV_CODEC_ID_HEVC) st->codecpar->codec_id != AV_CODEC_ID_HEVC)
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
if (track->default_duration) { if (track->default_duration) {
av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den, av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
@ -1866,16 +1866,16 @@ static int matroska_parse_tracks(AVFormatContext *s)
return ret; return ret;
} }
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) { } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->sample_rate = track->audio.out_samplerate; st->codecpar->sample_rate = track->audio.out_samplerate;
st->codec->channels = track->audio.channels; st->codecpar->channels = track->audio.channels;
if (st->codec->codec_id != AV_CODEC_ID_AAC) if (st->codecpar->codec_id != AV_CODEC_ID_AAC)
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
if (st->codec->codec_id == AV_CODEC_ID_MP3) if (st->codecpar->codec_id == AV_CODEC_ID_MP3)
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) { } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
if (st->codec->codec_id == AV_CODEC_ID_SSA) if (st->codecpar->codec_id == AV_CODEC_ID_SSA)
matroska->contains_ssa = 1; matroska->contains_ssa = 1;
} }
} }
@ -1961,21 +1961,21 @@ static int matroska_read_header(AVFormatContext *s)
break; break;
av_dict_set(&st->metadata, "filename", attachments[j].filename, 0); av_dict_set(&st->metadata, "filename", attachments[j].filename, 0);
av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0); av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0);
st->codec->codec_id = AV_CODEC_ID_NONE; st->codecpar->codec_id = AV_CODEC_ID_NONE;
for (i = 0; ff_mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++) { for (i = 0; ff_mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
if (!strncmp(ff_mkv_image_mime_tags[i].str, attachments[j].mime, if (!strncmp(ff_mkv_image_mime_tags[i].str, attachments[j].mime,
strlen(ff_mkv_image_mime_tags[i].str))) { strlen(ff_mkv_image_mime_tags[i].str))) {
st->codec->codec_id = ff_mkv_image_mime_tags[i].id; st->codecpar->codec_id = ff_mkv_image_mime_tags[i].id;
break; break;
} }
} }
attachments[j].stream = st; attachments[j].stream = st;
if (st->codec->codec_id != AV_CODEC_ID_NONE) { if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
st->disposition |= AV_DISPOSITION_ATTACHED_PIC; st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
av_init_packet(&st->attached_pic); av_init_packet(&st->attached_pic);
if ((res = av_new_packet(&st->attached_pic, attachments[j].bin.size)) < 0) if ((res = av_new_packet(&st->attached_pic, attachments[j].bin.size)) < 0)
@ -1984,19 +1984,19 @@ static int matroska_read_header(AVFormatContext *s)
st->attached_pic.stream_index = st->index; st->attached_pic.stream_index = st->index;
st->attached_pic.flags |= AV_PKT_FLAG_KEY; st->attached_pic.flags |= AV_PKT_FLAG_KEY;
} else { } else {
st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT; st->codecpar->codec_type = AVMEDIA_TYPE_ATTACHMENT;
st->codec->extradata = av_malloc(attachments[j].bin.size); st->codecpar->extradata = av_malloc(attachments[j].bin.size);
if (!st->codec->extradata) if (!st->codecpar->extradata)
break; break;
st->codec->extradata_size = attachments[j].bin.size; st->codecpar->extradata_size = attachments[j].bin.size;
memcpy(st->codec->extradata, attachments[j].bin.data, memcpy(st->codecpar->extradata, attachments[j].bin.data,
attachments[j].bin.size); attachments[j].bin.size);
for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) { for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
if (!strncmp(ff_mkv_mime_tags[i].str, attachments[j].mime, if (!strncmp(ff_mkv_mime_tags[i].str, attachments[j].mime,
strlen(ff_mkv_mime_tags[i].str))) { strlen(ff_mkv_mime_tags[i].str))) {
st->codec->codec_id = ff_mkv_mime_tags[i].id; st->codecpar->codec_id = ff_mkv_mime_tags[i].id;
break; break;
} }
} }
@ -2184,7 +2184,7 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
uint8_t *data, int size, uint64_t timecode, uint8_t *data, int size, uint64_t timecode,
uint64_t duration, int64_t pos) uint64_t duration, int64_t pos)
{ {
int a = st->codec->block_align; int a = st->codecpar->block_align;
int sps = track->audio.sub_packet_size; int sps = track->audio.sub_packet_size;
int cfs = track->audio.coded_framesize; int cfs = track->audio.coded_framesize;
int h = track->audio.sub_packet_h; int h = track->audio.sub_packet_h;
@ -2195,7 +2195,7 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
if (!track->audio.pkt_cnt) { if (!track->audio.pkt_cnt) {
if (track->audio.sub_packet_cnt == 0) if (track->audio.sub_packet_cnt == 0)
track->audio.buf_timecode = timecode; track->audio.buf_timecode = timecode;
if (st->codec->codec_id == AV_CODEC_ID_RA_288) { if (st->codecpar->codec_id == AV_CODEC_ID_RA_288) {
if (size < cfs * h / 2) { if (size < cfs * h / 2) {
av_log(matroska->ctx, AV_LOG_ERROR, av_log(matroska->ctx, AV_LOG_ERROR,
"Corrupt int4 RM-style audio packet size\n"); "Corrupt int4 RM-style audio packet size\n");
@ -2204,7 +2204,7 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
for (x = 0; x < h / 2; x++) for (x = 0; x < h / 2; x++)
memcpy(track->audio.buf + x * 2 * w + y * cfs, memcpy(track->audio.buf + x * 2 * w + y * cfs,
data + x * cfs, cfs); data + x * cfs, cfs);
} else if (st->codec->codec_id == AV_CODEC_ID_SIPR) { } else if (st->codecpar->codec_id == AV_CODEC_ID_SIPR) {
if (size < w) { if (size < w) {
av_log(matroska->ctx, AV_LOG_ERROR, av_log(matroska->ctx, AV_LOG_ERROR,
"Corrupt sipr RM-style audio packet size\n"); "Corrupt sipr RM-style audio packet size\n");
@ -2224,7 +2224,7 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
} }
if (++track->audio.sub_packet_cnt >= h) { if (++track->audio.sub_packet_cnt >= h) {
if (st->codec->codec_id == AV_CODEC_ID_SIPR) if (st->codecpar->codec_id == AV_CODEC_ID_SIPR)
ff_rm_reorder_sipr_data(track->audio.buf, h, w); ff_rm_reorder_sipr_data(track->audio.buf, h, w);
track->audio.sub_packet_cnt = 0; track->audio.sub_packet_cnt = 0;
track->audio.pkt_cnt = h * w / a; track->audio.pkt_cnt = h * w / a;
@ -2266,10 +2266,10 @@ static int matroska_parse_wavpack(MatroskaTrack *track, uint8_t *src,
uint16_t ver; uint16_t ver;
int ret, offset = 0; int ret, offset = 0;
if (srclen < 12 || track->stream->codec->extradata_size < 2) if (srclen < 12 || track->stream->codecpar->extradata_size < 2)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ver = AV_RL16(track->stream->codec->extradata); ver = AV_RL16(track->stream->codecpar->extradata);
samples = AV_RL32(src); samples = AV_RL32(src);
src += 4; src += 4;
@ -2353,7 +2353,7 @@ static int matroska_parse_frame(MatroskaDemuxContext *matroska,
return res; return res;
} }
if (st->codec->codec_id == AV_CODEC_ID_WAVPACK) { if (st->codecpar->codec_id == AV_CODEC_ID_WAVPACK) {
uint8_t *wv_data; uint8_t *wv_data;
res = matroska_parse_wavpack(track, pkt_data, &wv_data, &pkt_size); res = matroska_parse_wavpack(track, pkt_data, &wv_data, &pkt_size);
if (res < 0) { if (res < 0) {
@ -2366,7 +2366,7 @@ static int matroska_parse_frame(MatroskaDemuxContext *matroska,
pkt_data = wv_data; pkt_data = wv_data;
} }
if (st->codec->codec_id == AV_CODEC_ID_PRORES) if (st->codecpar->codec_id == AV_CODEC_ID_PRORES)
offset = 8; offset = 8;
pkt = av_mallocz(sizeof(AVPacket)); pkt = av_mallocz(sizeof(AVPacket));
@ -2381,7 +2381,7 @@ static int matroska_parse_frame(MatroskaDemuxContext *matroska,
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (st->codec->codec_id == AV_CODEC_ID_PRORES) { if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
uint8_t *buf = pkt->data; uint8_t *buf = pkt->data;
bytestream_put_be32(&buf, pkt_size); bytestream_put_be32(&buf, pkt_size);
bytestream_put_be32(&buf, MKBETAG('i', 'c', 'p', 'f')); bytestream_put_be32(&buf, MKBETAG('i', 'c', 'p', 'f'));
@ -2400,23 +2400,23 @@ static int matroska_parse_frame(MatroskaDemuxContext *matroska,
else else
pkt->pts = timecode; pkt->pts = timecode;
pkt->pos = pos; pkt->pos = pos;
if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE || st->codec->codec_id == AV_CODEC_ID_TEXT) if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE || st->codecpar->codec_id == AV_CODEC_ID_TEXT)
pkt->duration = duration; pkt->duration = duration;
#if FF_API_CONVERGENCE_DURATION #if FF_API_CONVERGENCE_DURATION
FF_DISABLE_DEPRECATION_WARNINGS FF_DISABLE_DEPRECATION_WARNINGS
if (st->codec->codec_id == AV_CODEC_ID_TEXT) if (st->codecpar->codec_id == AV_CODEC_ID_TEXT)
pkt->convergence_duration = duration; pkt->convergence_duration = duration;
FF_ENABLE_DEPRECATION_WARNINGS FF_ENABLE_DEPRECATION_WARNINGS
#endif #endif
if (st->codec->codec_id == AV_CODEC_ID_SSA) if (st->codecpar->codec_id == AV_CODEC_ID_SSA)
matroska_fix_ass_packet(matroska, pkt, duration); matroska_fix_ass_packet(matroska, pkt, duration);
if (matroska->prev_pkt && if (matroska->prev_pkt &&
timecode != AV_NOPTS_VALUE && timecode != AV_NOPTS_VALUE &&
matroska->prev_pkt->pts == timecode && matroska->prev_pkt->pts == timecode &&
matroska->prev_pkt->stream_index == st->index && matroska->prev_pkt->stream_index == st->index &&
st->codec->codec_id == AV_CODEC_ID_SSA) st->codecpar->codec_id == AV_CODEC_ID_SSA)
matroska_merge_packets(matroska->prev_pkt, pkt); matroska_merge_packets(matroska->prev_pkt, pkt);
else { else {
dynarray_add(&matroska->packets, &matroska->num_packets, pkt); dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
@ -2510,11 +2510,11 @@ static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
FFMAX(track->end_timecode, timecode + block_duration); FFMAX(track->end_timecode, timecode + block_duration);
for (n = 0; n < laces; n++) { for (n = 0; n < laces; n++) {
if ((st->codec->codec_id == AV_CODEC_ID_RA_288 || if ((st->codecpar->codec_id == AV_CODEC_ID_RA_288 ||
st->codec->codec_id == AV_CODEC_ID_COOK || st->codecpar->codec_id == AV_CODEC_ID_COOK ||
st->codec->codec_id == AV_CODEC_ID_SIPR || st->codecpar->codec_id == AV_CODEC_ID_SIPR ||
st->codec->codec_id == AV_CODEC_ID_ATRAC3) && st->codecpar->codec_id == AV_CODEC_ID_ATRAC3) &&
st->codec->block_align && track->audio.sub_packet_size) { st->codecpar->block_align && track->audio.sub_packet_size) {
res = matroska_parse_rm_audio(matroska, track, st, data, res = matroska_parse_rm_audio(matroska, track, st, data,
lace_size[n], lace_size[n],
timecode, duration, pos); timecode, duration, pos);

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save