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

Merge commit '9200514ad8717c63f82101dc394f4378854325bf'

Browse Source 
* commit '9200514ad8717c63f82101dc394f4378854325bf':
  lavf: replace AVStream.codec with AVStream.codecpar

This has been a HUGE effort from:
    - Derek Buitenhuis <derek.buitenhuis@gmail.com>
    - Hendrik Leppkes <h.leppkes@gmail.com>
    - wm4 <nfxjfg@googlemail.com>
    - Clément Bœsch <clement@stupeflix.com>
    - James Almer <jamrial@gmail.com>
    - Michael Niedermayer <michael@niedermayer.cc>
    - Rostislav Pehlivanov <atomnuker@gmail.com>

Merged-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>
pull/200/head
Derek Buitenhuis 9 years ago
parent 60b75186b2 9200514ad8
commit 6f69f7a8bf
362 changed files with 6555 additions and 6079 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. 9
      ffmpeg.c
  2. 4
      ffserver.c
  3. 2
      libavdevice/alsa.c
  4. 10
      libavdevice/alsa_dec.c
  5. 14
      libavdevice/alsa_enc.c
  6. 14
      libavdevice/bktr.c
  7. 49
      libavdevice/dshow.c
  8. 16
      libavdevice/fbdev_dec.c
  9. 12
      libavdevice/fbdev_enc.c
  10. 9
      libavdevice/gdigrab.c
  11. 10
      libavdevice/jack.c
  12. 32
      libavdevice/lavfi.c
  13. 12
      libavdevice/libcdio.c
  14. 15
      libavdevice/libdc1394.c
  15. 12
      libavdevice/openal-dec.c
  16. 16
      libavdevice/opengl_enc.c
  17. 8
      libavdevice/oss_dec.c
  18. 4
      libavdevice/oss_enc.c
  19. 8
      libavdevice/pulse_audio_dec.c
  20. 25
      libavdevice/pulse_audio_enc.c
  21. 32
      libavdevice/sdl.c
  22. 8
      libavdevice/sndio_dec.c
  23. 4
      libavdevice/sndio_enc.c
  24. 22
      libavdevice/v4l2.c
  25. 18
      libavdevice/v4l2enc.c
  26. 35
      libavdevice/vfwcap.c
  27. 17
      libavdevice/x11grab.c
  28. 11
      libavdevice/xcbgrab.c
  29. 38
      libavdevice/xv.c
  30. 20
      libavformat/3dostr.c
  31. 44
      libavformat/4xm.c
  32. 10
      libavformat/a64.c
  33. 6
      libavformat/aacdec.c
  34. 22
      libavformat/aadec.c
  35. 20
      libavformat/acm.c
  36. 22
      libavformat/act.c
  37. 14
      libavformat/adp.c
  38. 28
      libavformat/ads.c
  39. 8
      libavformat/adtsenc.c
  40. 30
      libavformat/adxdec.c
  41. 20
      libavformat/aea.c
  42. 16
      libavformat/afc.c
  43. 90
      libavformat/aiffdec.c
  44. 50
      libavformat/aiffenc.c
  45. 12
      libavformat/aixdec.c
  46. 36
      libavformat/amr.c
  47. 18
      libavformat/anm.c
  48. 24
      libavformat/apc.c
  49. 20
      libavformat/ape.c
  50. 8
      libavformat/apetag.c
  51. 66
      libavformat/apngdec.c
  52. 18
      libavformat/apngenc.c
  53. 4
      libavformat/aqtitledec.c
  54. 72
      libavformat/asfdec_f.c
  55. 30
      libavformat/asfdec_o.c
  56. 82
      libavformat/asfenc.c
  57. 6
      libavformat/assdec.c
  58. 22
      libavformat/assenc.c
  59. 26
      libavformat/astdec.c
  60. 22
      libavformat/astenc.c
  61. 30
      libavformat/au.c
  62. 12
      libavformat/audiointerleave.c
  63. 24
      libavformat/avformat.h
  64. 179
      libavformat/avidec.c
  65. 160
      libavformat/avienc.c
  66. 60
      libavformat/avisynth.c
  67. 18
      libavformat/avr.c
  68. 12
      libavformat/avs.c
  69. 24
      libavformat/bethsoftvid.c
  70. 42
      libavformat/bfi.c
  71. 40
      libavformat/bink.c
  72. 86
      libavformat/bintext.c
  73. 18
      libavformat/bit.c
  74. 20
      libavformat/bmv.c
  75. 12
      libavformat/boadec.c
  76. 60
      libavformat/brstm.c
  77. 10
      libavformat/c93.c
  78. 64
      libavformat/cafdec.c
  79. 50
      libavformat/cafenc.c
  80. 4
      libavformat/cdg.c
  81. 26
      libavformat/cdxl.c
  82. 6
      libavformat/chromaprint.c
  83. 34
      libavformat/cinedec.c
  84. 70
      libavformat/concatdec.c
  85. 62
      libavformat/dashenc.c
  86. 18
      libavformat/dauddec.c
  87. 4
      libavformat/daudenc.c
  88. 22
      libavformat/dcstr.c
  89. 12
      libavformat/dfa.c
  90. 22
      libavformat/dsfdec.c
  91. 26
      libavformat/dsicin.c
  92. 20
      libavformat/dss.c
  93. 6
      libavformat/dtshddec.c
  94. 47
      libavformat/dump.c
  95. 28
      libavformat/dv.c
  96. 47
      libavformat/dvenc.c
  97. 20
      libavformat/dxa.c
  98. 12
      libavformat/eacdata.c
  99. 34
      libavformat/electronicarts.c
  100. 16
      libavformat/epafdec.c
  101. Some files were not shown because too many files have changed in this diff Show More

9
ffmpeg.c
Unescape View File

@ -696,6 +696,15 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
} }
if (pkt->size == 0 && pkt->side_data_elems == 0) if (pkt->size == 0 && pkt->side_data_elems == 0)
return; return;
if (!ost->st->codecpar->extradata && avctx->extradata) {
ost->st->codecpar->extradata = av_malloc(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!ost->st->codecpar->extradata) {
av_log(NULL, AV_LOG_ERROR, "Could not allocate extradata buffer to copy parser data.\n");
exit_program(1);
}
ost->st->codecpar->extradata_size = avctx->extradata_size;
memcpy(ost->st->codecpar->extradata, avctx->extradata, avctx->extradata_size);
}
if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) { if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
if (pkt->dts != AV_NOPTS_VALUE && if (pkt->dts != AV_NOPTS_VALUE &&

4
ffserver.c
Unescape View File

@ -2996,6 +2996,8 @@ static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
for(i = 0; i < stream->nb_streams; i++) { for(i = 0; i < stream->nb_streams; i++) {
avc->streams[i] = &avs[i]; avc->streams[i] = &avs[i];
avc->streams[i]->codec = stream->streams[i]->codec; avc->streams[i]->codec = stream->streams[i]->codec;
avcodec_parameters_from_context(stream->streams[i]->codecpar, stream->streams[i]->codec);
avc->streams[i]->codecpar = stream->streams[i]->codecpar;
} }
*pbuffer = av_mallocz(2048); *pbuffer = av_mallocz(2048);
if (!*pbuffer) if (!*pbuffer)
@ -3536,6 +3538,8 @@ static AVStream *add_av_stream1(FFServerStream *stream,
fst->priv_data = av_mallocz(sizeof(FeedData)); fst->priv_data = av_mallocz(sizeof(FeedData));
fst->internal = av_mallocz(sizeof(*fst->internal)); fst->internal = av_mallocz(sizeof(*fst->internal));
fst->internal->avctx = avcodec_alloc_context3(NULL);
fst->codecpar = avcodec_parameters_alloc();
fst->index = stream->nb_streams; fst->index = stream->nb_streams;
avpriv_set_pts_info(fst, 33, 1, 90000); avpriv_set_pts_info(fst, 33, 1, 90000);
fst->sample_aspect_ratio = codec->sample_aspect_ratio; fst->sample_aspect_ratio = codec->sample_aspect_ratio;

2
libavdevice/alsa.c
Unescape View File

@ -175,7 +175,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;

10
libavdevice/alsa_dec.c
Unescape View File

@ -79,11 +79,11 @@ 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;
st->codec->frame_size = s->frame_size; st->codecpar->frame_size = s->frame_size;
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 */
/* microseconds instead of seconds, MHz instead of Hz */ /* microseconds instead of seconds, MHz instead of Hz */
s->timefilter = ff_timefilter_new(1000000.0 / s->sample_rate, s->timefilter = ff_timefilter_new(1000000.0 / s->sample_rate,

14
libavdevice/alsa_enc.c
Unescape View File

@ -55,20 +55,20 @@ static av_cold int audio_write_header(AVFormatContext *s1)
enum AVCodecID codec_id; enum AVCodecID codec_id;
int res; int res;
if (s1->nb_streams != 1 || s1->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO) { if (s1->nb_streams != 1 || s1->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
av_log(s1, AV_LOG_ERROR, "Only a single audio stream is supported.\n"); av_log(s1, AV_LOG_ERROR, "Only a single audio stream is supported.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
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;
} }
avpriv_set_pts_info(st, 64, 1, sample_rate); avpriv_set_pts_info(st, 64, 1, sample_rate);
@ -124,7 +124,7 @@ static int audio_write_frame(AVFormatContext *s1, int stream_index,
/* ff_alsa_open() should have accepted only supported formats */ /* ff_alsa_open() should have accepted only supported formats */
if ((flags & AV_WRITE_UNCODED_FRAME_QUERY)) if ((flags & AV_WRITE_UNCODED_FRAME_QUERY))
return av_sample_fmt_is_planar(s1->streams[stream_index]->codec->sample_fmt) ? return av_sample_fmt_is_planar(s1->streams[stream_index]->codecpar->format) ?
AVERROR(EINVAL) : 0; AVERROR(EINVAL) : 0;
/* set only used fields */ /* set only used fields */
pkt.data = (*frame)->data[0]; pkt.data = (*frame)->data[0];

14
libavdevice/bktr.c
Unescape View File

@ -286,14 +286,12 @@ static int grab_read_header(AVFormatContext *s1)
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 = s->width; st->codecpar->width = s->width;
st->codec->height = s->height; st->codecpar->height = s->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, s->width, s->height, s->standard, if (bktr_init(s1->filename, s->width, s->height, s->standard,
&s->video_fd, &s->tuner_fd, -1, 0.0) < 0) { &s->video_fd, &s->tuner_fd, -1, 0.0) < 0) {

49
libavdevice/dshow.c
Unescape View File

@ -918,7 +918,7 @@ dshow_add_device(AVFormatContext *avctx,
{ {
struct dshow_ctx *ctx = avctx->priv_data; struct dshow_ctx *ctx = avctx->priv_data;
AM_MEDIA_TYPE type; AM_MEDIA_TYPE type;
AVCodecContext *codec; AVCodecParameters *par;
AVStream *st; AVStream *st;
int ret = AVERROR(EIO); int ret = AVERROR(EIO);
@ -933,7 +933,7 @@ dshow_add_device(AVFormatContext *avctx,
libAVPin_ConnectionMediaType(ctx->capture_pin[devtype], &type); libAVPin_ConnectionMediaType(ctx->capture_pin[devtype], &type);
codec = st->codec; par = st->codecpar;
if (devtype == VideoDevice) { if (devtype == VideoDevice) {
BITMAPINFOHEADER *bih = NULL; BITMAPINFOHEADER *bih = NULL;
AVRational time_base; AVRational time_base;
@ -952,33 +952,34 @@ dshow_add_device(AVFormatContext *avctx,
goto error; goto error;
} }
codec->time_base = time_base; st->avg_frame_rate = av_inv_q(time_base);
codec->codec_type = AVMEDIA_TYPE_VIDEO;
codec->width = bih->biWidth; par->codec_type = AVMEDIA_TYPE_VIDEO;
codec->height = bih->biHeight; par->width = bih->biWidth;
codec->codec_tag = bih->biCompression; par->height = bih->biHeight;
codec->pix_fmt = dshow_pixfmt(bih->biCompression, bih->biBitCount); par->codec_tag = bih->biCompression;
par->format = dshow_pixfmt(bih->biCompression, bih->biBitCount);
if (bih->biCompression == MKTAG('H', 'D', 'Y', 'C')) { if (bih->biCompression == MKTAG('H', 'D', 'Y', 'C')) {
av_log(avctx, AV_LOG_DEBUG, "attempt to use full range for HDYC...\n"); av_log(avctx, AV_LOG_DEBUG, "attempt to use full range for HDYC...\n");
codec->color_range = AVCOL_RANGE_MPEG; // just in case it needs this... par->color_range = AVCOL_RANGE_MPEG; // just in case it needs this...
} }
if (codec->pix_fmt == AV_PIX_FMT_NONE) { if (par->format == AV_PIX_FMT_NONE) {
const AVCodecTag *const tags[] = { avformat_get_riff_video_tags(), NULL }; const AVCodecTag *const tags[] = { avformat_get_riff_video_tags(), NULL };
codec->codec_id = av_codec_get_id(tags, bih->biCompression); par->codec_id = av_codec_get_id(tags, bih->biCompression);
if (codec->codec_id == AV_CODEC_ID_NONE) { if (par->codec_id == AV_CODEC_ID_NONE) {
av_log(avctx, AV_LOG_ERROR, "Unknown compression type. " av_log(avctx, AV_LOG_ERROR, "Unknown compression type. "
"Please report type 0x%X.\n", (int) bih->biCompression); "Please report type 0x%X.\n", (int) bih->biCompression);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
codec->bits_per_coded_sample = bih->biBitCount; par->bits_per_coded_sample = bih->biBitCount;
} else { } else {
codec->codec_id = AV_CODEC_ID_RAWVIDEO; par->codec_id = AV_CODEC_ID_RAWVIDEO;
if (bih->biCompression == BI_RGB || bih->biCompression == BI_BITFIELDS) { if (bih->biCompression == BI_RGB || bih->biCompression == BI_BITFIELDS) {
codec->bits_per_coded_sample = bih->biBitCount; par->bits_per_coded_sample = bih->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);
} }
} }
} }
@ -993,11 +994,11 @@ dshow_add_device(AVFormatContext *avctx,
goto error; goto error;
} }
codec->codec_type = AVMEDIA_TYPE_AUDIO; par->codec_type = AVMEDIA_TYPE_AUDIO;
codec->sample_fmt = sample_fmt_bits_per_sample(fx->wBitsPerSample); par->format = sample_fmt_bits_per_sample(fx->wBitsPerSample);
codec->codec_id = waveform_codec_id(codec->sample_fmt); par->codec_id = waveform_codec_id(par->format);
codec->sample_rate = fx->nSamplesPerSec; par->sample_rate = fx->nSamplesPerSec;
codec->channels = fx->nChannels; par->channels = fx->nChannels;
} }
avpriv_set_pts_info(st, 64, 1, 10000000); avpriv_set_pts_info(st, 64, 1, 10000000);

16
libavdevice/fbdev_dec.c
Unescape View File

@ -126,13 +126,13 @@ 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 = av_inv_q(fbdev->framerate_q); st->avg_frame_rate = fbdev->framerate_q;
st->codec->bit_rate = st->codecpar->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;
av_log(avctx, AV_LOG_INFO, av_log(avctx, AV_LOG_INFO,
@ -140,7 +140,7 @@ static av_cold int fbdev_read_header(AVFormatContext *avctx)
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,
(int64_t)st->codec->bit_rate); (int64_t)st->codecpar->bit_rate);
return 0; return 0;
fail: fail:

12
libavdevice/fbdev_enc.c
Unescape View File

@ -48,7 +48,7 @@ static av_cold int fbdev_write_header(AVFormatContext *h)
int ret, flags = O_RDWR; int ret, flags = O_RDWR;
const char* device; const char* device;
if (h->nb_streams != 1 || h->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO) { if (h->nb_streams != 1 || h->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
av_log(fbdev, AV_LOG_ERROR, "Only a single video stream is supported.\n"); av_log(fbdev, AV_LOG_ERROR, "Only a single video stream is supported.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -105,11 +105,11 @@ static int fbdev_write_packet(AVFormatContext *h, AVPacket *pkt)
enum AVPixelFormat fb_pix_fmt; enum AVPixelFormat fb_pix_fmt;
int disp_height; int disp_height;
int bytes_to_copy; int bytes_to_copy;
AVCodecContext *codec_ctx = h->streams[0]->codec; AVCodecParameters *par = h->streams[0]->codecpar;
enum AVPixelFormat video_pix_fmt = codec_ctx->pix_fmt; enum AVPixelFormat video_pix_fmt = par->format;
int video_width = codec_ctx->width; int video_width = par->width;
int video_height = codec_ctx->height; int video_height = par->height;
int bytes_per_pixel = ((codec_ctx->bits_per_coded_sample + 7) >> 3); int bytes_per_pixel = ((par->bits_per_coded_sample + 7) >> 3);
int src_line_size = video_width * bytes_per_pixel; int src_line_size = video_width * bytes_per_pixel;
int i; int i;

9
libavdevice/gdigrab.c
Unescape View File

@ -403,10 +403,11 @@ gdigrab_read_header(AVFormatContext *s1)
} }
} }
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->avg_frame_rate = av_inv_q(gdigrab->time_base);
st->codec->codec_id = AV_CODEC_ID_BMP;
st->codec->time_base = gdigrab->time_base; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->bit_rate = (gdigrab->header_size + gdigrab->frame_size) * 1/av_q2d(gdigrab->time_base) * 8; st->codecpar->codec_id = AV_CODEC_ID_BMP;
st->codecpar->bit_rate = (gdigrab->header_size + gdigrab->frame_size) * 1/av_q2d(gdigrab->time_base) * 8;
return 0; return 0;

10
libavdevice/jack.c
Unescape View File

@ -262,14 +262,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;

32
libavdevice/lavfi.c
Unescape View File

@ -108,8 +108,8 @@ static int create_subcc_streams(AVFormatContext *avctx)
lavfi->sink_stream_subcc_map[sink_idx] = avctx->nb_streams; lavfi->sink_stream_subcc_map[sink_idx] = avctx->nb_streams;
if (!(st = avformat_new_stream(avctx, NULL))) if (!(st = avformat_new_stream(avctx, NULL)))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_EIA_608; st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
} else { } else {
lavfi->sink_stream_subcc_map[sink_idx] = -1; lavfi->sink_stream_subcc_map[sink_idx] = -1;
} }
@ -314,28 +314,28 @@ av_cold static int lavfi_read_header(AVFormatContext *avctx)
for (i = 0; i < lavfi->nb_sinks; i++) { for (i = 0; i < lavfi->nb_sinks; i++) {
AVFilterLink *link = lavfi->sinks[lavfi->stream_sink_map[i]]->inputs[0]; AVFilterLink *link = lavfi->sinks[lavfi->stream_sink_map[i]]->inputs[0];
AVStream *st = avctx->streams[i]; AVStream *st = avctx->streams[i];
st->codec->codec_type = link->type; st->codecpar->codec_type = link->type;
avpriv_set_pts_info(st, 64, link->time_base.num, link->time_base.den); avpriv_set_pts_info(st, 64, link->time_base.num, link->time_base.den);
if (link->type == AVMEDIA_TYPE_VIDEO) { if (link->type == AVMEDIA_TYPE_VIDEO) {
st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->pix_fmt = link->format; st->codecpar->format = link->format;
st->codec->time_base = link->time_base; st->avg_frame_rate = av_inv_q(link->time_base);
st->codec->width = link->w; st->codecpar->width = link->w;
st->codec->height = link->h; st->codecpar->height = link->h;
st ->sample_aspect_ratio = st ->sample_aspect_ratio =
st->codec->sample_aspect_ratio = link->sample_aspect_ratio; st->codecpar->sample_aspect_ratio = link->sample_aspect_ratio;
avctx->probesize = FFMAX(avctx->probesize, avctx->probesize = FFMAX(avctx->probesize,
link->w * link->h * link->w * link->h *
av_get_padded_bits_per_pixel(av_pix_fmt_desc_get(link->format)) * av_get_padded_bits_per_pixel(av_pix_fmt_desc_get(link->format)) *
30); 30);
} else if (link->type == AVMEDIA_TYPE_AUDIO) { } else if (link->type == AVMEDIA_TYPE_AUDIO) {
st->codec->codec_id = av_get_pcm_codec(link->format, -1); st->codecpar->codec_id = av_get_pcm_codec(link->format, -1);
st->codec->channels = avfilter_link_get_channels(link); st->codecpar->channels = avfilter_link_get_channels(link);
st->codec->sample_fmt = link->format; st->codecpar->format = link->format;
st->codec->sample_rate = link->sample_rate; st->codecpar->sample_rate = link->sample_rate;
st->codec->time_base = link->time_base; st->avg_frame_rate = av_inv_q(link->time_base);
st->codec->channel_layout = link->channel_layout; st->codecpar->channel_layout = link->channel_layout;
if (st->codec->codec_id == AV_CODEC_ID_NONE) if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
av_log(avctx, AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"Could not find PCM codec for sample format %s.\n", "Could not find PCM codec for sample format %s.\n",
av_get_sample_fmt_name(link->format)); av_get_sample_fmt_name(link->format));

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

@ -171,13 +171,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);
@ -188,7 +187,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:

12
libavdevice/openal-dec.c
Unescape View File

@ -128,7 +128,7 @@ static int read_header(AVFormatContext *ctx)
int error = 0; int error = 0;
const char *error_msg; const char *error_msg;
AVStream *st = NULL; AVStream *st = NULL;
AVCodecContext *codec = NULL; AVCodecParameters *par = NULL;
if (ad->list_devices) { if (ad->list_devices) {
print_al_capture_devices(ctx); print_al_capture_devices(ctx);
@ -156,11 +156,11 @@ static int read_header(AVFormatContext *ctx)
avpriv_set_pts_info(st, 64, 1, 1000000); avpriv_set_pts_info(st, 64, 1, 1000000);
/* Set codec parameters */ /* Set codec parameters */
codec = st->codec; par = st->codecpar;
codec->codec_type = AVMEDIA_TYPE_AUDIO; par->codec_type = AVMEDIA_TYPE_AUDIO;
codec->sample_rate = ad->sample_rate; par->sample_rate = ad->sample_rate;
codec->channels = get_al_format_info(ad->sample_format)->channels; par->channels = get_al_format_info(ad->sample_format)->channels;
codec->codec_id = get_al_format_info(ad->sample_format)->codec_id; par->codec_id = get_al_format_info(ad->sample_format)->codec_id;
/* This is needed to read the audio data */ /* This is needed to read the audio data */
ad->sample_step = (av_get_bits_per_sample(get_al_format_info(ad->sample_format)->codec_id) * ad->sample_step = (av_get_bits_per_sample(get_al_format_info(ad->sample_format)->codec_id) *

16
libavdevice/opengl_enc.c
Unescape View File

@ -678,11 +678,11 @@ static void opengl_compute_display_area(AVFormatContext *s)
AVRational sar, dar; /* sample and display aspect ratios */ AVRational sar, dar; /* sample and display aspect ratios */
OpenGLContext *opengl = s->priv_data; OpenGLContext *opengl = s->priv_data;
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
AVCodecContext *encctx = st->codec; AVCodecParameters *par = st->codecpar;
/* compute overlay width and height from the codec context information */ /* compute overlay width and height from the codec context information */
sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 }; sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
dar = av_mul_q(sar, (AVRational){ encctx->width, encctx->height }); dar = av_mul_q(sar, (AVRational){ par->width, par->height });
/* we suppose the screen has a 1/1 sample aspect ratio */ /* we suppose the screen has a 1/1 sample aspect ratio */
/* fit in the window */ /* fit in the window */
@ -1065,15 +1065,15 @@ static av_cold int opengl_write_header(AVFormatContext *h)
int ret; int ret;
if (h->nb_streams != 1 || if (h->nb_streams != 1 ||
h->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO || h->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
h->streams[0]->codec->codec_id != AV_CODEC_ID_RAWVIDEO) { h->streams[0]->codecpar->codec_id != AV_CODEC_ID_RAWVIDEO) {
av_log(opengl, AV_LOG_ERROR, "Only a single video stream is supported.\n"); av_log(opengl, AV_LOG_ERROR, "Only a single video stream is supported.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
st = h->streams[0]; st = h->streams[0];
opengl->width = st->codec->width; opengl->width = st->codecpar->width;
opengl->height = st->codec->height; opengl->height = st->codecpar->height;
opengl->pix_fmt = st->codec->pix_fmt; opengl->pix_fmt = st->codecpar->format;
if (!opengl->window_width) if (!opengl->window_width)
opengl->window_width = opengl->width; opengl->window_width = opengl->width;
if (!opengl->window_height) if (!opengl->window_height)
@ -1200,7 +1200,7 @@ static uint8_t* opengl_get_plane_pointer(OpenGLContext *opengl, AVPacket *pkt, i
static int opengl_draw(AVFormatContext *h, void *input, int repaint, int is_pkt) static int opengl_draw(AVFormatContext *h, void *input, int repaint, int is_pkt)
{ {
OpenGLContext *opengl = h->priv_data; OpenGLContext *opengl = h->priv_data;
enum AVPixelFormat pix_fmt = h->streams[0]->codec->pix_fmt; enum AVPixelFormat pix_fmt = h->streams[0]->codecpar->format;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
int ret; int ret;

8
libavdevice/oss_dec.c
Unescape View File

@ -63,10 +63,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

@ -49,8 +49,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_audio_dec.c
Unescape View File

@ -242,10 +242,10 @@ static av_cold int pulse_read_header(AVFormatContext *s)
pa_threaded_mainloop_unlock(pd->mainloop); pa_threaded_mainloop_unlock(pd->mainloop);
/* 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->timefilter = ff_timefilter_new(1000000.0 / pd->sample_rate, pd->timefilter = ff_timefilter_new(1000000.0 / pd->sample_rate,

25
libavdevice/pulse_audio_enc.c
Unescape View File

@ -452,7 +452,7 @@ static av_cold int pulse_write_header(AVFormatContext *h)
PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_AUTO_TIMING_UPDATE |
PA_STREAM_NOT_MONOTONIC; PA_STREAM_NOT_MONOTONIC;
if (h->nb_streams != 1 || h->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO) { if (h->nb_streams != 1 || h->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
av_log(s, AV_LOG_ERROR, "Only a single audio stream is supported.\n"); av_log(s, AV_LOG_ERROR, "Only a single audio stream is supported.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -468,8 +468,8 @@ static av_cold int pulse_write_header(AVFormatContext *h)
if (s->buffer_duration) { if (s->buffer_duration) {
int64_t bytes = s->buffer_duration; int64_t bytes = s->buffer_duration;
bytes *= st->codec->channels * st->codec->sample_rate * bytes *= st->codecpar->channels * st->codecpar->sample_rate *
av_get_bytes_per_sample(st->codec->sample_fmt); av_get_bytes_per_sample(st->codecpar->format);
bytes /= 1000; bytes /= 1000;
buffer_attributes.tlength = FFMAX(s->buffer_size, av_clip64(bytes, 0, UINT32_MAX - 1)); buffer_attributes.tlength = FFMAX(s->buffer_size, av_clip64(bytes, 0, UINT32_MAX - 1));
av_log(s, AV_LOG_DEBUG, av_log(s, AV_LOG_DEBUG,
@ -483,9 +483,9 @@ static av_cold int pulse_write_header(AVFormatContext *h)
if (s->minreq) if (s->minreq)
buffer_attributes.minreq = s->minreq; buffer_attributes.minreq = s->minreq;
sample_spec.format = ff_codec_id_to_pulse_format(st->codec->codec_id); sample_spec.format = ff_codec_id_to_pulse_format(st->codecpar->codec_id);
sample_spec.rate = st->codec->sample_rate; sample_spec.rate = st->codecpar->sample_rate;
sample_spec.channels = st->codec->channels; sample_spec.channels = st->codecpar->channels;
if (!pa_sample_spec_valid(&sample_spec)) { if (!pa_sample_spec_valid(&sample_spec)) {
av_log(s, AV_LOG_ERROR, "Invalid sample spec.\n"); av_log(s, AV_LOG_ERROR, "Invalid sample spec.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -494,10 +494,10 @@ static av_cold int pulse_write_header(AVFormatContext *h)
if (sample_spec.channels == 1) { if (sample_spec.channels == 1) {
channel_map.channels = 1; channel_map.channels = 1;
channel_map.map[0] = PA_CHANNEL_POSITION_MONO; channel_map.map[0] = PA_CHANNEL_POSITION_MONO;
} else if (st->codec->channel_layout) { } else if (st->codecpar->channel_layout) {
if (av_get_channel_layout_nb_channels(st->codec->channel_layout) != st->codec->channels) if (av_get_channel_layout_nb_channels(st->codecpar->channel_layout) != st->codecpar->channels)
return AVERROR(EINVAL); return AVERROR(EINVAL);
pulse_map_channels_to_pulse(st->codec->channel_layout, &channel_map); pulse_map_channels_to_pulse(st->codecpar->channel_layout, &channel_map);
/* Unknown channel is present in channel_layout, let PulseAudio use its default. */ /* Unknown channel is present in channel_layout, let PulseAudio use its default. */
if (channel_map.channels != sample_spec.channels) { if (channel_map.channels != sample_spec.channels) {
av_log(s, AV_LOG_WARNING, "Unknown channel. Using defaul channel map.\n"); av_log(s, AV_LOG_WARNING, "Unknown channel. Using defaul channel map.\n");
@ -637,9 +637,8 @@ static int pulse_write_packet(AVFormatContext *h, AVPacket *pkt)
s->timestamp += pkt->duration; s->timestamp += pkt->duration;
} else { } else {
AVStream *st = h->streams[0]; AVStream *st = h->streams[0];
AVCodecContext *codec_ctx = st->codec; AVRational r = { 1, st->codecpar->sample_rate };
AVRational r = { 1, codec_ctx->sample_rate }; int64_t samples = pkt->size / (av_get_bytes_per_sample(st->codecpar->format) * st->codecpar->channels);
int64_t samples = pkt->size / (av_get_bytes_per_sample(codec_ctx->sample_fmt) * codec_ctx->channels);
s->timestamp += av_rescale_q(samples, r, st->time_base); s->timestamp += av_rescale_q(samples, r, st->time_base);
} }
@ -678,7 +677,7 @@ static int pulse_write_frame(AVFormatContext *h, int stream_index,
/* Planar formats are not supported yet. */ /* Planar formats are not supported yet. */
if (flags & AV_WRITE_UNCODED_FRAME_QUERY) if (flags & AV_WRITE_UNCODED_FRAME_QUERY)
return av_sample_fmt_is_planar(h->streams[stream_index]->codec->sample_fmt) ? return av_sample_fmt_is_planar(h->streams[stream_index]->codecpar->format) ?
AVERROR(EINVAL) : 0; AVERROR(EINVAL) : 0;
pkt.data = (*frame)->data[0]; pkt.data = (*frame)->data[0];

32
libavdevice/sdl.c
Unescape View File

@ -94,12 +94,12 @@ static void compute_overlay_rect(AVFormatContext *s)
AVRational sar, dar; /* sample and display aspect ratios */ AVRational sar, dar; /* sample and display aspect ratios */
SDLContext *sdl = s->priv_data; SDLContext *sdl = s->priv_data;
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
AVCodecContext *encctx = st->codec; AVCodecParameters *par = st->codecpar;
SDL_Rect *overlay_rect = &sdl->overlay_rect; SDL_Rect *overlay_rect = &sdl->overlay_rect;
/* compute overlay width and height from the codec context information */ /* compute overlay width and height from the codec context information */
sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 }; sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
dar = av_mul_q(sar, (AVRational){ encctx->width, encctx->height }); dar = av_mul_q(sar, (AVRational){ par->width, par->height });
/* we suppose the screen has a 1/1 sample aspect ratio */ /* we suppose the screen has a 1/1 sample aspect ratio */
if (sdl->window_width && sdl->window_height) { if (sdl->window_width && sdl->window_height) {
@ -115,10 +115,10 @@ static void compute_overlay_rect(AVFormatContext *s)
} }
} else { } else {
if (sar.num > sar.den) { if (sar.num > sar.den) {
overlay_rect->w = encctx->width; overlay_rect->w = par->width;
overlay_rect->h = av_rescale(overlay_rect->w, dar.den, dar.num); overlay_rect->h = av_rescale(overlay_rect->w, dar.den, dar.num);
} else { } else {
overlay_rect->h = encctx->height; overlay_rect->h = par->height;
overlay_rect->w = av_rescale(overlay_rect->h, dar.num, dar.den); overlay_rect->w = av_rescale(overlay_rect->h, dar.num, dar.den);
} }
sdl->window_width = overlay_rect->w; sdl->window_width = overlay_rect->w;
@ -137,7 +137,7 @@ static int event_thread(void *arg)
SDLContext *sdl = s->priv_data; SDLContext *sdl = s->priv_data;
int flags = SDL_BASE_FLAGS | (sdl->window_fullscreen ? SDL_FULLSCREEN : 0); int flags = SDL_BASE_FLAGS | (sdl->window_fullscreen ? SDL_FULLSCREEN : 0);
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
AVCodecContext *encctx = st->codec; AVCodecParameters *par = st->codecpar;
/* initialization */ /* initialization */
if (SDL_Init(SDL_INIT_VIDEO) != 0) { if (SDL_Init(SDL_INIT_VIDEO) != 0) {
@ -155,19 +155,19 @@ static int event_thread(void *arg)
goto init_end; goto init_end;
} }
sdl->overlay = SDL_CreateYUVOverlay(encctx->width, encctx->height, sdl->overlay = SDL_CreateYUVOverlay(par->width, par->height,
sdl->overlay_fmt, sdl->surface); sdl->overlay_fmt, sdl->surface);
if (!sdl->overlay || sdl->overlay->pitches[0] < encctx->width) { if (!sdl->overlay || sdl->overlay->pitches[0] < par->width) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"SDL does not support an overlay with size of %dx%d pixels\n", "SDL does not support an overlay with size of %dx%d pixels\n",
encctx->width, encctx->height); par->width, par->height);
sdl->init_ret = AVERROR(EINVAL); sdl->init_ret = AVERROR(EINVAL);
goto init_end; goto init_end;
} }
sdl->init_ret = 0; sdl->init_ret = 0;
av_log(s, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s -> w:%d h:%d\n", av_log(s, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s -> w:%d h:%d\n",
encctx->width, encctx->height, av_get_pix_fmt_name(encctx->pix_fmt), par->width, par->height, av_get_pix_fmt_name(par->format),
sdl->overlay_rect.w, sdl->overlay_rect.h); sdl->overlay_rect.w, sdl->overlay_rect.h);
init_end: init_end:
@ -234,7 +234,7 @@ static int sdl_write_header(AVFormatContext *s)
{ {
SDLContext *sdl = s->priv_data; SDLContext *sdl = s->priv_data;
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
AVCodecContext *encctx = st->codec; AVCodecParameters *par = st->codecpar;
int i, ret; int i, ret;
if (!sdl->window_title) if (!sdl->window_title)
@ -251,15 +251,15 @@ static int sdl_write_header(AVFormatContext *s)
} }
if ( s->nb_streams > 1 if ( s->nb_streams > 1
|| encctx->codec_type != AVMEDIA_TYPE_VIDEO || par->codec_type != AVMEDIA_TYPE_VIDEO
|| encctx->codec_id != AV_CODEC_ID_RAWVIDEO) { || par->codec_id != AV_CODEC_ID_RAWVIDEO) {
av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n"); av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto fail; goto fail;
} }
for (i = 0; sdl_overlay_pix_fmt_map[i].pix_fmt != AV_PIX_FMT_NONE; i++) { for (i = 0; sdl_overlay_pix_fmt_map[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
if (sdl_overlay_pix_fmt_map[i].pix_fmt == encctx->pix_fmt) { if (sdl_overlay_pix_fmt_map[i].pix_fmt == par->format) {
sdl->overlay_fmt = sdl_overlay_pix_fmt_map[i].overlay_fmt; sdl->overlay_fmt = sdl_overlay_pix_fmt_map[i].overlay_fmt;
break; break;
} }
@ -268,7 +268,7 @@ static int sdl_write_header(AVFormatContext *s)
if (!sdl->overlay_fmt) { if (!sdl->overlay_fmt) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Unsupported pixel format '%s', choose one of yuv420p, yuyv422, or uyvy422\n", "Unsupported pixel format '%s', choose one of yuv420p, yuyv422, or uyvy422\n",
av_get_pix_fmt_name(encctx->pix_fmt)); av_get_pix_fmt_name(par->format));
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto fail; goto fail;
} }
@ -315,7 +315,7 @@ fail:
static int sdl_write_packet(AVFormatContext *s, AVPacket *pkt) static int sdl_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
SDLContext *sdl = s->priv_data; SDLContext *sdl = s->priv_data;
AVCodecContext *encctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
uint8_t *data[4]; uint8_t *data[4];
int linesize[4]; int linesize[4];
int i; int i;
@ -324,7 +324,7 @@ static int sdl_write_packet(AVFormatContext *s, AVPacket *pkt)
sdl_write_trailer(s); sdl_write_trailer(s);
return AVERROR(EIO); return AVERROR(EIO);
} }
av_image_fill_arrays(data, linesize, pkt->data, encctx->pix_fmt, encctx->width, encctx->height, 1); av_image_fill_arrays(data, linesize, pkt->data, par->format, par->width, par->height, 1);
SDL_LockMutex(sdl->mutex); SDL_LockMutex(sdl->mutex);
SDL_FillRect(sdl->surface, &sdl->surface->clip_rect, SDL_FillRect(sdl->surface, &sdl->surface->clip_rect,

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);

22
libavdevice/v4l2.c
Unescape View File

@ -938,8 +938,8 @@ static int v4l2_read_header(AVFormatContext *ctx)
if ((res = v4l2_set_parameters(ctx)) < 0) if ((res = v4l2_set_parameters(ctx)) < 0)
goto fail; goto fail;
st->codec->pix_fmt = ff_fmt_v4l2ff(desired_format, codec_id); st->codecpar->format = ff_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(ctx)) || if ((res = mmap_init(ctx)) ||
@ -948,22 +948,22 @@ static int v4l2_read_header(AVFormatContext *ctx)
s->top_field_first = first_field(s); s->top_field_first = first_field(s);
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);
else if (codec_id == AV_CODEC_ID_H264) { else if (codec_id == AV_CODEC_ID_H264) {
st->need_parsing = AVSTREAM_PARSE_FULL_ONCE; st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
} }
if (desired_format == V4L2_PIX_FMT_YVU420) if (desired_format == V4L2_PIX_FMT_YVU420)
st->codec->codec_tag = MKTAG('Y', 'V', '1', '2'); st->codecpar->codec_tag = MKTAG('Y', 'V', '1', '2');
else if (desired_format == V4L2_PIX_FMT_YVU410) else if (desired_format == V4L2_PIX_FMT_YVU410)
st->codec->codec_tag = MKTAG('Y', 'V', 'U', '9'); st->codecpar->codec_tag = MKTAG('Y', 'V', 'U', '9');
st->codec->width = s->width; st->codecpar->width = s->width;
st->codec->height = s->height; st->codecpar->height = s->height;
if (st->avg_frame_rate.den) if (st->avg_frame_rate.den)
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;

18
libavdevice/v4l2enc.c
Unescape View File

@ -33,7 +33,7 @@ static av_cold int write_header(AVFormatContext *s1)
.type = V4L2_BUF_TYPE_VIDEO_OUTPUT .type = V4L2_BUF_TYPE_VIDEO_OUTPUT
}; };
V4L2Context *s = s1->priv_data; V4L2Context *s = s1->priv_data;
AVCodecContext *enc_ctx; AVCodecParameters *par;
uint32_t v4l2_pixfmt; uint32_t v4l2_pixfmt;
if (s1->flags & AVFMT_FLAG_NONBLOCK) if (s1->flags & AVFMT_FLAG_NONBLOCK)
@ -47,19 +47,19 @@ static av_cold int write_header(AVFormatContext *s1)
} }
if (s1->nb_streams != 1 || if (s1->nb_streams != 1 ||
s1->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO || s1->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
s1->streams[0]->codec->codec_id != AV_CODEC_ID_RAWVIDEO) { s1->streams[0]->codecpar->codec_id != AV_CODEC_ID_RAWVIDEO) {
av_log(s1, AV_LOG_ERROR, av_log(s1, AV_LOG_ERROR,
"V4L2 output device supports only a single raw video stream\n"); "V4L2 output device supports only a single raw video stream\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
enc_ctx = s1->streams[0]->codec; par = s1->streams[0]->codecpar;
v4l2_pixfmt = ff_fmt_ff2v4l(enc_ctx->pix_fmt, AV_CODEC_ID_RAWVIDEO); v4l2_pixfmt = ff_fmt_ff2v4l(par->format, AV_CODEC_ID_RAWVIDEO);
if (!v4l2_pixfmt) { // XXX: try to force them one by one? if (!v4l2_pixfmt) { // XXX: try to force them one by one?
av_log(s1, AV_LOG_ERROR, "Unknown V4L2 pixel format equivalent for %s\n", av_log(s1, AV_LOG_ERROR, "Unknown V4L2 pixel format equivalent for %s\n",
av_get_pix_fmt_name(enc_ctx->pix_fmt)); av_get_pix_fmt_name(par->format));
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -69,10 +69,10 @@ static av_cold int write_header(AVFormatContext *s1)
return res; return res;
} }
fmt.fmt.pix.width = enc_ctx->width; fmt.fmt.pix.width = par->width;
fmt.fmt.pix.height = enc_ctx->height; fmt.fmt.pix.height = par->height;
fmt.fmt.pix.pixelformat = v4l2_pixfmt; fmt.fmt.pix.pixelformat = v4l2_pixfmt;
fmt.fmt.pix.sizeimage = av_image_get_buffer_size(enc_ctx->pix_fmt, enc_ctx->width, enc_ctx->height, 1); fmt.fmt.pix.sizeimage = av_image_get_buffer_size(par->format, par->width, par->height, 1);
if (ioctl(s->fd, VIDIOC_S_FMT, &fmt) < 0) { if (ioctl(s->fd, VIDIOC_S_FMT, &fmt) < 0) {
res = AVERROR(errno); res = AVERROR(errno);

35
libavdevice/vfwcap.c
Unescape View File

@ -245,7 +245,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;
@ -377,29 +377,30 @@ static int vfw_read_header(AVFormatContext *s)
if(!ret) if(!ret)
goto fail; goto fail;
codec = st->codec; st->avg_frame_rate = framerate_q;
codec->time_base = av_inv_q(framerate_q);
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);
} }
} }
} }

17
libavdevice/x11grab.c
Unescape View File

@ -355,11 +355,11 @@ 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;
if (st->codec->pix_fmt == AV_PIX_FMT_PAL8) { if (st->codecpar->format == AV_PIX_FMT_PAL8) {
color_map = DefaultColormap(dpy, screen); color_map = DefaultColormap(dpy, screen);
for (i = 0; i < 256; ++i) for (i = 0; i < 256; ++i)
color[i].pixel = i; color[i].pixel = i;
@ -372,12 +372,13 @@ static int x11grab_read_header(AVFormatContext *s1)
} }
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(dpyname); av_free(dpyname);

11
libavdevice/xcbgrab.c
Unescape View File

@ -548,13 +548,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);

38
libavdevice/xv.c
Unescape View File

@ -109,22 +109,22 @@ static int xv_write_header(AVFormatContext *s)
XColor fgcolor; XColor fgcolor;
XWindowAttributes window_attrs; XWindowAttributes window_attrs;
int num_formats = 0, j, tag, ret; int num_formats = 0, j, tag, ret;
AVCodecContext *encctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if ( s->nb_streams > 1 if ( s->nb_streams > 1
|| encctx->codec_type != AVMEDIA_TYPE_VIDEO || par->codec_type != AVMEDIA_TYPE_VIDEO
|| encctx->codec_id != AV_CODEC_ID_RAWVIDEO) { || par->codec_id != AV_CODEC_ID_RAWVIDEO) {
av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n"); av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (!(tag = xv_get_tag_from_format(encctx->pix_fmt))) { if (!(tag = xv_get_tag_from_format(par->format))) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Unsupported pixel format '%s', only yuv420p, uyvy422, yuyv422 are currently supported\n", "Unsupported pixel format '%s', only yuv420p, uyvy422, yuyv422 are currently supported\n",
av_get_pix_fmt_name(encctx->pix_fmt)); av_get_pix_fmt_name(par->format));
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
xv->image_format = encctx->pix_fmt; xv->image_format = par->format;
xv->display = XOpenDisplay(xv->display_name); xv->display = XOpenDisplay(xv->display_name);
if (!xv->display) { if (!xv->display) {
@ -132,12 +132,12 @@ static int xv_write_header(AVFormatContext *s)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
xv->image_width = encctx->width; xv->image_width = par->width;
xv->image_height = encctx->height; xv->image_height = par->height;
if (!xv->window_width && !xv->window_height) { if (!xv->window_width && !xv->window_height) {
AVRational sar = encctx->sample_aspect_ratio; AVRational sar = par->sample_aspect_ratio;
xv->window_width = encctx->width; xv->window_width = par->width;
xv->window_height = encctx->height; xv->window_height = par->height;
if (sar.num) { if (sar.num) {
if (sar.num > sar.den) if (sar.num > sar.den)
xv->window_width = av_rescale(xv->window_width, sar.num, sar.den); xv->window_width = av_rescale(xv->window_width, sar.num, sar.den);
@ -189,14 +189,14 @@ static int xv_write_header(AVFormatContext *s)
if (j >= num_formats) { if (j >= num_formats) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Device does not support pixel format %s, aborting\n", "Device does not support pixel format %s, aborting\n",
av_get_pix_fmt_name(encctx->pix_fmt)); av_get_pix_fmt_name(par->format));
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto fail; goto fail;
} }
xv->gc = XCreateGC(xv->display, xv->window, 0, 0); xv->gc = XCreateGC(xv->display, xv->window, 0, 0);
xv->image_width = encctx->width; xv->image_width = par->width;
xv->image_height = encctx->height; xv->image_height = par->height;
xv->yuv_image = XvShmCreateImage(xv->display, xv->xv_port, tag, 0, xv->yuv_image = XvShmCreateImage(xv->display, xv->xv_port, tag, 0,
xv->image_width, xv->image_height, &xv->yuv_shminfo); xv->image_width, xv->image_height, &xv->yuv_shminfo);
xv->yuv_shminfo.shmid = shmget(IPC_PRIVATE, xv->yuv_image->data_size, xv->yuv_shminfo.shmid = shmget(IPC_PRIVATE, xv->yuv_image->data_size,
@ -228,11 +228,11 @@ static void compute_display_area(AVFormatContext *s)
XVContext *xv = s->priv_data; XVContext *xv = s->priv_data;
AVRational sar, dar; /* sample and display aspect ratios */ AVRational sar, dar; /* sample and display aspect ratios */
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
AVCodecContext *encctx = st->codec; AVCodecParameters *par = st->codecpar;
/* compute overlay width and height from the codec context information */ /* compute overlay width and height from the codec context information */
sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 }; sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
dar = av_mul_q(sar, (AVRational){ encctx->width, encctx->height }); dar = av_mul_q(sar, (AVRational){ par->width, par->height });
/* we suppose the screen has a 1/1 sample aspect ratio */ /* we suppose the screen has a 1/1 sample aspect ratio */
/* fit in the window */ /* fit in the window */
@ -321,12 +321,12 @@ static int write_picture(AVFormatContext *s, uint8_t *input_data[4],
static int xv_write_packet(AVFormatContext *s, AVPacket *pkt) static int xv_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVCodecContext *ctx = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
uint8_t *data[4]; uint8_t *data[4];
int linesize[4]; int linesize[4];
av_image_fill_arrays(data, linesize, pkt->data, ctx->pix_fmt, av_image_fill_arrays(data, linesize, pkt->data, par->format,
ctx->width, ctx->height, 1); par->width, par->height, 1);
return write_picture(s, data, linesize); return write_picture(s, data, linesize);
} }

20
libavformat/3dostr.c
Unescape View File

@ -61,17 +61,17 @@ static int threedostr_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->sample_rate = avio_rb32(s->pb); st->codecpar->sample_rate = avio_rb32(s->pb);
st->codec->channels = avio_rb32(s->pb); st->codecpar->channels = avio_rb32(s->pb);
if (st->codec->channels <= 0) if (st->codecpar->channels <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
codec = avio_rl32(s->pb); codec = avio_rl32(s->pb);
avio_skip(s->pb, 4); avio_skip(s->pb, 4);
if (ctrl_size == 20 || ctrl_size == 3 || ctrl_size == -1) if (ctrl_size == 20 || ctrl_size == 3 || ctrl_size == -1)
st->duration = (avio_rb32(s->pb) - 1) / st->codec->channels; st->duration = (avio_rb32(s->pb) - 1) / st->codecpar->channels;
else else
st->duration = avio_rb32(s->pb) * 16 / st->codec->channels; st->duration = avio_rb32(s->pb) * 16 / st->codecpar->channels;
size -= 56; size -= 56;
found_shdr = 1; found_shdr = 1;
break; break;
@ -95,15 +95,15 @@ static int threedostr_read_header(AVFormatContext *s)
switch (codec) { switch (codec) {
case MKTAG('S','D','X','2'): case MKTAG('S','D','X','2'):
st->codec->codec_id = AV_CODEC_ID_SDX2_DPCM; st->codecpar->codec_id = AV_CODEC_ID_SDX2_DPCM;
st->codec->block_align = 1 * st->codec->channels; st->codecpar->block_align = 1 * st->codecpar->channels;
break; break;
default: default:
avpriv_request_sample(s, "codec %X", codec); avpriv_request_sample(s, "codec %X", codec);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
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;
} }
@ -142,7 +142,7 @@ static int threedostr_read_packet(AVFormatContext *s, AVPacket *pkt)
ret = av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
pkt->pos = pos; pkt->pos = pos;
pkt->stream_index = 0; pkt->stream_index = 0;
pkt->duration = size / st->codec->channels; pkt->duration = size / st->codecpar->channels;
size = 0; size = 0;
found_ssmp = 1; found_ssmp = 1;
break; break;

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;
} }
@ -173,23 +173,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

@ -26,7 +26,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
@ -35,20 +35,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:

6
libavformat/aacdec.c
Unescape View File

@ -84,9 +84,9 @@ 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_RAW; st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
ff_id3v1_read(s); ff_id3v1_read(s);
if (s->pb->seekable && if (s->pb->seekable &&

22
libavformat/aadec.c
Unescape View File

@ -173,22 +173,22 @@ static int aa_read_header(AVFormatContext *s)
av_freep(&c->tea_ctx); av_freep(&c->tea_ctx);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
if (!strcmp(codec_name, "mp332")) { if (!strcmp(codec_name, "mp332")) {
st->codec->codec_id = AV_CODEC_ID_MP3; st->codecpar->codec_id = AV_CODEC_ID_MP3;
st->codec->sample_rate = 22050; st->codecpar->sample_rate = 22050;
st->need_parsing = AVSTREAM_PARSE_FULL_RAW; st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
st->start_time = 0; st->start_time = 0;
} else if (!strcmp(codec_name, "acelp85")) { } else if (!strcmp(codec_name, "acelp85")) {
st->codec->codec_id = AV_CODEC_ID_SIPR; st->codecpar->codec_id = AV_CODEC_ID_SIPR;
st->codec->block_align = 19; st->codecpar->block_align = 19;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->sample_rate = 8500; st->codecpar->sample_rate = 8500;
} else if (!strcmp(codec_name, "acelp16")) { } else if (!strcmp(codec_name, "acelp16")) {
st->codec->codec_id = AV_CODEC_ID_SIPR; st->codecpar->codec_id = AV_CODEC_ID_SIPR;
st->codec->block_align = 20; st->codecpar->block_align = 20;
st->codec->channels = 1; st->codecpar->channels = 1;
st->codec->sample_rate = 16000; st->codecpar->sample_rate = 16000;
} }
/* determine, and jump to audio start offset */ /* determine, and jump to audio start offset */

20
libavformat/acm.c
Unescape View File

@ -41,24 +41,24 @@ static int acm_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_INTERPLAY_ACM; st->codecpar->codec_id = AV_CODEC_ID_INTERPLAY_ACM;
ff_alloc_extradata(st->codec, 14); ff_alloc_extradata(st->codecpar, 14);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = avio_read(s->pb, st->codec->extradata, 14); ret = avio_read(s->pb, st->codecpar->extradata, 14);
if (ret < 10) if (ret < 10)
return ret < 0 ? ret : AVERROR_EOF; return ret < 0 ? ret : AVERROR_EOF;
st->codec->channels = AV_RL16(st->codec->extradata + 8); st->codecpar->channels = AV_RL16(st->codecpar->extradata + 8);
st->codec->sample_rate = AV_RL16(st->codec->extradata + 10); st->codecpar->sample_rate = AV_RL16(st->codecpar->extradata + 10);
if (st->codec->channels <= 0 || st->codec->sample_rate <= 0) if (st->codecpar->channels <= 0 || st->codecpar->sample_rate <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->start_time = 0; st->start_time = 0;
st->duration = AV_RL32(st->codec->extradata + 4) / st->codec->channels; st->duration = AV_RL32(st->codecpar->extradata + 4) / st->codecpar->channels;
st->need_parsing = AVSTREAM_PARSE_FULL_RAW; st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
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;
} }

22
libavformat/act.c
Unescape View File

@ -75,29 +75,29 @@ static int read_header(AVFormatContext *s)
avio_skip(pb, 16); avio_skip(pb, 16);
size=avio_rl32(pb); size=avio_rl32(pb);
ff_get_wav_header(s, pb, st->codec, size, 0); ff_get_wav_header(s, pb, st->codecpar, size, 0);
/* /*
8000Hz (Fine-rec) file format has 10 bytes long 8000Hz (Fine-rec) file format has 10 bytes long
packets with 10ms of sound data in them packets with 10ms of sound data in them
*/ */
if (st->codec->sample_rate != 8000) { if (st->codecpar->sample_rate != 8000) {
av_log(s, AV_LOG_ERROR, "Sample rate %d is not supported.\n", st->codec->sample_rate); av_log(s, AV_LOG_ERROR, "Sample rate %d is not supported.\n", st->codecpar->sample_rate);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->frame_size=80; st->codecpar->frame_size=80;
st->codec->channels=1; st->codecpar->channels=1;
avpriv_set_pts_info(st, 64, 1, 100); avpriv_set_pts_info(st, 64, 1, 100);
st->codec->codec_id=AV_CODEC_ID_G729; st->codecpar->codec_id=AV_CODEC_ID_G729;
avio_seek(pb, 257, SEEK_SET); avio_seek(pb, 257, SEEK_SET);
msec=avio_rl16(pb); msec=avio_rl16(pb);
sec=avio_r8(pb); sec=avio_r8(pb);
min=avio_rl32(pb); min=avio_rl32(pb);
st->duration = av_rescale(1000*(min*60+sec)+msec, st->codec->sample_rate, 1000 * st->codec->frame_size); st->duration = av_rescale(1000*(min*60+sec)+msec, st->codecpar->sample_rate, 1000 * st->codecpar->frame_size);
ctx->bytes_left_in_chunk=CHUNK_SIZE; ctx->bytes_left_in_chunk=CHUNK_SIZE;
@ -113,10 +113,10 @@ static int read_packet(AVFormatContext *s,
ACTContext *ctx = s->priv_data; ACTContext *ctx = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int ret; int ret;
int frame_size=s->streams[0]->codec->sample_rate==8000?10:22; int frame_size=s->streams[0]->codecpar->sample_rate==8000?10:22;
if(s->streams[0]->codec->sample_rate==8000) if(s->streams[0]->codecpar->sample_rate==8000)
ret=av_new_packet(pkt, 10); ret=av_new_packet(pkt, 10);
else else
ret=av_new_packet(pkt, 11); ret=av_new_packet(pkt, 11);
@ -124,7 +124,7 @@ static int read_packet(AVFormatContext *s,
if(ret) if(ret)
return ret; return ret;
if(s->streams[0]->codec->sample_rate==4400 && !ctx->second_packet) if(s->streams[0]->codecpar->sample_rate==4400 && !ctx->second_packet)
{ {
ret = avio_read(pb, ctx->audio_buffer, frame_size); ret = avio_read(pb, ctx->audio_buffer, frame_size);
@ -147,7 +147,7 @@ static int read_packet(AVFormatContext *s,
ctx->second_packet=1; ctx->second_packet=1;
} }
else if(s->streams[0]->codec->sample_rate==4400 && ctx->second_packet) else if(s->streams[0]->codecpar->sample_rate==4400 && ctx->second_packet)
{ {
pkt->data[0]=ctx->audio_buffer[5]; pkt->data[0]=ctx->audio_buffer[5];
pkt->data[1]=ctx->audio_buffer[17]; pkt->data[1]=ctx->audio_buffer[17];

14
libavformat/adp.c
Unescape View File

@ -53,16 +53,16 @@ static int adp_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_DTK; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_DTK;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->sample_rate = 48000; st->codecpar->sample_rate = 48000;
st->start_time = 0; st->start_time = 0;
if (s->pb->seekable) if (s->pb->seekable)
st->duration = av_get_audio_frame_duration(st->codec, avio_size(s->pb)); st->duration = av_get_audio_frame_duration2(st->codecpar, avio_size(s->pb));
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;
} }

28
libavformat/ads.c
Unescape View File

@ -42,39 +42,39 @@ static int ads_read_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_skip(s->pb, 8); avio_skip(s->pb, 8);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
codec = avio_rl32(s->pb); codec = avio_rl32(s->pb);
st->codec->sample_rate = avio_rl32(s->pb); st->codecpar->sample_rate = avio_rl32(s->pb);
if (st->codec->sample_rate <= 0) if (st->codecpar->sample_rate <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->codec->channels = avio_rl32(s->pb); st->codecpar->channels = avio_rl32(s->pb);
if (st->codec->channels <= 0) if (st->codecpar->channels <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
align = avio_rl32(s->pb); align = avio_rl32(s->pb);
if (align <= 0 || align > INT_MAX / st->codec->channels) if (align <= 0 || align > INT_MAX / st->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (codec == 1) if (codec == 1)
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE_PLANAR; st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE_PLANAR;
else else
st->codec->codec_id = AV_CODEC_ID_ADPCM_PSX; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_PSX;
st->codec->block_align = st->codec->channels * align; st->codecpar->block_align = st->codecpar->channels * align;
avio_skip(s->pb, 12); avio_skip(s->pb, 12);
size = avio_rl32(s->pb); size = avio_rl32(s->pb);
if (st->codec->codec_id == AV_CODEC_ID_ADPCM_PSX) if (st->codecpar->codec_id == AV_CODEC_ID_ADPCM_PSX)
st->duration = (size - 0x40) / 16 / st->codec->channels * 28; st->duration = (size - 0x40) / 16 / st->codecpar->channels * 28;
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 ads_read_packet(AVFormatContext *s, AVPacket *pkt) static int ads_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVCodecContext *codec = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
int ret; int ret;
ret = av_get_packet(s->pb, pkt, codec->block_align); ret = av_get_packet(s->pb, pkt, par->block_align);
pkt->stream_index = 0; pkt->stream_index = 0;
return ret; return ret;
} }

8
libavformat/adtsenc.c
Unescape View File

@ -97,13 +97,13 @@ static int adts_decode_extradata(AVFormatContext *s, ADTSContext *adts, const ui
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 (adts->id3v2tag) if (adts->id3v2tag)
ff_id3v2_write_simple(s, 4, ID3v2_DEFAULT_MAGIC); ff_id3v2_write_simple(s, 4, ID3v2_DEFAULT_MAGIC);
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;
} }

30
libavformat/adxdec.c
Unescape View File

@ -50,15 +50,15 @@ static int adx_probe(AVProbeData *p)
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;
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;
} }
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;
@ -82,37 +82,37 @@ 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);
if (ff_get_extradata(avctx, s->pb, c->header_size) < 0) if (ff_get_extradata(par, s->pb, c->header_size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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

@ -67,29 +67,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)

16
libavformat/afc.c
Unescape View File

@ -35,20 +35,20 @@ static int afc_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_AFC; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_AFC;
st->codec->channels = 2; st->codecpar->channels = 2;
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
if (ff_alloc_extradata(st->codec, 1)) if (ff_alloc_extradata(st->codecpar, 1))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata[0] = 8 * st->codec->channels; st->codecpar->extradata[0] = 8 * st->codecpar->channels;
c->data_end = avio_rb32(s->pb) + 32LL; c->data_end = avio_rb32(s->pb) + 32LL;
st->duration = avio_rb32(s->pb); st->duration = avio_rb32(s->pb);
st->codec->sample_rate = avio_rb16(s->pb); st->codecpar->sample_rate = avio_rb16(s->pb);
avio_skip(s->pb, 22); avio_skip(s->pb, 22);
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;
} }

90
libavformat/aiffdec.c
Unescape View File

@ -95,7 +95,7 @@ static 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;
@ -104,10 +104,10 @@ static 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) - 16383 - 63; exp = avio_rb16(pb) - 16383 - 63;
val = avio_rb64(pb); val = avio_rb64(pb);
@ -119,29 +119,29 @@ static int get_aiff_header(AVFormatContext *s, int size,
sample_rate = val << exp; sample_rate = val << exp;
else else
sample_rate = (val + (1ULL<<(-exp-1))) >> -exp; sample_rate = (val + (1ULL<<(-exp-1))) >> -exp;
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 (size < 4) { if (size < 4) {
version = AIFF; version = AIFF;
} else if (version == AIFF_C_VERSION1) { } else 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);
if (codec->codec_id == AV_CODEC_ID_NONE) { if (par->codec_id == AV_CODEC_ID_NONE) {
char tag[32]; char tag[32];
av_get_codec_tag_string(tag, sizeof(tag), codec->codec_tag); av_get_codec_tag_string(tag, sizeof(tag), par->codec_tag);
avpriv_request_sample(s, "unknown or unsupported codec tag: %s", tag); avpriv_request_sample(s, "unknown or unsupported codec tag: %s", 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:
@ -150,39 +150,39 @@ static 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_G726LE: case AV_CODEC_ID_ADPCM_G726LE:
codec->bits_per_coded_sample = 5; par->bits_per_coded_sample = 5;
case AV_CODEC_ID_ADPCM_IMA_WS: case AV_CODEC_ID_ADPCM_IMA_WS:
case AV_CODEC_ID_ADPCM_G722: case AV_CODEC_ID_ADPCM_G722:
case AV_CODEC_ID_MACE6: case AV_CODEC_ID_MACE6:
case AV_CODEC_ID_SDX2_DPCM: case AV_CODEC_ID_SDX2_DPCM:
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;
default: default:
aiff->block_duration = 1; aiff->block_duration = 1;
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 = (av_get_bits_per_sample(codec->codec_id) * codec->channels) >> 3; par->block_align = (av_get_bits_per_sample(par->codec_id) * 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 */
@ -238,7 +238,7 @@ static int aiff_read_header(AVFormatContext *s)
/* parse different chunks */ /* parse different chunks */
size = get_tag(pb, &tag); size = get_tag(pb, &tag);
if (size == AVERROR_EOF && offset > 0 && st->codec->block_align) { if (size == AVERROR_EOF && offset > 0 && st->codecpar->block_align) {
av_log(s, AV_LOG_WARNING, "header parser hit EOF\n"); av_log(s, AV_LOG_WARNING, "header parser hit EOF\n");
goto got_sound; goto got_sound;
} }
@ -288,7 +288,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 && !pb->seekable) /* Assume COMM already parsed */ if (st->codecpar->block_align && !pb->seekable) /* 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");
@ -299,26 +299,26 @@ 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;
if (ff_get_extradata(st->codec, pb, size) < 0) if (ff_get_extradata(st->codecpar, pb, size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (st->codec->codec_id == AV_CODEC_ID_QDM2 && size>=12*4 && !st->codec->block_align) { if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 && size>=12*4 && !st->codecpar->block_align) {
st->codec->block_align = AV_RB32(st->codec->extradata+11*4); st->codecpar->block_align = AV_RB32(st->codecpar->extradata+11*4);
aiff->block_duration = AV_RB32(st->codec->extradata+9*4); aiff->block_duration = AV_RB32(st->codecpar->extradata+9*4);
} else if (st->codec->codec_id == AV_CODEC_ID_QCELP) { } else if (st->codecpar->codec_id == AV_CODEC_ID_QCELP) {
char rate = 0; char rate = 0;
if (size >= 25) if (size >= 25)
rate = st->codec->extradata[24]; rate = st->codecpar->extradata[24];
switch (rate) { switch (rate) {
case 'H': // RATE_HALF case 'H': // RATE_HALF
st->codec->block_align = 17; st->codecpar->block_align = 17;
break; break;
case 'F': // RATE_FULL case 'F': // RATE_FULL
default: default:
st->codec->block_align = 35; st->codecpar->block_align = 35;
} }
aiff->block_duration = 160; aiff->block_duration = 160;
st->codec->bit_rate = st->codec->sample_rate * (st->codec->block_align << 3) / st->codecpar->bit_rate = st->codecpar->sample_rate * (st->codecpar->block_align << 3) /
aiff->block_duration; aiff->block_duration;
} }
break; break;
case MKTAG('C','H','A','N'): case MKTAG('C','H','A','N'):
@ -326,7 +326,7 @@ static int aiff_read_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
break; break;
case 0: case 0:
if (offset > 0 && st->codec->block_align) // COMM && SSND if (offset > 0 && st->codecpar->block_align) // COMM && SSND
goto got_sound; goto got_sound;
default: /* Jump */ default: /* Jump */
if (size & 1) /* Always even aligned */ if (size & 1) /* Always even aligned */
@ -336,13 +336,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;
@ -368,26 +368,26 @@ static int aiff_read_packet(AVFormatContext *s,
return AVERROR_EOF; return AVERROR_EOF;
/* Now for that packet */ /* Now for that packet */
switch (st->codec->codec_id) { switch (st->codecpar->codec_id) {
case AV_CODEC_ID_ADPCM_IMA_QT: case AV_CODEC_ID_ADPCM_IMA_QT:
case AV_CODEC_ID_GSM: case AV_CODEC_ID_GSM:
case AV_CODEC_ID_QDM2: case AV_CODEC_ID_QDM2:
case AV_CODEC_ID_QCELP: case AV_CODEC_ID_QCELP:
size = st->codec->block_align; size = st->codecpar->block_align;
break; break;
default: default:
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)
return res; return res;
if (size >= st->codec->block_align) if (size >= st->codecpar->block_align)
pkt->flags &= ~AV_PKT_FLAG_CORRUPT; pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
/* 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;
} }

50
libavformat/aiffenc.c
Unescape View File

@ -102,16 +102,16 @@ 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; AVCodecParameters *par;
uint64_t sample_rate; uint64_t sample_rate;
int i, aifc = 0; int i, aifc = 0;
aiff->audio_stream_idx = -1; aiff->audio_stream_idx = -1;
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 (aiff->audio_stream_idx < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (aiff->audio_stream_idx < 0 && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
aiff->audio_stream_idx = i; aiff->audio_stream_idx = i;
} else if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO) { } else if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
av_log(s, AV_LOG_ERROR, "AIFF allows only one audio stream and a picture.\n"); av_log(s, AV_LOG_ERROR, "AIFF allows only one audio stream and a picture.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -121,12 +121,12 @@ static int aiff_write_header(AVFormatContext *s)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
enc = s->streams[aiff->audio_stream_idx]->codec; par = s->streams[aiff->audio_stream_idx]->codecpar;
/* 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 */
@ -136,7 +136,7 @@ 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
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;
} }
@ -146,10 +146,10 @@ static int aiff_write_header(AVFormatContext *s)
avio_wb32(pb, 0xA2805140); avio_wb32(pb, 0xA2805140);
} }
if (enc->channels > 2 && enc->channel_layout) { if (par->channels > 2 && par->channel_layout) {
ffio_wfourcc(pb, "CHAN"); ffio_wfourcc(pb, "CHAN");
avio_wb32(pb, 12); avio_wb32(pb, 12);
ff_mov_write_chan(pb, enc->channel_layout); ff_mov_write_chan(pb, par->channel_layout);
} }
put_meta(s, "title", MKTAG('N', 'A', 'M', 'E')); put_meta(s, "title", MKTAG('N', 'A', 'M', 'E'));
@ -160,35 +160,35 @@ 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);
} }
if (enc->codec_tag == MKTAG('Q','D','M','2') && enc->extradata_size) { if (par->codec_tag == MKTAG('Q','D','M','2') && par->extradata_size) {
ffio_wfourcc(pb, "wave"); ffio_wfourcc(pb, "wave");
avio_wb32(pb, enc->extradata_size); avio_wb32(pb, par->extradata_size);
avio_write(pb, enc->extradata, enc->extradata_size); avio_write(pb, par->extradata, par->extradata_size);
} }
/* Sound data chunk */ /* Sound data chunk */
@ -199,7 +199,7 @@ static int aiff_write_header(AVFormatContext *s)
avio_wb32(pb, 0); /* Block-size (block align) */ avio_wb32(pb, 0); /* Block-size (block align) */
avpriv_set_pts_info(s->streams[aiff->audio_stream_idx], 64, 1, avpriv_set_pts_info(s->streams[aiff->audio_stream_idx], 64, 1,
s->streams[aiff->audio_stream_idx]->codec->sample_rate); s->streams[aiff->audio_stream_idx]->codecpar->sample_rate);
/* Data is starting here */ /* Data is starting here */
avio_flush(pb); avio_flush(pb);
@ -217,7 +217,7 @@ static int aiff_write_packet(AVFormatContext *s, AVPacket *pkt)
int ret; int ret;
AVPacketList *pict_list, *last; AVPacketList *pict_list, *last;
if (s->streams[pkt->stream_index]->codec->codec_type != AVMEDIA_TYPE_VIDEO) if (s->streams[pkt->stream_index]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
return 0; return 0;
/* warn only once for each stream */ /* warn only once for each stream */
@ -256,7 +256,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;
AVPacketList *pict_list = aiff->pict_list; AVPacketList *pict_list = aiff->pict_list;
AVCodecContext *enc = s->streams[aiff->audio_stream_idx]->codec; AVCodecParameters *par = s->streams[aiff->audio_stream_idx]->codecpar;
/* Chunks sizes must be even */ /* Chunks sizes must be even */
int64_t file_size, end_size; int64_t file_size, end_size;
@ -269,7 +269,7 @@ static int aiff_write_trailer(AVFormatContext *s)
if (s->pb->seekable) { if (s->pb->seekable) {
/* 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);

12
libavformat/aixdec.c
Unescape View File

@ -61,11 +61,11 @@ static int aix_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_ADX; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_ADX;
st->codec->sample_rate = avio_rb32(s->pb); st->codecpar->sample_rate = avio_rb32(s->pb);
st->codec->channels = avio_r8(s->pb); st->codecpar->channels = avio_r8(s->pb);
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, 3); avio_skip(s->pb, 3);
} }
@ -77,7 +77,7 @@ static int aix_read_header(AVFormatContext *s)
if (size <= 8) if (size <= 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
avio_skip(s->pb, 8); avio_skip(s->pb, 8);
ff_get_extradata(s->streams[i]->codec, s->pb, size - 8); ff_get_extradata(s->streams[i]->codecpar, s->pb, size - 8);
} }
return 0; return 0;

36
libavformat/amr.c
Unescape View File

@ -42,13 +42,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;
@ -94,25 +94,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);
AMRContext *amr = s->priv_data; AMRContext *amr = s->priv_data;
@ -125,13 +125,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
}; };
@ -145,13 +145,13 @@ static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
if (amr->cumulated_size < UINT64_MAX - size) { if (amr->cumulated_size < UINT64_MAX - size) {
amr->cumulated_size += size; amr->cumulated_size += size;
/* Both AMR formats have 50 frames per second */ /* Both AMR formats have 50 frames per second */
s->streams[0]->codec->bit_rate = amr->cumulated_size / ++amr->block_count * 8 * 50; s->streams[0]->codecpar->bit_rate = amr->cumulated_size / ++amr->block_count * 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;

24
libavformat/apc.c
Unescape View File

@ -46,28 +46,28 @@ 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);
/* initial predictor values for adpcm decoder */ /* initial predictor values for adpcm decoder */
if (ff_get_extradata(st->codec, pb, 2 * 4) < 0) if (ff_get_extradata(st->codecpar, pb, 2 * 4) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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;
} }

20
libavformat/ape.c
Unescape View File

@ -348,23 +348,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; st->duration = total_blocks;
avpriv_set_pts_info(st, 64, 1, ape->samplerate); avpriv_set_pts_info(st, 64, 1, ape->samplerate);
if (ff_alloc_extradata(st->codec, APE_EXTRADATA_SIZE)) if (ff_alloc_extradata(st->codecpar, APE_EXTRADATA_SIZE))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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++) {

8
libavformat/apetag.c
Unescape View File

@ -89,16 +89,16 @@ 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 {
if (ff_get_extradata(st->codec, s->pb, size) < 0) if (ff_get_extradata(st->codecpar, s->pb, size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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);

66
libavformat/apngdec.c
Unescape View File

@ -122,9 +122,9 @@ end:
return AVPROBE_SCORE_MAX; return AVPROBE_SCORE_MAX;
} }
static int append_extradata(AVCodecContext *s, AVIOContext *pb, int len) static int append_extradata(AVCodecParameters *par, AVIOContext *pb, int len)
{ {
int previous_size = s->extradata_size; int previous_size = par->extradata_size;
int new_size, ret; int new_size, ret;
uint8_t *new_extradata; uint8_t *new_extradata;
@ -132,13 +132,13 @@ static int append_extradata(AVCodecContext *s, AVIOContext *pb, int len)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
new_size = previous_size + len; new_size = previous_size + len;
new_extradata = av_realloc(s->extradata, new_size + AV_INPUT_BUFFER_PADDING_SIZE); new_extradata = av_realloc(par->extradata, new_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!new_extradata) if (!new_extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
s->extradata = new_extradata; par->extradata = new_extradata;
s->extradata_size = new_size; par->extradata_size = new_size;
if ((ret = avio_read(pb, s->extradata + previous_size, len)) < 0) if ((ret = avio_read(pb, par->extradata + previous_size, len)) < 0)
return ret; return ret;
return previous_size; return previous_size;
@ -170,23 +170,23 @@ static int apng_read_header(AVFormatContext *s)
/* set the timebase to something large enough (1/100,000 of second) /* set the timebase to something large enough (1/100,000 of second)
* to hopefully cope with all sane frame durations */ * to hopefully cope with all sane frame durations */
avpriv_set_pts_info(st, 64, 1, 100000); avpriv_set_pts_info(st, 64, 1, 100000);
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_APNG; st->codecpar->codec_id = AV_CODEC_ID_APNG;
st->codec->width = avio_rb32(pb); st->codecpar->width = avio_rb32(pb);
st->codec->height = avio_rb32(pb); st->codecpar->height = avio_rb32(pb);
if ((ret = av_image_check_size(st->codec->width, st->codec->height, 0, s)) < 0) if ((ret = av_image_check_size(st->codecpar->width, st->codecpar->height, 0, s)) < 0)
return ret; return ret;
/* extradata will contain every chunk up to the first fcTL (excluded) */ /* extradata will contain every chunk up to the first fcTL (excluded) */
st->codec->extradata = av_malloc(len + 12 + AV_INPUT_BUFFER_PADDING_SIZE); st->codecpar->extradata = av_malloc(len + 12 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codec->extradata) if (!st->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata_size = len + 12; st->codecpar->extradata_size = len + 12;
AV_WB32(st->codec->extradata, len); AV_WB32(st->codecpar->extradata, len);
AV_WL32(st->codec->extradata+4, tag); AV_WL32(st->codecpar->extradata+4, tag);
AV_WB32(st->codec->extradata+8, st->codec->width); AV_WB32(st->codecpar->extradata+8, st->codecpar->width);
AV_WB32(st->codec->extradata+12, st->codec->height); AV_WB32(st->codecpar->extradata+12, st->codecpar->height);
if ((ret = avio_read(pb, st->codec->extradata+16, 9)) < 0) if ((ret = avio_read(pb, st->codecpar->extradata+16, 9)) < 0)
goto fail; goto fail;
while (!avio_feof(pb)) { while (!avio_feof(pb)) {
@ -218,11 +218,11 @@ static int apng_read_header(AVFormatContext *s)
switch (tag) { switch (tag) {
case MKTAG('a', 'c', 'T', 'L'): case MKTAG('a', 'c', 'T', 'L'):
if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 || if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
(ret = append_extradata(st->codec, pb, len + 12)) < 0) (ret = append_extradata(st->codecpar, pb, len + 12)) < 0)
goto fail; goto fail;
acTL_found = 1; acTL_found = 1;
ctx->num_frames = AV_RB32(st->codec->extradata + ret + 8); ctx->num_frames = AV_RB32(st->codecpar->extradata + ret + 8);
ctx->num_play = AV_RB32(st->codec->extradata + ret + 12); ctx->num_play = AV_RB32(st->codecpar->extradata + ret + 12);
av_log(s, AV_LOG_DEBUG, "num_frames: %"PRIu32", num_play: %"PRIu32"\n", av_log(s, AV_LOG_DEBUG, "num_frames: %"PRIu32", num_play: %"PRIu32"\n",
ctx->num_frames, ctx->num_play); ctx->num_frames, ctx->num_play);
break; break;
@ -236,15 +236,15 @@ static int apng_read_header(AVFormatContext *s)
return 0; return 0;
default: default:
if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 || if ((ret = avio_seek(pb, -8, SEEK_CUR)) < 0 ||
(ret = append_extradata(st->codec, pb, len + 12)) < 0) (ret = append_extradata(st->codecpar, pb, len + 12)) < 0)
goto fail; goto fail;
} }
} }
fail: fail:
if (st->codec->extradata_size) { if (st->codecpar->extradata_size) {
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
st->codec->extradata_size = 0; st->codecpar->extradata_size = 0;
} }
return ret; return ret;
} }
@ -298,15 +298,15 @@ static int decode_fctl_chunk(AVFormatContext *s, APNGDemuxContext *ctx, AVPacket
dispose_op, dispose_op,
blend_op); blend_op);
if (width != s->streams[0]->codec->width || if (width != s->streams[0]->codecpar->width ||
height != s->streams[0]->codec->height || height != s->streams[0]->codecpar->height ||
x_offset != 0 || x_offset != 0 ||
y_offset != 0) { y_offset != 0) {
if (sequence_number == 0 || if (sequence_number == 0 ||
x_offset >= s->streams[0]->codec->width || x_offset >= s->streams[0]->codecpar->width ||
width > s->streams[0]->codec->width - x_offset || width > s->streams[0]->codecpar->width - x_offset ||
y_offset >= s->streams[0]->codec->height || y_offset >= s->streams[0]->codecpar->height ||
height > s->streams[0]->codec->height - y_offset) height > s->streams[0]->codecpar->height - y_offset)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ctx->is_key_frame = 0; ctx->is_key_frame = 0;
} else { } else {
@ -400,7 +400,7 @@ static int apng_read_packet(AVFormatContext *s, AVPacket *pkt)
avio_seek(pb, -8, SEEK_CUR); avio_seek(pb, -8, SEEK_CUR);
return AVERROR_EOF; return AVERROR_EOF;
} }
if ((ret = avio_seek(pb, s->streams[0]->codec->extradata_size + 8, SEEK_SET)) < 0) if ((ret = avio_seek(pb, s->streams[0]->codecpar->extradata_size + 8, SEEK_SET)) < 0)
return ret; return ret;
return 0; return 0;
default: default:

18
libavformat/apngenc.c
Unescape View File

@ -80,8 +80,8 @@ static int apng_write_header(AVFormatContext *format_context)
APNGMuxContext *apng = format_context->priv_data; APNGMuxContext *apng = format_context->priv_data;
if (format_context->nb_streams != 1 || if (format_context->nb_streams != 1 ||
format_context->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO || format_context->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
format_context->streams[0]->codec->codec_id != AV_CODEC_ID_APNG) { format_context->streams[0]->codecpar->codec_id != AV_CODEC_ID_APNG) {
av_log(format_context, AV_LOG_ERROR, av_log(format_context, AV_LOG_ERROR,
"APNG muxer supports only a single video APNG stream.\n"); "APNG muxer supports only a single video APNG stream.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -106,7 +106,7 @@ static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
APNGMuxContext *apng = format_context->priv_data; APNGMuxContext *apng = format_context->priv_data;
AVIOContext *io_context = format_context->pb; AVIOContext *io_context = format_context->pb;
AVStream *codec_stream = format_context->streams[0]; AVStream *codec_stream = format_context->streams[0];
AVCodecContext *codec_context = codec_stream->codec; AVCodecParameters *codec_par = codec_stream->codecpar;
av_assert0(apng->prev_packet); av_assert0(apng->prev_packet);
@ -117,13 +117,13 @@ static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
av_log(format_context, AV_LOG_INFO, "Only a single frame so saving as a normal PNG.\n"); av_log(format_context, AV_LOG_INFO, "Only a single frame so saving as a normal PNG.\n");
// Write normal PNG headers without acTL chunk // Write normal PNG headers without acTL chunk
existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), codec_context->extradata, codec_context->extradata_size); existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), codec_par->extradata, codec_par->extradata_size);
if (existing_acTL_chunk) { if (existing_acTL_chunk) {
uint8_t *chunk_after_acTL = existing_acTL_chunk + AV_RB32(existing_acTL_chunk) + 12; uint8_t *chunk_after_acTL = existing_acTL_chunk + AV_RB32(existing_acTL_chunk) + 12;
avio_write(io_context, codec_context->extradata, existing_acTL_chunk - codec_context->extradata); avio_write(io_context, codec_par->extradata, existing_acTL_chunk - codec_par->extradata);
avio_write(io_context, chunk_after_acTL, codec_context->extradata + codec_context->extradata_size - chunk_after_acTL); avio_write(io_context, chunk_after_acTL, codec_par->extradata + codec_par->extradata_size - chunk_after_acTL);
} else { } else {
avio_write(io_context, codec_context->extradata, codec_context->extradata_size); avio_write(io_context, codec_par->extradata, codec_par->extradata_size);
} }
// Write frame data without fcTL chunk // Write frame data without fcTL chunk
@ -142,9 +142,9 @@ static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
uint8_t *existing_acTL_chunk; uint8_t *existing_acTL_chunk;
// Write normal PNG headers // Write normal PNG headers
avio_write(io_context, codec_context->extradata, codec_context->extradata_size); avio_write(io_context, codec_par->extradata, codec_par->extradata_size);
existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), codec_context->extradata, codec_context->extradata_size); existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), codec_par->extradata, codec_par->extradata_size);
if (!existing_acTL_chunk) { if (!existing_acTL_chunk) {
uint8_t buf[8]; uint8_t buf[8];
// Write animation control header // Write animation control header

4
libavformat/aqtitledec.c
Unescape View File

@ -58,8 +58,8 @@ static int aqt_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, aqt->frame_rate.den, aqt->frame_rate.num); avpriv_set_pts_info(st, 64, aqt->frame_rate.den, aqt->frame_rate.num);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE; st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_TEXT; st->codecpar->codec_id = AV_CODEC_ID_TEXT;
while (!avio_feof(s->pb)) { while (!avio_feof(s->pb)) {
char line[4096]; char line[4096];

72
libavformat/asfdec_f.c
Unescape View File

@ -281,8 +281,8 @@ static int asf_read_picture(AVFormatContext *s, int len)
goto fail; goto fail;
} }
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;
@ -436,7 +436,7 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
type = AVMEDIA_TYPE_VIDEO; type = AVMEDIA_TYPE_VIDEO;
} else if (!ff_guidcmp(&g, &ff_asf_jfif_media)) { } else if (!ff_guidcmp(&g, &ff_asf_jfif_media)) {
type = AVMEDIA_TYPE_VIDEO; type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = AV_CODEC_ID_MJPEG; st->codecpar->codec_id = AV_CODEC_ID_MJPEG;
} else if (!ff_guidcmp(&g, &ff_asf_command_stream)) { } else if (!ff_guidcmp(&g, &ff_asf_command_stream)) {
type = AVMEDIA_TYPE_DATA; type = AVMEDIA_TYPE_DATA;
} else if (!ff_guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) { } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) {
@ -470,18 +470,18 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
} }
} }
st->codec->codec_type = type; st->codecpar->codec_type = type;
if (type == AVMEDIA_TYPE_AUDIO) { if (type == AVMEDIA_TYPE_AUDIO) {
int ret = ff_get_wav_header(s, pb, st->codec, type_specific_size, 0); int ret = ff_get_wav_header(s, pb, st->codecpar, type_specific_size, 0);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (is_dvr_ms_audio) { if (is_dvr_ms_audio) {
// codec_id and codec_tag are unreliable in dvr_ms // codec_id and codec_tag are unreliable in dvr_ms
// files. Set them later by probing stream. // files. Set them later by probing stream.
st->request_probe = 1; st->request_probe = 1;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
} }
if (st->codec->codec_id == AV_CODEC_ID_AAC) if (st->codecpar->codec_id == AV_CODEC_ID_AAC)
st->need_parsing = AVSTREAM_PARSE_NONE; st->need_parsing = AVSTREAM_PARSE_NONE;
else else
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
@ -507,52 +507,52 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
avio_r8(pb); avio_r8(pb);
avio_rl16(pb); /* size */ avio_rl16(pb); /* size */
sizeX = avio_rl32(pb); /* size */ sizeX = avio_rl32(pb); /* size */
st->codec->width = avio_rl32(pb); st->codecpar->width = avio_rl32(pb);
st->codec->height = avio_rl32(pb); st->codecpar->height = avio_rl32(pb);
/* not available for asf */ /* not available for asf */
avio_rl16(pb); /* panes */ avio_rl16(pb); /* panes */
st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */ st->codecpar->bits_per_coded_sample = avio_rl16(pb); /* depth */
tag1 = avio_rl32(pb); tag1 = avio_rl32(pb);
avio_skip(pb, 20); avio_skip(pb, 20);
if (sizeX > 40) { if (sizeX > 40) {
st->codec->extradata_size = ffio_limit(pb, sizeX - 40); st->codecpar->extradata_size = ffio_limit(pb, sizeX - 40);
st->codec->extradata = av_mallocz(st->codec->extradata_size + st->codecpar->extradata = av_mallocz(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);
avio_read(pb, st->codec->extradata, st->codec->extradata_size); avio_read(pb, st->codecpar->extradata, st->codecpar->extradata_size);
} }
/* 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 libavcodec */ /* This is true for all paletted codecs implemented in libavcodec */
if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) { if (st->codecpar->extradata_size && (st->codecpar->bits_per_coded_sample <= 8)) {
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
int i; int i;
for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE) / 4; i++) for (i = 0; i < FFMIN(st->codecpar->extradata_size, AVPALETTE_SIZE) / 4; i++)
asf_st->palette[i] = av_bswap32(((uint32_t *)st->codec->extradata)[i]); asf_st->palette[i] = av_bswap32(((uint32_t *)st->codecpar->extradata)[i]);
#else #else
memcpy(asf_st->palette, st->codec->extradata, memcpy(asf_st->palette, st->codecpar->extradata,
FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)); FFMIN(st->codecpar->extradata_size, AVPALETTE_SIZE));
#endif #endif
asf_st->palette_changed = 1; asf_st->palette_changed = 1;
} }
st->codec->codec_tag = tag1; st->codecpar->codec_tag = tag1;
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1); st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1);
if (tag1 == MKTAG('D', 'V', 'R', ' ')) { if (tag1 == MKTAG('D', 'V', 'R', ' ')) {
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
/* issue658 contains wrong w/h and MS even puts a fake seq header /* issue658 contains wrong w/h and MS even puts a fake seq header
* with wrong w/h in extradata while a correct one is in the stream. * with wrong w/h in extradata while a correct one is in the stream.
* maximum lameness */ * maximum lameness */
st->codec->width = st->codecpar->width =
st->codec->height = 0; st->codecpar->height = 0;
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
st->codec->extradata_size = 0; st->codecpar->extradata_size = 0;
} }
if (st->codec->codec_id == AV_CODEC_ID_H264) if (st->codecpar->codec_id == AV_CODEC_ID_H264)
st->need_parsing = AVSTREAM_PARSE_FULL_ONCE; st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
if (st->codec->codec_id == AV_CODEC_ID_MPEG4) if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4)
st->need_parsing = AVSTREAM_PARSE_FULL_ONCE; st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
} }
pos2 = avio_tell(pb); pos2 = avio_tell(pb);
@ -890,21 +890,21 @@ static int asf_read_header(AVFormatContext *s)
int stream_num = asf->asfid2avid[i]; int stream_num = asf->asfid2avid[i];
if (stream_num >= 0) { if (stream_num >= 0) {
AVStream *st = s->streams[stream_num]; AVStream *st = s->streams[stream_num];
if (!st->codec->bit_rate) if (!st->codecpar->bit_rate)
st->codec->bit_rate = asf->stream_bitrates[i]; st->codecpar->bit_rate = asf->stream_bitrates[i];
if (asf->dar[i].num > 0 && asf->dar[i].den > 0) { if (asf->dar[i].num > 0 && asf->dar[i].den > 0) {
av_reduce(&st->sample_aspect_ratio.num, av_reduce(&st->sample_aspect_ratio.num,
&st->sample_aspect_ratio.den, &st->sample_aspect_ratio.den,
asf->dar[i].num, asf->dar[i].den, INT_MAX); asf->dar[i].num, asf->dar[i].den, INT_MAX);
} else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) && } else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) &&
// Use ASF container value if the stream doesn't set AR. // Use ASF container value if the stream doesn't set AR.
(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)) (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO))
av_reduce(&st->sample_aspect_ratio.num, av_reduce(&st->sample_aspect_ratio.num,
&st->sample_aspect_ratio.den, &st->sample_aspect_ratio.den,
asf->dar[0].num, asf->dar[0].den, INT_MAX); asf->dar[0].num, asf->dar[0].den, INT_MAX);
av_log(s, AV_LOG_TRACE, "i=%d, st->codec->codec_type:%d, asf->dar %d:%d sar=%d:%d\n", av_log(s, AV_LOG_TRACE, "i=%d, st->codecpar->codec_type:%d, asf->dar %d:%d sar=%d:%d\n",
i, st->codec->codec_type, asf->dar[i].num, asf->dar[i].den, i, st->codecpar->codec_type, asf->dar[i].num, asf->dar[i].den,
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den); st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
// copy and convert language codes to the frontend // copy and convert language codes to the frontend
@ -1316,9 +1316,9 @@ static int asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
av_log(asf, AV_LOG_TRACE, "new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n", av_log(asf, AV_LOG_TRACE, "new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
asf->stream_index, asf->packet_key_frame, asf->stream_index, asf->packet_key_frame,
asf_st->pkt.flags & AV_PKT_FLAG_KEY, asf_st->pkt.flags & AV_PKT_FLAG_KEY,
s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO, s->streams[asf->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO,
asf_st->packet_obj_size); asf_st->packet_obj_size);
if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO) if (s->streams[asf->stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
asf->packet_key_frame = 1; asf->packet_key_frame = 1;
if (asf->packet_key_frame) if (asf->packet_key_frame)
asf_st->pkt.flags |= AV_PKT_FLAG_KEY; asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
@ -1371,7 +1371,7 @@ static int asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
/* test if whole packet is read */ /* test if whole packet is read */
if (asf_st->frag_offset == asf_st->pkt.size) { if (asf_st->frag_offset == asf_st->pkt.size) {
// workaround for macroshit radio DVR-MS files // workaround for macroshit radio DVR-MS files
if (s->streams[asf->stream_index]->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && if (s->streams[asf->stream_index]->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
asf_st->pkt.size > 100) { asf_st->pkt.size > 100) {
int i; int i;
for (i = 0; i < asf_st->pkt.size && !asf_st->pkt.data[i]; i++) for (i = 0; i < asf_st->pkt.size && !asf_st->pkt.data[i]; i++)
@ -1492,7 +1492,7 @@ static void skip_to_key(AVFormatContext *s)
for (i = 0; i < 128; i++) { for (i = 0; i < 128; i++) {
int j = asf->asfid2avid[i]; int j = asf->asfid2avid[i];
ASFStream *asf_st = &asf->streams[i]; ASFStream *asf_st = &asf->streams[i];
if (j < 0 || s->streams[j]->codec->codec_type != AVMEDIA_TYPE_VIDEO) if (j < 0 || s->streams[j]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
continue; continue;
asf_st->skip_to_key = 1; asf_st->skip_to_key = 1;

30
libavformat/asfdec_o.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, NULL); tag = ff_get_bmp_header(pb, st, NULL);
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)) < 0) if ((ret = ff_get_wav_header(s, pb, st->codecpar, ts_data_len, 0)) < 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;
} }

82
libavformat/asfenc.c
Unescape View File

@ -392,7 +392,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
int header_size, n, extra_size, extra_size2, wav_extra_size; int header_size, n, extra_size, extra_size2, wav_extra_size;
int has_title, has_aspect_ratio = 0; int has_title, has_aspect_ratio = 0;
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;
@ -419,14 +419,14 @@ 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++) {
AVDictionaryEntry *entry; AVDictionaryEntry *entry;
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 ( enc->codec_type == AVMEDIA_TYPE_VIDEO if ( par->codec_type == AVMEDIA_TYPE_VIDEO
&& enc->sample_aspect_ratio.num > 0 && par->sample_aspect_ratio.num > 0
&& enc->sample_aspect_ratio.den > 0) && par->sample_aspect_ratio.den > 0)
has_aspect_ratio++; has_aspect_ratio++;
entry = av_dict_get(s->streams[n]->metadata, "language", NULL, 0); entry = av_dict_get(s->streams[n]->metadata, "language", NULL, 0);
@ -445,7 +445,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
asf->streams[n].stream_language_index = asf->nb_languages; asf->streams[n].stream_language_index = asf->nb_languages;
asf->nb_languages++; asf->nb_languages++;
} }
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) if (par->codec_type == AVMEDIA_TYPE_AUDIO)
audio_language_counts[asf->streams[n].stream_language_index]++; audio_language_counts[asf->streams[n].stream_language_index]++;
} }
} else { } else {
@ -509,7 +509,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
if (audio_language_counts[i]) { if (audio_language_counts[i]) {
avio_wl16(pb, audio_language_counts[i]); avio_wl16(pb, audio_language_counts[i]);
for (n = 0; n < s->nb_streams; n++) for (n = 0; n < s->nb_streams; n++)
if (asf->streams[n].stream_language_index == i && s->streams[n]->codec->codec_type == AVMEDIA_TYPE_AUDIO) if (asf->streams[n].stream_language_index == i && s->streams[n]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
avio_wl16(pb, n + 1); avio_wl16(pb, n + 1);
} }
} }
@ -523,10 +523,10 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
es_pos = put_header(pb, &ff_asf_extended_stream_properties_object); es_pos = put_header(pb, &ff_asf_extended_stream_properties_object);
avio_wl64(pb, 0); /* start time */ avio_wl64(pb, 0); /* start time */
avio_wl64(pb, 0); /* end time */ avio_wl64(pb, 0); /* end time */
avio_wl32(pb, s->streams[n]->codec->bit_rate); /* data bitrate bps */ avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* data bitrate bps */
avio_wl32(pb, 5000); /* buffer size ms */ avio_wl32(pb, 5000); /* buffer size ms */
avio_wl32(pb, 0); /* initial buffer fullness */ avio_wl32(pb, 0); /* initial buffer fullness */
avio_wl32(pb, s->streams[n]->codec->bit_rate); /* peak data bitrate */ avio_wl32(pb, s->streams[n]->codecpar->bit_rate); /* peak data bitrate */
avio_wl32(pb, 5000); /* maximum buffer size ms */ avio_wl32(pb, 5000); /* maximum buffer size ms */
avio_wl32(pb, 0); /* max initial buffer fullness */ avio_wl32(pb, 0); /* max initial buffer fullness */
avio_wl32(pb, 0); /* max object size */ avio_wl32(pb, 0); /* max object size */
@ -544,11 +544,11 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
hpos2 = put_header(pb, &ff_asf_metadata_header); hpos2 = put_header(pb, &ff_asf_metadata_header);
avio_wl16(pb, 2 * has_aspect_ratio); avio_wl16(pb, 2 * has_aspect_ratio);
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;
if ( enc->codec_type == AVMEDIA_TYPE_VIDEO if ( par->codec_type == AVMEDIA_TYPE_VIDEO
&& enc->sample_aspect_ratio.num > 0 && par->sample_aspect_ratio.num > 0
&& enc->sample_aspect_ratio.den > 0) { && par->sample_aspect_ratio.den > 0) {
AVRational sar = enc->sample_aspect_ratio; AVRational sar = par->sample_aspect_ratio;
avio_wl16(pb, 0); avio_wl16(pb, 0);
// the stream number is set like this below // the stream number is set like this below
avio_wl16(pb, n + 1); avio_wl16(pb, n + 1);
@ -620,11 +620,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 = 1; asf->streams[n].seq = 1;
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;
@ -632,14 +632,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) {
ff_put_guid(pb, &ff_asf_audio_stream); ff_put_guid(pb, &ff_asf_audio_stream);
ff_put_guid(pb, &ff_asf_audio_conceal_spread); ff_put_guid(pb, &ff_asf_audio_conceal_spread);
} else { } else {
@ -653,9 +653,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, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX); int wavsize = ff_put_wav_header(s, pb, par, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX);
if (wavsize < 0) if (wavsize < 0)
return -1; return -1;
@ -667,23 +667,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, 0); ff_put_bmp_header(pb, par, ff_codec_bmp_tags, 1, 0);
} }
end_header(pb, hpos); end_header(pb, hpos);
} }
@ -697,17 +697,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;
@ -732,14 +732,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);
@ -963,7 +963,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;
} }
@ -1053,7 +1053,7 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ASFStream *stream; ASFStream *stream;
AVCodecContext *codec; AVCodecParameters *par;
uint32_t packet_number; uint32_t packet_number;
int64_t pts; int64_t pts;
int start_sec; int start_sec;
@ -1061,10 +1061,10 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
int ret; int ret;
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;

6
libavformat/assdec.c
Unescape View File

@ -121,8 +121,8 @@ static int ass_read_header(AVFormatContext *s)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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_ASS; st->codecpar->codec_id = AV_CODEC_ID_ASS;
av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED); av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);
av_bprint_init(&line, 0, AV_BPRINT_SIZE_UNLIMITED); av_bprint_init(&line, 0, AV_BPRINT_SIZE_UNLIMITED);
@ -153,7 +153,7 @@ static int ass_read_header(AVFormatContext *s)
sub->duration = duration; sub->duration = duration;
} }
res = avpriv_bprint_to_extradata(st->codec, &header); res = ff_bprint_to_codecpar_extradata(st->codecpar, &header);
if (res < 0) if (res < 0)
goto end; goto end;

22
libavformat/assenc.c
Unescape View File

@ -46,16 +46,16 @@ 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;
if (s->nb_streams != 1 || avctx->codec_id != AV_CODEC_ID_ASS) { if (s->nb_streams != 1 || par->codec_id != AV_CODEC_ID_ASS) {
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 AVERROR(EINVAL); return AVERROR(EINVAL);
} }
avpriv_set_pts_info(s->streams[0], 64, 1, 100); avpriv_set_pts_info(s->streams[0], 64, 1, 100);
if (avctx->extradata_size > 0) { if (par->extradata_size > 0) {
size_t header_size = avctx->extradata_size; size_t header_size = par->extradata_size;
uint8_t *trailer = strstr(avctx->extradata, "\n[Events]"); uint8_t *trailer = strstr(par->extradata, "\n[Events]");
if (trailer) if (trailer)
trailer = strstr(trailer, "Format:"); trailer = strstr(trailer, "Format:");
@ -63,17 +63,17 @@ static int write_header(AVFormatContext *s)
trailer = strstr(trailer, "\n"); trailer = strstr(trailer, "\n");
if (trailer++) { if (trailer++) {
header_size = (trailer - avctx->extradata); header_size = (trailer - par->extradata);
ass->trailer_size = avctx->extradata_size - header_size; ass->trailer_size = par->extradata_size - header_size;
if (ass->trailer_size) if (ass->trailer_size)
ass->trailer = trailer; ass->trailer = trailer;
} }
avio_write(s->pb, avctx->extradata, header_size); avio_write(s->pb, par->extradata, header_size);
if (avctx->extradata[header_size - 1] != '\n') if (par->extradata[header_size - 1] != '\n')
avio_write(s->pb, "\r\n", 2); avio_write(s->pb, "\r\n", 2);
ass->ssa_mode = !strstr(avctx->extradata, "\n[V4+ Styles]"); ass->ssa_mode = !strstr(par->extradata, "\n[V4+ Styles]");
if (!strstr(avctx->extradata, "\n[Events]")) if (!strstr(par->extradata, "\n[Events]"))
avio_printf(s->pb, "[Events]\r\nFormat: %s, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\r\n", avio_printf(s->pb, "[Events]\r\nFormat: %s, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\r\n",
ass->ssa_mode ? "Marked" : "Layer"); ass->ssa_mode ? "Marked" : "Layer");
} }

26
libavformat/astdec.c
Unescape View File

@ -48,8 +48,8 @@ static int ast_read_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_skip(s->pb, 8); avio_skip(s->pb, 8);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = ff_codec_get_id(ff_codec_ast_tags, avio_rb16(s->pb)); st->codecpar->codec_id = ff_codec_get_id(ff_codec_ast_tags, avio_rb16(s->pb));
depth = avio_rb16(s->pb); depth = avio_rb16(s->pb);
if (depth != 16) { if (depth != 16) {
@ -57,23 +57,23 @@ static int ast_read_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->channels = avio_rb16(s->pb); st->codecpar->channels = avio_rb16(s->pb);
if (!st->codec->channels) if (!st->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (st->codec->channels == 2) if (st->codecpar->channels == 2)
st->codec->channel_layout = AV_CH_LAYOUT_STEREO; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
else if (st->codec->channels == 4) else if (st->codecpar->channels == 4)
st->codec->channel_layout = AV_CH_LAYOUT_4POINT0; st->codecpar->channel_layout = AV_CH_LAYOUT_4POINT0;
avio_skip(s->pb, 2); avio_skip(s->pb, 2);
st->codec->sample_rate = avio_rb32(s->pb); st->codecpar->sample_rate = avio_rb32(s->pb);
if (st->codec->sample_rate <= 0) if (st->codecpar->sample_rate <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->start_time = 0; st->start_time = 0;
st->duration = avio_rb32(s->pb); st->duration = avio_rb32(s->pb);
avio_skip(s->pb, 40); avio_skip(s->pb, 40);
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;
} }
@ -90,10 +90,10 @@ static int ast_read_packet(AVFormatContext *s, AVPacket *pkt)
pos = avio_tell(s->pb); pos = avio_tell(s->pb);
type = avio_rl32(s->pb); type = avio_rl32(s->pb);
size = avio_rb32(s->pb); size = avio_rb32(s->pb);
if (size > INT_MAX / s->streams[0]->codec->channels) if (size > INT_MAX / s->streams[0]->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
size *= s->streams[0]->codec->channels; size *= s->streams[0]->codecpar->channels;
if ((ret = avio_skip(s->pb, 24)) < 0) // padding if ((ret = avio_skip(s->pb, 24)) < 0) // padding
return ret; return ret;

22
libavformat/astenc.c
Unescape View File

@ -37,7 +37,7 @@ typedef struct ASTMuxContext {
#define CHECK_LOOP(type) \ #define CHECK_LOOP(type) \
if (ast->loop ## type > 0) { \ if (ast->loop ## type > 0) { \
ast->loop ## type = av_rescale_rnd(ast->loop ## type, enc->sample_rate, 1000, AV_ROUND_DOWN); \ ast->loop ## type = av_rescale_rnd(ast->loop ## type, par->sample_rate, 1000, AV_ROUND_DOWN); \
if (ast->loop ## type < 0 || ast->loop ## type > UINT_MAX) { \ if (ast->loop ## type < 0 || ast->loop ## type > UINT_MAX) { \
av_log(s, AV_LOG_ERROR, "Invalid loop" #type " value\n"); \ av_log(s, AV_LOG_ERROR, "Invalid loop" #type " value\n"); \
return AVERROR(EINVAL); \ return AVERROR(EINVAL); \
@ -48,22 +48,22 @@ static int ast_write_header(AVFormatContext *s)
{ {
ASTMuxContext *ast = s->priv_data; ASTMuxContext *ast = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc; AVCodecParameters *par;
unsigned int codec_tag; unsigned int codec_tag;
if (s->nb_streams == 1) { if (s->nb_streams == 1) {
enc = s->streams[0]->codec; par = s->streams[0]->codecpar;
} else { } else {
av_log(s, AV_LOG_ERROR, "only one stream is supported\n"); av_log(s, AV_LOG_ERROR, "only one stream is supported\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (enc->codec_id == AV_CODEC_ID_ADPCM_AFC) { if (par->codec_id == AV_CODEC_ID_ADPCM_AFC) {
av_log(s, AV_LOG_ERROR, "muxing ADPCM AFC is not implemented\n"); av_log(s, AV_LOG_ERROR, "muxing ADPCM AFC is not implemented\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
codec_tag = ff_codec_get_tag(ff_codec_ast_tags, enc->codec_id); codec_tag = ff_codec_get_tag(ff_codec_ast_tags, par->codec_id);
if (!codec_tag) { if (!codec_tag) {
av_log(s, AV_LOG_ERROR, "unsupported codec\n"); av_log(s, AV_LOG_ERROR, "unsupported codec\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -84,9 +84,9 @@ static int ast_write_header(AVFormatContext *s)
avio_wb32(pb, 0); /* File size minus header */ avio_wb32(pb, 0); /* File size minus header */
avio_wb16(pb, codec_tag); avio_wb16(pb, codec_tag);
avio_wb16(pb, 16); /* Bit depth */ avio_wb16(pb, 16); /* Bit depth */
avio_wb16(pb, enc->channels); avio_wb16(pb, par->channels);
avio_wb16(pb, 0); /* Loop flag */ avio_wb16(pb, 0); /* Loop flag */
avio_wb32(pb, enc->sample_rate); avio_wb32(pb, par->sample_rate);
ast->samples = avio_tell(pb); ast->samples = avio_tell(pb);
avio_wb32(pb, 0); /* Number of samples */ avio_wb32(pb, 0); /* Number of samples */
@ -110,8 +110,8 @@ static int ast_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ASTMuxContext *ast = s->priv_data; ASTMuxContext *ast = s->priv_data;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
int size = pkt->size / enc->channels; int size = pkt->size / par->channels;
if (s->streams[0]->nb_frames == 0) if (s->streams[0]->nb_frames == 0)
ast->fbs = size; ast->fbs = size;
@ -133,9 +133,9 @@ static int ast_write_trailer(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
ASTMuxContext *ast = s->priv_data; ASTMuxContext *ast = s->priv_data;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
int64_t file_size = avio_tell(pb); int64_t file_size = avio_tell(pb);
int64_t samples = (file_size - 64 - (32 * s->streams[0]->nb_frames)) / enc->block_align; /* PCM_S16BE_PLANAR */ int64_t samples = (file_size - 64 - (32 * s->streams[0]->nb_frames)) / par->block_align; /* PCM_S16BE_PLANAR */
av_log(s, AV_LOG_DEBUG, "total samples: %"PRId64"\n", samples); av_log(s, AV_LOG_DEBUG, "total samples: %"PRId64"\n", samples);

30
libavformat/au.c
Unescape View File

@ -132,16 +132,16 @@ 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->bits_per_coded_sample = bps; st->codecpar->bits_per_coded_sample = bps;
st->codec->bit_rate = channels * rate * bps; st->codecpar->bit_rate = channels * rate * bps;
st->codec->block_align = FFMAX(bps * st->codec->channels / 8, 1); st->codecpar->block_align = FFMAX(bps * st->codecpar->channels / 8, 1);
if (data_size != AU_UNKNOWN_SIZE) if (data_size != AU_UNKNOWN_SIZE)
st->duration = (((int64_t)data_size)<<3) / (st->codec->channels * (int64_t)bps); st->duration = (((int64_t)data_size)<<3) / (st->codecpar->channels * (int64_t)bps);
st->start_time = 0; st->start_time = 0;
avpriv_set_pts_info(st, 64, 1, rate); avpriv_set_pts_info(st, 64, 1, rate);
@ -168,15 +168,15 @@ AVInputFormat ff_au_demuxer = {
static int au_write_header(AVFormatContext *s) static int au_write_header(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if (s->nb_streams != 1) { if (s->nb_streams != 1) {
av_log(s, AV_LOG_ERROR, "only one stream is supported\n"); av_log(s, AV_LOG_ERROR, "only one stream is supported\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
enc->codec_tag = ff_codec_get_tag(codec_au_tags, enc->codec_id); par->codec_tag = ff_codec_get_tag(codec_au_tags, par->codec_id);
if (!enc->codec_tag) { if (!par->codec_tag) {
av_log(s, AV_LOG_ERROR, "unsupported codec\n"); av_log(s, AV_LOG_ERROR, "unsupported codec\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -184,9 +184,9 @@ static int au_write_header(AVFormatContext *s)
ffio_wfourcc(pb, ".snd"); /* magic number */ ffio_wfourcc(pb, ".snd"); /* magic number */
avio_wb32(pb, AU_HEADER_SIZE); /* header size */ avio_wb32(pb, AU_HEADER_SIZE); /* 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);
avio_wb64(pb, 0); /* annotation field */ avio_wb64(pb, 0); /* annotation field */
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_freep(&aic->fifo); av_fifo_freep(&aic->fifo);
} }
} }
@ -55,9 +55,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 AVERROR(EINVAL); return AVERROR(EINVAL);
@ -111,7 +111,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)
@ -131,7 +131,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 ((ret = interleave_new_audio_packet(s, &new_pkt, i, flush)) > 0) { while ((ret = interleave_new_audio_packet(s, &new_pkt, i, flush)) > 0) {
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

@ -872,18 +872,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
@ -990,6 +985,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

179
libavformat/avidec.c
Unescape View File

@ -385,11 +385,11 @@ static void avi_read_nikon(AVFormatContext *s, uint64_t end)
} }
} }
static int avi_extract_stream_metadata(AVStream *st) static int avi_extract_stream_metadata(AVFormatContext *s, AVStream *st)
{ {
GetByteContext gb; GetByteContext gb;
uint8_t *data = st->codec->extradata; uint8_t *data = st->codecpar->extradata;
int data_size = st->codec->extradata_size; int data_size = st->codecpar->extradata_size;
int tag, offset; int tag, offset;
if (!data || data_size < 8) { if (!data || data_size < 8) {
@ -408,13 +408,13 @@ static int avi_extract_stream_metadata(AVStream *st)
bytestream2_init(&gb, data + offset, data_size - offset); bytestream2_init(&gb, data + offset, data_size - offset);
// decode EXIF tags from IFD, AVI is always little-endian // decode EXIF tags from IFD, AVI is always little-endian
return avpriv_exif_decode_ifd(st->codec, &gb, 1, 0, &st->metadata); return avpriv_exif_decode_ifd(s, &gb, 1, 0, &st->metadata);
break; break;
case MKTAG('C', 'A', 'S', 'I'): case MKTAG('C', 'A', 'S', 'I'):
avpriv_request_sample(st->codec, "RIFF stream data tag type CASI (%u)", tag); avpriv_request_sample(s, "RIFF stream data tag type CASI (%u)", tag);
break; break;
case MKTAG('Z', 'o', 'r', 'a'): case MKTAG('Z', 'o', 'r', 'a'):
avpriv_request_sample(st->codec, "RIFF stream data tag type Zora (%u)", tag); avpriv_request_sample(s, "RIFF stream data tag type Zora (%u)", tag);
break; break;
default: default:
break; break;
@ -456,12 +456,12 @@ static int calculate_bitrate(AVFormatContext *s)
for (j = 0; j < st->nb_index_entries; j++) for (j = 0; j < st->nb_index_entries; j++)
len += st->index_entries[j].size; len += st->index_entries[j].size;
if (st->nb_index_entries < 2 || st->codec->bit_rate > 0) if (st->nb_index_entries < 2 || st->codecpar->bit_rate > 0)
continue; continue;
duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp; duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp;
bitrate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num); bitrate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num);
if (bitrate <= INT_MAX && bitrate > 0) { if (bitrate <= INT_MAX && bitrate > 0) {
st->codec->bit_rate = bitrate; st->codecpar->bit_rate = bitrate;
} }
} }
return 1; return 1;
@ -603,8 +603,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);
if (s->streams[0]->info) if (s->streams[0]->info)
av_freep(&s->streams[0]->info->duration_error); av_freep(&s->streams[0]->info->duration_error);
av_freep(&s->streams[0]->info); av_freep(&s->streams[0]->info);
@ -733,17 +733,17 @@ static int avi_read_header(AVFormatContext *s)
if (cur_pos < list_end) if (cur_pos < list_end)
size = FFMIN(size, list_end - cur_pos); size = FFMIN(size, list_end - cur_pos);
st = s->streams[stream_index]; st = s->streams[stream_index];
if (st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) { if (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN) {
avio_skip(pb, size); avio_skip(pb, size);
break; break;
} }
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;
} }
@ -751,40 +751,40 @@ 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) && size < avi->fsize) { if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
if (esize == size-1 && (esize&1)) { if (esize == size-1 && (esize&1)) {
st->codec->extradata_size = esize - 10 * 4; st->codecpar->extradata_size = esize - 10 * 4;
} else } else
st->codec->extradata_size = size - 10 * 4; st->codecpar->extradata_size = size - 10 * 4;
if (ff_get_extradata(st->codec, pb, st->codec->extradata_size) < 0) if (ff_get_extradata(st->codecpar, pb, st->codecpar->extradata_size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
// 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
* FFmpeg. */ * FFmpeg. */
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;
/* Exclude the "BottomUp" field from the palette */ /* Exclude the "BottomUp" field from the palette */
if (pal_src - st->codec->extradata >= 9 && if (pal_src - st->codecpar->extradata >= 9 &&
!memcmp(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9)) !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
pal_src -= 9; pal_src -= 9;
for (i = 0; i < pal_size / 4; i++) for (i = 0; i < pal_size / 4; i++)
ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i); ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i);
@ -793,17 +793,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);
@ -812,44 +812,44 @@ 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');
if (st->codec->codec_tag == MKTAG('V', 'S', 'S', 'H')) if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
if (st->codec->codec_id == AV_CODEC_ID_RV40) if (st->codecpar->codec_id == AV_CODEC_ID_RV40)
st->need_parsing = AVSTREAM_PARSE_NONE; st->need_parsing = AVSTREAM_PARSE_NONE;
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, 0); ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
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) */
@ -861,45 +861,45 @@ 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;
// The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
if (st->codec->codec_id == AV_CODEC_ID_FLAC) if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)
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;
ast->dshow_block_align = 0; ast->dshow_block_align = 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;
} }
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_FLAC || st->codecpar->codec_id == AV_CODEC_ID_FLAC ||
st->codec->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) { st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align); av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
ast->dshow_block_align = 0; ast->dshow_block_align = 0;
} }
if (st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 || if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 || st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
st->codec->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) { st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
av_log(s, AV_LOG_DEBUG, "overriding sample_size\n"); av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
ast->sample_size = 0; ast->sample_size = 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->request_probe= 1; st->request_probe= 1;
avio_skip(pb, size); avio_skip(pb, size);
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;
} }
@ -907,8 +907,8 @@ static int avi_read_header(AVFormatContext *s)
break; break;
case MKTAG('s', 't', 'r', 'd'): case MKTAG('s', 't', 'r', 'd'):
if (stream_index >= (unsigned)s->nb_streams if (stream_index >= (unsigned)s->nb_streams
|| s->streams[stream_index]->codec->extradata_size || s->streams[stream_index]->codecpar->extradata_size
|| s->streams[stream_index]->codec->codec_tag == MKTAG('H','2','6','4')) { || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {
avio_skip(pb, size); avio_skip(pb, size);
} else { } else {
uint64_t cur_pos = avio_tell(pb); uint64_t cur_pos = avio_tell(pb);
@ -917,14 +917,14 @@ static int avi_read_header(AVFormatContext *s)
st = s->streams[stream_index]; st = s->streams[stream_index];
if (size<(1<<30)) { if (size<(1<<30)) {
if (ff_get_extradata(st->codec, pb, size) < 0) if (ff_get_extradata(st->codecpar, pb, size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
avio_r8(pb); avio_r8(pb);
ret = avi_extract_stream_metadata(st); ret = avi_extract_stream_metadata(s, st);
if (ret < 0) { if (ret < 0) {
av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n"); av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
} }
@ -1014,8 +1014,8 @@ fail:
if (dict_entry && !strcmp(dict_entry->value, "PotEncoder")) if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
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_id == AV_CODEC_ID_MPEG1VIDEO if ( st->codecpar->codec_id == AV_CODEC_ID_MPEG1VIDEO
|| st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) || st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO)
st->need_parsing = AVSTREAM_PARSE_FULL; st->need_parsing = AVSTREAM_PARSE_FULL;
} }
@ -1094,8 +1094,7 @@ static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
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);
} }
@ -1232,8 +1231,8 @@ start_sync:
// workaround for broken small-file-bug402.avi // workaround for broken small-file-bug402.avi
if ( d[2] == 'w' && d[3] == 'b' if ( d[2] == 'w' && d[3] == 'b'
&& n == 0 && 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 || !ast1->prefix_count) && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
) { ) {
@ -1443,8 +1442,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(s, st, pkt)) { !st->codecpar->codec_tag && read_gab2_sub(s, st, pkt)) {
ast->frame_offset++; ast->frame_offset++;
avi->stream_index = -1; avi->stream_index = -1;
ast->remaining = 0; ast->remaining = 0;
@ -1468,7 +1467,7 @@ resync:
size); size);
pkt->stream_index = avi->stream_index; pkt->stream_index = avi->stream_index;
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) { if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
AVIndexEntry *e; AVIndexEntry *e;
int index; int index;
@ -1479,7 +1478,7 @@ resync:
if (index == st->nb_index_entries-1) { if (index == st->nb_index_entries-1) {
int key=1; int key=1;
uint32_t state=-1; uint32_t state=-1;
if (st->codec->codec_id == AV_CODEC_ID_MPEG4) { if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4) {
const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256); const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
while (ptr < end) { while (ptr < end) {
ptr = avpriv_find_start_code(ptr, end, &state); ptr = avpriv_find_start_code(ptr, end, &state);
@ -1557,7 +1556,7 @@ static int avi_read_idx1(AVFormatContext *s, int size)
avi->stream_index = -1; avi->stream_index = -1;
avio_seek(pb, idx1_pos, SEEK_SET); avio_seek(pb, idx1_pos, SEEK_SET);
if (s->nb_streams == 1 && s->streams[0]->codec->codec_tag == AV_RL32("MMES")) { if (s->nb_streams == 1 && s->streams[0]->codecpar->codec_tag == AV_RL32("MMES")) {
first_packet_pos = 0; first_packet_pos = 0;
data_offset = avi->movi_list; data_offset = avi->movi_list;
} }
@ -1661,7 +1660,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));
} }
} }
@ -1847,7 +1846,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;
// av_assert1(st2->codec->block_align); // av_assert1(st2->codecpar->block_align);
av_assert0(fabs(av_q2d(st2->time_base) - ast2->scale / (double)ast2->rate) < av_q2d(st2->time_base) * 0.00000001); av_assert0(fabs(av_q2d(st2->time_base) - ast2->scale / (double)ast2->rate) < av_q2d(st2->time_base) * 0.00000001);
index = av_index_search_timestamp(st2, index = av_index_search_timestamp(st2,
av_rescale_q(timestamp, av_rescale_q(timestamp,
@ -1856,7 +1855,7 @@ static int avi_read_seek(AVFormatContext *s, int stream_index,
FFMAX(ast2->sample_size, 1), FFMAX(ast2->sample_size, 1),
flags | flags |
AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_BACKWARD |
(st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0)); (st2->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
if (index < 0) if (index < 0)
index = 0; index = 0;
ast2->seek_pos = st2->index_entries[index].pos; ast2->seek_pos = st2->index_entries[index].pos;
@ -1872,7 +1871,7 @@ static int avi_read_seek(AVFormatContext *s, int stream_index,
index = av_index_search_timestamp( index = av_index_search_timestamp(
st2, st2,
av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1), av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
flags | AVSEEK_FLAG_BACKWARD | (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0)); flags | AVSEEK_FLAG_BACKWARD | (st2->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
if (index < 0) if (index < 0)
index = 0; index = 0;
while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min) while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)

160
libavformat/avienc.c
Unescape View File

@ -180,21 +180,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;
av_assert0(avist->frames_hdr_strm); av_assert0(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) {
@ -211,7 +211,7 @@ static void write_odml_master(AVFormatContext *s, int stream_index)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st = s->streams[stream_index]; AVStream *st = s->streams[stream_index];
AVCodecContext *enc = st->codec; AVCodecParameters *par = st->codecpar;
AVIStream *avist = st->priv_data; AVIStream *avist = st->priv_data;
unsigned char tag[5]; unsigned char tag[5];
int j; int j;
@ -225,7 +225,7 @@ static void write_odml_master(AVFormatContext *s, int stream_index)
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, stream_index, enc->codec_type)); ffio_wfourcc(pb, avi_stream2fourcc(tag, stream_index, 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. */
@ -239,7 +239,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;
@ -266,12 +266,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];
} }
} }
@ -295,9 +295,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);
@ -310,18 +310,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;
@ -339,9 +339,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);
avist->strh_flags_offset = avio_tell(pb); avist->strh_flags_offset = avio_tell(pb);
@ -352,14 +352,14 @@ static int avi_write_header(AVFormatContext *s)
ff_parse_specific_params(st, &au_byterate, &au_ssize, &au_scale); ff_parse_specific_params(st, &au_byterate, &au_ssize, &au_scale);
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
&& au_byterate > 1000LL*au_scale) { && au_byterate > 1000LL*au_scale) {
au_byterate = 600; au_byterate = 600;
au_scale = 1; au_scale = 1;
} }
avpriv_set_pts_info(st, 64, au_scale, au_byterate); avpriv_set_pts_info(st, 64, au_scale, au_byterate);
if (enc->codec_id == AV_CODEC_ID_XSUB) if (par->codec_id == AV_CODEC_ID_XSUB)
au_scale = au_byterate = 0; au_scale = au_byterate = 0;
avio_wl32(pb, au_scale); /* scale */ avio_wl32(pb, au_scale); /* scale */
@ -375,57 +375,57 @@ 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, is set to largest chunk size in avi_write_trailer */ /* suggested buffer size, is set to largest chunk size in avi_write_trailer */
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) {
int ret, flags; int ret, flags;
enum AVPixelFormat pix_fmt; enum AVPixelFormat pix_fmt;
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:
/* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */ /* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */
if ( !enc->codec_tag if ( !par->codec_tag
&& enc->codec_id == AV_CODEC_ID_RAWVIDEO && par->codec_id == AV_CODEC_ID_RAWVIDEO
&& enc->pix_fmt == AV_PIX_FMT_RGB555LE && par->format == AV_PIX_FMT_RGB555LE
&& enc->bits_per_coded_sample == 15) && par->bits_per_coded_sample == 15)
enc->bits_per_coded_sample = 16; par->bits_per_coded_sample = 16;
avist->pal_offset = avio_tell(pb) + 40; avist->pal_offset = avio_tell(pb) + 40;
ff_put_bmp_header(pb, enc, ff_codec_bmp_tags, 0, 0); ff_put_bmp_header(pb, par, ff_codec_bmp_tags, 0, 0);
pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi, pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
enc->bits_per_coded_sample); par->bits_per_coded_sample);
if ( !enc->codec_tag if ( !par->codec_tag
&& enc->codec_id == AV_CODEC_ID_RAWVIDEO && par->codec_id == AV_CODEC_ID_RAWVIDEO
&& enc->pix_fmt != pix_fmt && par->format != pix_fmt
&& enc->pix_fmt != AV_PIX_FMT_NONE) && par->format != AV_PIX_FMT_NONE)
av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to avi, output file will be unreadable\n", av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to avi, output file will be unreadable\n",
av_get_pix_fmt_name(enc->pix_fmt)); av_get_pix_fmt_name(par->format));
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
flags = (avi->write_channel_mask == 0) ? FF_PUT_WAV_HEADER_SKIP_CHANNELMASK : 0; flags = (avi->write_channel_mask == 0) ? FF_PUT_WAV_HEADER_SKIP_CHANNELMASK : 0;
if ((ret = ff_put_wav_header(pb, enc, flags)) < 0) if ((ret = ff_put_wav_header(s, pb, par, flags)) < 0)
return ret; return ret;
break; break;
default: default:
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"Invalid or not supported codec type '%s' found in the input\n", "Invalid or not supported codec type '%s' found in the input\n",
(char *)av_x_if_null(av_get_media_type_string(enc->codec_type), "?")); (char *)av_x_if_null(av_get_media_type_string(par->codec_type), "?"));
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
ff_end_tag(pb, strf); ff_end_tag(pb, strf);
@ -433,7 +433,7 @@ static int avi_write_header(AVFormatContext *s)
ff_riff_write_info_tag(s->pb, "strn", t->value); ff_riff_write_info_tag(s->pb, "strn", t->value);
t = NULL; t = NULL;
} }
if (enc->codec_id == AV_CODEC_ID_XSUB if (par->codec_id == AV_CODEC_ID_XSUB
&& (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) { && (t = av_dict_get(s->streams[i]->metadata, "language", NULL, 0))) {
const char* langstr = av_convert_lang_to(t->value, AV_LANG_ISO639_1); const char* langstr = av_convert_lang_to(t->value, AV_LANG_ISO639_1);
t = NULL; t = NULL;
@ -451,13 +451,13 @@ static int avi_write_header(AVFormatContext *s)
write_odml_master(s, i); write_odml_master(s, i);
} }
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);
@ -465,18 +465,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, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num)); avio_wl32(pb, (2LL*st->time_base.den + st->time_base.num - 1) / (2LL * st->time_base.num));
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);
@ -544,7 +544,7 @@ static void update_odml_entry(AVFormatContext *s, int stream_index, int64_t ix,
avio_wl64(pb, ix); /* qwOffset */ avio_wl64(pb, ix); /* qwOffset */
avio_wl32(pb, size); /* dwSize */ avio_wl32(pb, size); /* dwSize */
ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale); ff_parse_specific_params(s->streams[stream_index], &au_byterate, &au_ssize, &au_scale);
if (s->streams[stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) { if (s->streams[stream_index]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && au_ssize > 0) {
uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset); uint32_t audio_segm_size = (avist->audio_strm_length - avist->indexes.audio_strm_offset);
if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) { if ((audio_segm_size % au_ssize > 0) && !avist->sample_requested) {
avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames"); avpriv_request_sample(s, "OpenDML index duration for audio packets with partial frames");
@ -586,7 +586,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; int64_t ix;
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 */
@ -654,7 +654,7 @@ static int avi_write_idx1(AVFormatContext *s)
ffio_wfourcc(pb, ie->tag); ffio_wfourcc(pb, ie->tag);
else { else {
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);
@ -673,11 +673,11 @@ static int avi_write_idx1(AVFormatContext *s)
static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts) static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
{ {
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;
ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index); ff_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);
while (enc->block_align == 0 && dts != AV_NOPTS_VALUE && while (par->block_align == 0 && dts != AV_NOPTS_VALUE &&
dts > avist->packet_count && enc->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) { dts > avist->packet_count && par->codec_id != AV_CODEC_ID_XSUB && avist->packet_count) {
AVPacket empty_packet; AVPacket empty_packet;
if (dts - avist->packet_count > 60000) { if (dts - avist->packet_count > 60000) {
@ -699,10 +699,10 @@ static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
static int avi_write_packet(AVFormatContext *s, AVPacket *pkt) static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
{ {
const int stream_index = pkt->stream_index; const int stream_index = pkt->stream_index;
AVCodecContext *enc = s->streams[stream_index]->codec; AVCodecParameters *par = s->streams[stream_index]->codecpar;
int ret; int ret;
if (enc->codec_id == AV_CODEC_ID_H264 && enc->codec_tag == MKTAG('H','2','6','4') && pkt->size) { if (par->codec_id == AV_CODEC_ID_H264 && par->codec_tag == MKTAG('H','2','6','4') && pkt->size) {
ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt); ret = ff_check_h264_startcode(s, s->streams[stream_index], pkt);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -714,27 +714,27 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
if (!pkt->size) if (!pkt->size)
return avi_write_packet_internal(s, pkt); /* Passthrough */ return avi_write_packet_internal(s, pkt); /* Passthrough */
if (enc->codec_type == AVMEDIA_TYPE_VIDEO) { if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
AVIStream *avist = s->streams[stream_index]->priv_data; AVIStream *avist = s->streams[stream_index]->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVPacket *opkt = pkt; AVPacket *opkt = pkt;
if (enc->codec_id == AV_CODEC_ID_RAWVIDEO && enc->codec_tag == 0) { if (par->codec_id == AV_CODEC_ID_RAWVIDEO && par->codec_tag == 0) {
int64_t bpc = enc->bits_per_coded_sample != 15 ? enc->bits_per_coded_sample : 16; int64_t bpc = par->bits_per_coded_sample != 15 ? par->bits_per_coded_sample : 16;
int expected_stride = ((enc->width * bpc + 31) >> 5)*4; int expected_stride = ((par->width * bpc + 31) >> 5)*4;
ret = ff_reshuffle_raw_rgb(s, &pkt, enc, expected_stride); ret = ff_reshuffle_raw_rgb(s, &pkt, par, expected_stride);
if (ret < 0) if (ret < 0)
return ret; return ret;
} else } else
ret = 0; ret = 0;
if (enc->pix_fmt == AV_PIX_FMT_PAL8) { if (par->format == AV_PIX_FMT_PAL8) {
int ret2 = ff_get_packet_palette(s, opkt, ret, avist->palette); int ret2 = ff_get_packet_palette(s, opkt, ret, avist->palette);
if (ret2 < 0) if (ret2 < 0)
return ret2; return ret2;
if (ret2) { if (ret2) {
int pal_size = 1 << enc->bits_per_coded_sample; int pal_size = 1 << par->bits_per_coded_sample;
int pc_tag, i; int pc_tag, i;
av_assert0(enc->bits_per_coded_sample >= 0 && enc->bits_per_coded_sample <= 8); av_assert0(par->bits_per_coded_sample >= 0 && par->bits_per_coded_sample <= 8);
if (pb->seekable && avist->pal_offset) { if (pb->seekable && avist->pal_offset) {
int64_t cur_offset = avio_tell(pb); int64_t cur_offset = avio_tell(pb);
@ -749,7 +749,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
} }
if (memcmp(avist->palette, avist->old_palette, pal_size * 4)) { if (memcmp(avist->palette, avist->old_palette, pal_size * 4)) {
unsigned char tag[5]; unsigned char tag[5];
avi_stream2fourcc(tag, stream_index, enc->codec_type); avi_stream2fourcc(tag, stream_index, par->codec_type);
tag[2] = 'p'; tag[3] = 'c'; tag[2] = 'p'; tag[3] = 'c';
if (s->pb->seekable) { if (s->pb->seekable) {
int ret; int ret;
@ -797,7 +797,7 @@ static int avi_write_packet_internal(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;
if (pkt->dts != AV_NOPTS_VALUE) if (pkt->dts != AV_NOPTS_VALUE)
avist->last_dts = pkt->dts + pkt->duration; avist->last_dts = pkt->dts + pkt->duration;
@ -817,10 +817,10 @@ static int avi_write_packet_internal(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) {
@ -868,15 +868,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;
} }
} }

60
libavformat/avisynth.c
Unescape View File

@ -232,10 +232,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->avg_frame_rate = (AVRational) { avs->vi->fps_numerator, st->avg_frame_rate = (AVRational) { avs->vi->fps_numerator,
avs->vi->fps_denominator }; avs->vi->fps_denominator };
@ -247,38 +247,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,
@ -307,27 +307,27 @@ 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->duration = avs->vi->num_audio_samples; st->duration = avs->vi->num_audio_samples;
avpriv_set_pts_info(st, 64, 1, avs->vi->audio_samples_per_second); avpriv_set_pts_info(st, 64, 1, avs->vi->audio_samples_per_second);
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,
@ -636,7 +636,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);
@ -678,7 +678,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) ||

18
libavformat/avr.c
Unescape View File

@ -46,22 +46,22 @@ static int avr_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;
avio_skip(s->pb, 4); // magic avio_skip(s->pb, 4); // magic
avio_skip(s->pb, 8); // sample_name avio_skip(s->pb, 8); // sample_name
chan = avio_rb16(s->pb); chan = avio_rb16(s->pb);
if (!chan) { if (!chan) {
st->codec->channels = 1; st->codecpar->channels = 1;
} else if (chan == 0xFFFFu) { } else if (chan == 0xFFFFu) {
st->codec->channels = 2; st->codecpar->channels = 2;
} else { } else {
avpriv_request_sample(s, "chan %d", chan); avpriv_request_sample(s, "chan %d", chan);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
st->codec->bits_per_coded_sample = bps = avio_rb16(s->pb); st->codecpar->bits_per_coded_sample = bps = avio_rb16(s->pb);
sign = avio_rb16(s->pb); sign = avio_rb16(s->pb);
@ -69,21 +69,21 @@ static int avr_read_header(AVFormatContext *s)
avio_skip(s->pb, 2); // midi avio_skip(s->pb, 2); // midi
avio_skip(s->pb, 1); // replay speed avio_skip(s->pb, 1); // replay speed
st->codec->sample_rate = avio_rb24(s->pb); st->codecpar->sample_rate = avio_rb24(s->pb);
avio_skip(s->pb, 4 * 3); avio_skip(s->pb, 4 * 3);
avio_skip(s->pb, 2 * 3); avio_skip(s->pb, 2 * 3);
avio_skip(s->pb, 20); avio_skip(s->pb, 20);
avio_skip(s->pb, 64); avio_skip(s->pb, 64);
st->codec->codec_id = ff_get_pcm_codec_id(bps, 0, 1, sign); st->codecpar->codec_id = ff_get_pcm_codec_id(bps, 0, 1, sign);
if (st->codec->codec_id == AV_CODEC_ID_NONE) { if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
avpriv_request_sample(s, "Bps %d and sign %d", bps, sign); avpriv_request_sample(s, "Bps %d and sign %d", bps, sign);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
st->codec->block_align = bps * st->codec->channels / 8; st->codecpar->block_align = bps * st->codecpar->channels / 8;
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/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;
#if FF_API_R_FRAME_RATE #if FF_API_R_FRAME_RATE
avs->st_video->r_frame_rate = avs->st_video->r_frame_rate =
@ -203,7 +203,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

@ -116,13 +116,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)
@ -245,13 +245,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);
} }

42
libavformat/bfi.c
Unescape View File

@ -75,38 +75,38 @@ 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);
if (!vstream->codec->extradata) if (!vstream->codecpar->extradata)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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;
vstream->nb_frames = vstream->nb_frames =
vstream->duration = bfi->nframes; vstream->duration = bfi->nframes;
/* 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;
} }

40
libavformat/bink.c
Unescape View File

@ -89,7 +89,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);
@ -107,8 +107,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);
@ -121,15 +121,15 @@ 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;
if ((vst->codec->codec_tag & 0xFFFFFF) == MKTAG('K', 'B', '2', 0)) { if ((vst->codecpar->codec_tag & 0xFFFFFF) == MKTAG('K', 'B', '2', 0)) {
av_log(s, AV_LOG_WARNING, "Bink 2 video is not implemented\n"); av_log(s, AV_LOG_WARNING, "Bink 2 video is not implemented\n");
vst->codec->codec_id = AV_CODEC_ID_NONE; vst->codecpar->codec_id = AV_CODEC_ID_NONE;
} }
if (ff_get_extradata(vst->codec, pb, 4) < 0) if (ff_get_extradata(vst->codecpar, pb, 4) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
bink->num_audio_tracks = avio_rl32(pb); bink->num_audio_tracks = avio_rl32(pb);
@ -148,23 +148,23 @@ 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;
} }
if (ff_alloc_extradata(ast->codec, 4)) if (ff_alloc_extradata(ast->codecpar, 4))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
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++)
@ -250,7 +250,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);

86
libavformat/bintext.c
Unescape View File

@ -54,12 +54,12 @@ static AVStream * init_stream(AVFormatContext *s)
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_tag = 0; st->codecpar->codec_tag = 0;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
if (!bin->width) { if (!bin->width) {
st->codec->width = (80<<3); st->codecpar->width = (80<<3);
st->codec->height = (25<<4); st->codecpar->height = (25<<4);
} }
avpriv_set_pts_info(st, 60, bin->framerate.den, bin->framerate.num); avpriv_set_pts_info(st, 60, bin->framerate.den, bin->framerate.num);
@ -74,9 +74,9 @@ static AVStream * init_stream(AVFormatContext *s)
/** /**
* Given filesize and width, calculate height (assume font_height of 16) * Given filesize and width, calculate height (assume font_height of 16)
*/ */
static void calculate_height(AVCodecContext *avctx, uint64_t fsize) static void calculate_height(AVCodecParameters *par, uint64_t fsize)
{ {
avctx->height = (fsize / ((avctx->width>>3)*2)) << 4; par->height = (fsize / ((par->width>>3)*2)) << 4;
} }
#endif #endif
@ -119,11 +119,11 @@ static int next_tag_read(AVFormatContext *avctx, uint64_t *fsize)
return 0; return 0;
} }
static void predict_width(AVCodecContext *avctx, uint64_t fsize, int got_width) static void predict_width(AVCodecParameters *par, uint64_t fsize, int got_width)
{ {
/** attempt to guess width */ /** attempt to guess width */
if (!got_width) if (!got_width)
avctx->width = fsize > 4000 ? (160<<3) : (80<<3); par->width = fsize > 4000 ? (160<<3) : (80<<3);
} }
static int bintext_read_header(AVFormatContext *s) static int bintext_read_header(AVFormatContext *s)
@ -134,12 +134,12 @@ static int bintext_read_header(AVFormatContext *s)
AVStream *st = init_stream(s); AVStream *st = init_stream(s);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_BINTEXT; st->codecpar->codec_id = AV_CODEC_ID_BINTEXT;
if (ff_alloc_extradata(st->codec, 2)) if (ff_alloc_extradata(st->codecpar, 2))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata[0] = 16; st->codecpar->extradata[0] = 16;
st->codec->extradata[1] = 0; st->codecpar->extradata[1] = 0;
if (pb->seekable) { if (pb->seekable) {
int got_width = 0; int got_width = 0;
@ -147,8 +147,8 @@ static int bintext_read_header(AVFormatContext *s)
if (ff_sauce_read(s, &bin->fsize, &got_width, 0) < 0) if (ff_sauce_read(s, &bin->fsize, &got_width, 0) < 0)
next_tag_read(s, &bin->fsize); next_tag_read(s, &bin->fsize);
if (!bin->width) { if (!bin->width) {
predict_width(st->codec, bin->fsize, got_width); predict_width(st->codecpar, bin->fsize, got_width);
calculate_height(st->codec, bin->fsize); calculate_height(st->codecpar, bin->fsize);
} }
avio_seek(pb, 0, SEEK_SET); avio_seek(pb, 0, SEEK_SET);
} }
@ -179,30 +179,30 @@ static int xbin_read_header(AVFormatContext *s)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_skip(pb, 5); avio_skip(pb, 5);
st->codec->width = avio_rl16(pb)<<3; st->codecpar->width = avio_rl16(pb)<<3;
st->codec->height = avio_rl16(pb); st->codecpar->height = avio_rl16(pb);
fontheight = avio_r8(pb); fontheight = avio_r8(pb);
st->codec->height *= fontheight; st->codecpar->height *= fontheight;
flags = avio_r8(pb); flags = avio_r8(pb);
st->codec->extradata_size = 2; st->codecpar->extradata_size = 2;
if ((flags & BINTEXT_PALETTE)) if ((flags & BINTEXT_PALETTE))
st->codec->extradata_size += 48; st->codecpar->extradata_size += 48;
if ((flags & BINTEXT_FONT)) if ((flags & BINTEXT_FONT))
st->codec->extradata_size += fontheight * (flags & 0x10 ? 512 : 256); st->codecpar->extradata_size += fontheight * (flags & 0x10 ? 512 : 256);
st->codec->codec_id = flags & 4 ? AV_CODEC_ID_XBIN : AV_CODEC_ID_BINTEXT; st->codecpar->codec_id = flags & 4 ? AV_CODEC_ID_XBIN : AV_CODEC_ID_BINTEXT;
if (ff_alloc_extradata(st->codec, st->codec->extradata_size)) if (ff_alloc_extradata(st->codecpar, st->codecpar->extradata_size))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata[0] = fontheight; st->codecpar->extradata[0] = fontheight;
st->codec->extradata[1] = flags; st->codecpar->extradata[1] = flags;
if (avio_read(pb, st->codec->extradata + 2, st->codec->extradata_size - 2) < 0) if (avio_read(pb, st->codecpar->extradata + 2, st->codecpar->extradata_size - 2) < 0)
return AVERROR(EIO); return AVERROR(EIO);
if (pb->seekable) { if (pb->seekable) {
bin->fsize = avio_size(pb) - 9 - st->codec->extradata_size; bin->fsize = avio_size(pb) - 9 - st->codecpar->extradata_size;
ff_sauce_read(s, &bin->fsize, NULL, 0); ff_sauce_read(s, &bin->fsize, NULL, 0);
avio_seek(pb, 9 + st->codec->extradata_size, SEEK_SET); avio_seek(pb, 9 + st->codecpar->extradata_size, SEEK_SET);
} }
return 0; return 0;
@ -222,28 +222,28 @@ static int adf_read_header(AVFormatContext *s)
st = init_stream(s); st = init_stream(s);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_BINTEXT; st->codecpar->codec_id = AV_CODEC_ID_BINTEXT;
if (ff_alloc_extradata(st->codec, 2 + 48 + 4096)) if (ff_alloc_extradata(st->codecpar, 2 + 48 + 4096))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata[0] = 16; st->codecpar->extradata[0] = 16;
st->codec->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT; st->codecpar->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT;
if (avio_read(pb, st->codec->extradata + 2, 24) < 0) if (avio_read(pb, st->codecpar->extradata + 2, 24) < 0)
return AVERROR(EIO); return AVERROR(EIO);
avio_skip(pb, 144); avio_skip(pb, 144);
if (avio_read(pb, st->codec->extradata + 2 + 24, 24) < 0) if (avio_read(pb, st->codecpar->extradata + 2 + 24, 24) < 0)
return AVERROR(EIO); return AVERROR(EIO);
if (avio_read(pb, st->codec->extradata + 2 + 48, 4096) < 0) if (avio_read(pb, st->codecpar->extradata + 2 + 48, 4096) < 0)
return AVERROR(EIO); return AVERROR(EIO);
if (pb->seekable) { if (pb->seekable) {
int got_width = 0; int got_width = 0;
bin->fsize = avio_size(pb) - 1 - 192 - 4096; bin->fsize = avio_size(pb) - 1 - 192 - 4096;
st->codec->width = 80<<3; st->codecpar->width = 80<<3;
ff_sauce_read(s, &bin->fsize, &got_width, 0); ff_sauce_read(s, &bin->fsize, &got_width, 0);
if (!bin->width) if (!bin->width)
calculate_height(st->codec, bin->fsize); calculate_height(st->codecpar, bin->fsize);
avio_seek(pb, 1 + 192 + 4096, SEEK_SET); avio_seek(pb, 1 + 192 + 4096, SEEK_SET);
} }
return 0; return 0;
@ -277,24 +277,24 @@ static int idf_read_header(AVFormatContext *s)
st = init_stream(s); st = init_stream(s);
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->codec_id = AV_CODEC_ID_IDF; st->codecpar->codec_id = AV_CODEC_ID_IDF;
if (ff_alloc_extradata(st->codec, 2 + 48 + 4096)) if (ff_alloc_extradata(st->codecpar, 2 + 48 + 4096))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
st->codec->extradata[0] = 16; st->codecpar->extradata[0] = 16;
st->codec->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT; st->codecpar->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT;
avio_seek(pb, avio_size(pb) - 4096 - 48, SEEK_SET); avio_seek(pb, avio_size(pb) - 4096 - 48, SEEK_SET);
if (avio_read(pb, st->codec->extradata + 2 + 48, 4096) < 0) if (avio_read(pb, st->codecpar->extradata + 2 + 48, 4096) < 0)
return AVERROR(EIO); return AVERROR(EIO);
if (avio_read(pb, st->codec->extradata + 2, 48) < 0) if (avio_read(pb, st->codecpar->extradata + 2, 48) < 0)
return AVERROR(EIO); return AVERROR(EIO);
bin->fsize = avio_size(pb) - 12 - 4096 - 48; bin->fsize = avio_size(pb) - 12 - 4096 - 48;
ff_sauce_read(s, &bin->fsize, &got_width, 0); ff_sauce_read(s, &bin->fsize, &got_width, 0);
if (!bin->width) if (!bin->width)
calculate_height(st->codec, bin->fsize); calculate_height(st->codecpar, bin->fsize);
avio_seek(pb, 12, SEEK_SET); avio_seek(pb, 12, SEEK_SET);
return 0; return 0;
} }

18
libavformat/bit.c
Unescape View File

@ -55,11 +55,11 @@ static int 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_G729; st->codecpar->codec_id=AV_CODEC_ID_G729;
st->codec->sample_rate=8000; st->codecpar->sample_rate=8000;
st->codec->block_align = 16; st->codecpar->block_align = 16;
st->codec->channels=1; st->codecpar->channels=1;
avpriv_set_pts_info(st, 64, 1, 100); avpriv_set_pts_info(st, 64, 1, 100);
return 0; return 0;
@ -117,16 +117,16 @@ AVInputFormat ff_bit_demuxer = {
#if CONFIG_MUXERS #if CONFIG_MUXERS
static int write_header(AVFormatContext *s) static int write_header(AVFormatContext *s)
{ {
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if ((enc->codec_id != AV_CODEC_ID_G729) || enc->channels != 1) { if ((par->codec_id != AV_CODEC_ID_G729) || par->channels != 1) {
av_log(s, AV_LOG_ERROR, av_log(s, AV_LOG_ERROR,
"only codec g729 with 1 channel is supported by this format\n"); "only codec g729 with 1 channel is supported by this format\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
enc->bits_per_coded_sample = 16; par->bits_per_coded_sample = 16;
enc->block_align = (enc->bits_per_coded_sample * enc->channels) >> 3; par->block_align = (par->bits_per_coded_sample * par->channels) >> 3;
return 0; return 0;
} }

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;

12
libavformat/boadec.c
Unescape View File

@ -46,16 +46,16 @@ static int 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_MS; st->codecpar->codec_id = AV_CODEC_ID_ADPCM_MS;
avio_rl32(s->pb); avio_rl32(s->pb);
avio_rl32(s->pb); avio_rl32(s->pb);
st->codec->sample_rate = avio_rl32(s->pb); st->codecpar->sample_rate = avio_rl32(s->pb);
st->codec->channels = avio_rl32(s->pb); st->codecpar->channels = avio_rl32(s->pb);
s->internal->data_offset = avio_rl32(s->pb); s->internal->data_offset = avio_rl32(s->pb);
avio_r8(s->pb); avio_r8(s->pb);
st->codec->block_align = st->codec->channels * avio_rl32(s->pb); st->codecpar->block_align = st->codecpar->channels * avio_rl32(s->pb);
avio_seek(s->pb, s->internal->data_offset, SEEK_SET); avio_seek(s->pb, s->internal->data_offset, SEEK_SET);
@ -66,7 +66,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVStream *st = s->streams[0]; AVStream *st = s->streams[0];
return av_get_packet(s->pb, pkt, st->codec->block_align); return av_get_packet(s->pb, pkt, st->codecpar->block_align);
} }
AVInputFormat ff_boa_demuxer = { AVInputFormat ff_boa_demuxer = {

60
libavformat/brstm.c
Unescape View File

@ -99,7 +99,7 @@ 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_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
avio_skip(s->pb, 4); avio_skip(s->pb, 4);
@ -197,15 +197,15 @@ static int read_header(AVFormatContext *s)
} }
loop = avio_r8(s->pb); // loop flag loop = avio_r8(s->pb); // loop flag
st->codec->codec_id = codec; st->codecpar->codec_id = codec;
st->codec->channels = avio_r8(s->pb); st->codecpar->channels = avio_r8(s->pb);
if (!st->codec->channels) if (!st->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
avio_skip(s->pb, 1); // padding avio_skip(s->pb, 1); // padding
st->codec->sample_rate = bfstm ? read32(s) : read16(s); st->codecpar->sample_rate = bfstm ? read32(s) : read16(s);
if (st->codec->sample_rate <= 0) if (st->codecpar->sample_rate <= 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (!bfstm) if (!bfstm)
@ -214,7 +214,7 @@ static int read_header(AVFormatContext *s)
if (loop) { if (loop) {
if (av_dict_set_int(&s->metadata, "loop_start", if (av_dict_set_int(&s->metadata, "loop_start",
av_rescale(read32(s), AV_TIME_BASE, av_rescale(read32(s), AV_TIME_BASE,
st->codec->sample_rate), st->codecpar->sample_rate),
0) < 0) 0) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} else { } else {
@ -223,7 +223,7 @@ static int read_header(AVFormatContext *s)
st->start_time = 0; st->start_time = 0;
st->duration = read32(s); st->duration = read32(s);
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
if (!bfstm) if (!bfstm)
start = read32(s); start = read32(s);
@ -235,14 +235,14 @@ static int read_header(AVFormatContext *s)
} }
b->block_size = read32(s); b->block_size = read32(s);
if (b->block_size > UINT32_MAX / st->codec->channels) if (b->block_size > UINT32_MAX / st->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
b->samples_per_block = read32(s); b->samples_per_block = read32(s);
b->last_block_used_bytes = read32(s); b->last_block_used_bytes = read32(s);
b->last_block_samples = read32(s); b->last_block_samples = read32(s);
b->last_block_size = read32(s); b->last_block_size = read32(s);
if (b->last_block_size > UINT32_MAX / st->codec->channels) if (b->last_block_size > UINT32_MAX / st->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (b->last_block_used_bytes > b->last_block_size) if (b->last_block_used_bytes > b->last_block_size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -255,16 +255,16 @@ static int read_header(AVFormatContext *s)
if (!bfstm) if (!bfstm)
toffset = read32(s) + 16LL; toffset = read32(s) + 16LL;
else else
toffset = toffset + read32(s) + st->codec->channels * 8 - 8; toffset = toffset + read32(s) + st->codecpar->channels * 8 - 8;
if (toffset > size) if (toffset > size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
avio_skip(s->pb, pos + toffset - avio_tell(s->pb)); avio_skip(s->pb, pos + toffset - avio_tell(s->pb));
b->table = av_mallocz(32 * st->codec->channels); b->table = av_mallocz(32 * st->codecpar->channels);
if (!b->table) if (!b->table)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
for (ch = 0; ch < st->codec->channels; ch++) { for (ch = 0; ch < st->codecpar->channels; ch++) {
if (avio_read(s->pb, b->table + ch * 32, 32) != 32) { if (avio_read(s->pb, b->table + ch * 32, 32) != 32) {
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto fail; goto fail;
@ -295,7 +295,7 @@ static int read_header(AVFormatContext *s)
codec != AV_CODEC_ID_ADPCM_THP_LE) codec != AV_CODEC_ID_ADPCM_THP_LE)
goto skip; goto skip;
asize = b->block_count * st->codec->channels * 4; asize = b->block_count * st->codecpar->channels * 4;
if (size < asize) { if (size < asize) {
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;
goto fail; goto fail;
@ -357,7 +357,7 @@ fail:
static int read_packet(AVFormatContext *s, AVPacket *pkt) static int read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVCodecContext *codec = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
BRSTMDemuxContext *b = s->priv_data; BRSTMDemuxContext *b = s->priv_data;
uint32_t samples, size, skip = 0; uint32_t samples, size, skip = 0;
int ret, i; int ret, i;
@ -385,8 +385,8 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR_EOF; return AVERROR_EOF;
} }
if (codec->codec_id == AV_CODEC_ID_ADPCM_THP || if (par->codec_id == AV_CODEC_ID_ADPCM_THP ||
codec->codec_id == AV_CODEC_ID_ADPCM_THP_LE) { par->codec_id == AV_CODEC_ID_ADPCM_THP_LE) {
uint8_t *dst; uint8_t *dst;
if (!b->adpc) { if (!b->adpc) {
@ -394,30 +394,30 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (!b->table) { if (!b->table) {
b->table = av_mallocz(32 * codec->channels); b->table = av_mallocz(32 * par->channels);
if (!b->table) if (!b->table)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if (size > (INT_MAX - 32 - 4) || if (size > (INT_MAX - 32 - 4) ||
(32 + 4 + size) > (INT_MAX / codec->channels) || (32 + 4 + size) > (INT_MAX / par->channels) ||
(32 + 4 + size) * codec->channels > INT_MAX - 8) (32 + 4 + size) * par->channels > INT_MAX - 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
if (av_new_packet(pkt, 8 + (32 + 4 + size) * codec->channels) < 0) if (av_new_packet(pkt, 8 + (32 + 4 + size) * par->channels) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
dst = pkt->data; dst = pkt->data;
if (codec->codec_id == AV_CODEC_ID_ADPCM_THP_LE) { if (par->codec_id == AV_CODEC_ID_ADPCM_THP_LE) {
bytestream_put_le32(&dst, size * codec->channels); bytestream_put_le32(&dst, size * par->channels);
bytestream_put_le32(&dst, samples); bytestream_put_le32(&dst, samples);
} else { } else {
bytestream_put_be32(&dst, size * codec->channels); bytestream_put_be32(&dst, size * par->channels);
bytestream_put_be32(&dst, samples); bytestream_put_be32(&dst, samples);
} }
bytestream_put_buffer(&dst, b->table, 32 * codec->channels); bytestream_put_buffer(&dst, b->table, 32 * par->channels);
bytestream_put_buffer(&dst, b->adpc + 4 * codec->channels * bytestream_put_buffer(&dst, b->adpc + 4 * par->channels *
(b->current_block - 1), 4 * codec->channels); (b->current_block - 1), 4 * par->channels);
for (i = 0; i < codec->channels; i++) { for (i = 0; i < par->channels; i++) {
ret = avio_read(s->pb, dst, size); ret = avio_read(s->pb, dst, size);
dst += size; dst += size;
avio_skip(s->pb, skip); avio_skip(s->pb, skip);
@ -428,7 +428,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
} }
pkt->duration = samples; pkt->duration = samples;
} else { } else {
size *= codec->channels; size *= par->channels;
ret = av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
} }
@ -449,7 +449,7 @@ static int read_seek(AVFormatContext *s, int stream_index,
timestamp /= b->samples_per_block; timestamp /= b->samples_per_block;
ret = avio_seek(s->pb, b->data_start + timestamp * b->block_size * ret = avio_seek(s->pb, b->data_start + timestamp * b->block_size *
st->codec->channels, SEEK_SET); st->codecpar->channels, SEEK_SET);
if (ret < 0) if (ret < 0)
return ret; return ret;

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_rl32(pb); st->codecpar->codec_tag = avio_rl32(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 == MKTAG('l','p','c','m')) if (st->codecpar->codec_tag == MKTAG('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
@ -134,8 +134,8 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
if (ff_alloc_extradata(st->codec, ALAC_HEADER)) if (ff_alloc_extradata(st->codecpar, ALAC_HEADER))
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.
@ -145,30 +145,30 @@ 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;
} }
if (avio_read(pb, st->codec->extradata, ALAC_HEADER) != ALAC_HEADER) { if (avio_read(pb, st->codecpar->extradata, ALAC_HEADER) != ALAC_HEADER) {
av_log(s, AV_LOG_ERROR, "failed to read kuki header\n"); av_log(s, AV_LOG_ERROR, "failed to read kuki header\n");
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
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);
if (avio_read(pb, &st->codec->extradata[24], ALAC_NEW_KUKI - 12) != ALAC_NEW_KUKI - 12) { if (avio_read(pb, &st->codecpar->extradata[24], ALAC_NEW_KUKI - 12) != ALAC_NEW_KUKI - 12) {
av_log(s, AV_LOG_ERROR, "failed to read new kuki header\n"); av_log(s, AV_LOG_ERROR, "failed to read new kuki header\n");
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avio_skip(pb, size - ALAC_NEW_KUKI); avio_skip(pb, size - ALAC_NEW_KUKI);
} }
} else { } else {
av_freep(&st->codec->extradata); av_freep(&st->codecpar->extradata);
if (ff_get_extradata(st->codec, pb, size) < 0) if (ff_get_extradata(st->codecpar, pb, size) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@ -323,15 +323,15 @@ 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 && st->duration > 0) { } else if (st->nb_index_entries && st->duration > 0) {
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 "
"block size or frame size are variable.\n"); "block size or frame size are variable.\n");
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 */

50
libavformat/cafenc.c
Unescape View File

@ -102,19 +102,19 @@ static uint32_t samples_per_packet(enum AVCodecID codec_id, int channels, int bl
static int caf_write_header(AVFormatContext *s) static int caf_write_header(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
CAFContext *caf = s->priv_data; CAFContext *caf = s->priv_data;
AVDictionaryEntry *t = NULL; AVDictionaryEntry *t = NULL;
unsigned int codec_tag = ff_codec_get_tag(ff_codec_caf_tags, enc->codec_id); unsigned int codec_tag = ff_codec_get_tag(ff_codec_caf_tags, par->codec_id);
int64_t chunk_size = 0; int64_t chunk_size = 0;
int frame_size = enc->frame_size; int frame_size = par->frame_size;
if (s->nb_streams != 1) { if (s->nb_streams != 1) {
av_log(s, AV_LOG_ERROR, "CAF files have exactly one stream\n"); av_log(s, AV_LOG_ERROR, "CAF files have exactly one stream\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
switch (enc->codec_id) { switch (par->codec_id) {
case AV_CODEC_ID_AAC: case AV_CODEC_ID_AAC:
av_log(s, AV_LOG_ERROR, "muxing codec currently unsupported\n"); av_log(s, AV_LOG_ERROR, "muxing codec currently unsupported\n");
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
@ -125,13 +125,13 @@ static int caf_write_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (!enc->block_align && !pb->seekable) { if (!par->block_align && !pb->seekable) {
av_log(s, AV_LOG_ERROR, "Muxing variable packet size not supported on non seekable output\n"); av_log(s, AV_LOG_ERROR, "Muxing variable packet size not supported on non seekable output\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if (enc->codec_id != AV_CODEC_ID_MP3 || frame_size != 576) if (par->codec_id != AV_CODEC_ID_MP3 || frame_size != 576)
frame_size = samples_per_packet(enc->codec_id, enc->channels, enc->block_align); frame_size = samples_per_packet(par->codec_id, par->channels, par->block_align);
ffio_wfourcc(pb, "caff"); //< mFileType ffio_wfourcc(pb, "caff"); //< mFileType
avio_wb16(pb, 1); //< mFileVersion avio_wb16(pb, 1); //< mFileVersion
@ -139,26 +139,26 @@ static int caf_write_header(AVFormatContext *s)
ffio_wfourcc(pb, "desc"); //< Audio Description chunk ffio_wfourcc(pb, "desc"); //< Audio Description chunk
avio_wb64(pb, 32); //< mChunkSize avio_wb64(pb, 32); //< mChunkSize
avio_wb64(pb, av_double2int(enc->sample_rate)); //< mSampleRate avio_wb64(pb, av_double2int(par->sample_rate)); //< mSampleRate
avio_wl32(pb, codec_tag); //< mFormatID avio_wl32(pb, codec_tag); //< mFormatID
avio_wb32(pb, codec_flags(enc->codec_id)); //< mFormatFlags avio_wb32(pb, codec_flags(par->codec_id)); //< mFormatFlags
avio_wb32(pb, enc->block_align); //< mBytesPerPacket avio_wb32(pb, par->block_align); //< mBytesPerPacket
avio_wb32(pb, frame_size); //< mFramesPerPacket avio_wb32(pb, frame_size); //< mFramesPerPacket
avio_wb32(pb, enc->channels); //< mChannelsPerFrame avio_wb32(pb, par->channels); //< mChannelsPerFrame
avio_wb32(pb, av_get_bits_per_sample(enc->codec_id)); //< mBitsPerChannel avio_wb32(pb, av_get_bits_per_sample(par->codec_id)); //< mBitsPerChannel
if (enc->channel_layout) { if (par->channel_layout) {
ffio_wfourcc(pb, "chan"); ffio_wfourcc(pb, "chan");
avio_wb64(pb, 12); avio_wb64(pb, 12);
ff_mov_write_chan(pb, enc->channel_layout); ff_mov_write_chan(pb, par->channel_layout);
} }
if (enc->codec_id == AV_CODEC_ID_ALAC) { if (par->codec_id == AV_CODEC_ID_ALAC) {
ffio_wfourcc(pb, "kuki"); ffio_wfourcc(pb, "kuki");
avio_wb64(pb, 12 + enc->extradata_size); avio_wb64(pb, 12 + par->extradata_size);
avio_write(pb, "\0\0\0\14frmaalac", 12); avio_write(pb, "\0\0\0\14frmaalac", 12);
avio_write(pb, enc->extradata, enc->extradata_size); avio_write(pb, par->extradata, par->extradata_size);
} else if (enc->codec_id == AV_CODEC_ID_AMR_NB) { } else if (par->codec_id == AV_CODEC_ID_AMR_NB) {
ffio_wfourcc(pb, "kuki"); ffio_wfourcc(pb, "kuki");
avio_wb64(pb, 29); avio_wb64(pb, 29);
avio_write(pb, "\0\0\0\14frmasamr", 12); avio_write(pb, "\0\0\0\14frmasamr", 12);
@ -169,10 +169,10 @@ static int caf_write_header(AVFormatContext *s)
avio_wb16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */ avio_wb16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */
avio_w8(pb, 0x00); /* Mode change period (no restriction) */ avio_w8(pb, 0x00); /* Mode change period (no restriction) */
avio_w8(pb, 0x01); /* Frames per sample */ avio_w8(pb, 0x01); /* Frames per sample */
} else if (enc->codec_id == AV_CODEC_ID_QDM2) { } else if (par->codec_id == AV_CODEC_ID_QDM2) {
ffio_wfourcc(pb, "kuki"); ffio_wfourcc(pb, "kuki");
avio_wb64(pb, enc->extradata_size); avio_wb64(pb, par->extradata_size);
avio_write(pb, enc->extradata, enc->extradata_size); avio_write(pb, par->extradata, par->extradata_size);
} }
ff_standardize_creation_time(s); ff_standardize_creation_time(s);
@ -204,7 +204,7 @@ static int caf_write_packet(AVFormatContext *s, AVPacket *pkt)
CAFContext *caf = s->priv_data; CAFContext *caf = s->priv_data;
avio_write(s->pb, pkt->data, pkt->size); avio_write(s->pb, pkt->data, pkt->size);
if (!s->streams[0]->codec->block_align) { if (!s->streams[0]->codecpar->block_align) {
void *pkt_sizes = caf->pkt_sizes; void *pkt_sizes = caf->pkt_sizes;
int i, alloc_size = caf->size_entries_used + 5; int i, alloc_size = caf->size_entries_used + 5;
if (alloc_size < 0) { if (alloc_size < 0) {
@ -233,7 +233,7 @@ static int caf_write_trailer(AVFormatContext *s)
{ {
CAFContext *caf = s->priv_data; CAFContext *caf = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVCodecContext *enc = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
if (pb->seekable) { if (pb->seekable) {
int64_t file_size = avio_tell(pb); int64_t file_size = avio_tell(pb);
@ -241,11 +241,11 @@ static int caf_write_trailer(AVFormatContext *s)
avio_seek(pb, caf->data, SEEK_SET); avio_seek(pb, caf->data, SEEK_SET);
avio_wb64(pb, file_size - caf->data - 8); avio_wb64(pb, file_size - caf->data - 8);
avio_seek(pb, file_size, SEEK_SET); avio_seek(pb, file_size, SEEK_SET);
if (!enc->block_align) { if (!par->block_align) {
ffio_wfourcc(pb, "pakt"); ffio_wfourcc(pb, "pakt");
avio_wb64(pb, caf->size_entries_used + 24); avio_wb64(pb, caf->size_entries_used + 24);
avio_wb64(pb, caf->packets); ///< mNumberPackets avio_wb64(pb, caf->packets); ///< mNumberPackets
avio_wb64(pb, caf->packets * samples_per_packet(enc->codec_id, enc->channels, enc->block_align)); ///< mNumberValidFrames avio_wb64(pb, caf->packets * samples_per_packet(par->codec_id, par->channels, par->block_align)); ///< mNumberValidFrames
avio_wb32(pb, 0); ///< mPrimingFrames avio_wb32(pb, 0); ///< mPrimingFrames
avio_wb32(pb, 0); ///< mRemainderFrames avio_wb32(pb, 0); ///< mRemainderFrames
avio_write(pb, caf->pkt_sizes, caf->size_entries_used); avio_write(pb, caf->pkt_sizes, caf->size_entries_used);

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

@ -150,17 +150,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);
@ -179,11 +179,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;
if (audio_size + video_size && cdxl->filesize > 0) { if (audio_size + video_size && cdxl->filesize > 0) {
frames = cdxl->filesize / (audio_size + video_size); frames = cdxl->filesize / (audio_size + video_size);

6
libavformat/chromaprint.c
Unescape View File

@ -85,17 +85,17 @@ static int write_header(AVFormatContext *s)
st = s->streams[0]; st = s->streams[0];
if (st->codec->channels > 2) { if (st->codecpar->channels > 2) {
av_log(s, AV_LOG_ERROR, "Only up to 2 channels are supported\n"); av_log(s, AV_LOG_ERROR, "Only up to 2 channels are supported\n");
goto fail; goto fail;
} }
if (st->codec->sample_rate < 1000) { if (st->codecpar->sample_rate < 1000) {
av_log(s, AV_LOG_ERROR, "Sampling rate must be at least 1000\n"); av_log(s, AV_LOG_ERROR, "Sampling rate must be at least 1000\n");
goto fail; goto fail;
} }
if (!chromaprint_start(cpr->ctx, st->codec->sample_rate, st->codec->channels)) { if (!chromaprint_start(cpr->ctx, st->codecpar->sample_rate, st->codecpar->channels)) {
av_log(s, AV_LOG_ERROR, "Failed to start chromaprint\n"); av_log(s, AV_LOG_ERROR, "Failed to start chromaprint\n");
goto fail; goto fail;
} }

34
libavformat/cinedec.c
Unescape View File

@ -101,9 +101,9 @@ static int cine_read_header(AVFormatContext *avctx)
st = avformat_new_stream(avctx, NULL); st = avformat_new_stream(avctx, 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_RAWVIDEO; st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
st->codec->codec_tag = 0; st->codecpar->codec_tag = 0;
/* CINEFILEHEADER structure */ /* CINEFILEHEADER structure */
avio_skip(pb, 4); // Type, Headersize avio_skip(pb, 4); // Type, Headersize
@ -127,8 +127,8 @@ static int cine_read_header(AVFormatContext *avctx)
/* BITMAPINFOHEADER structure */ /* BITMAPINFOHEADER structure */
avio_seek(pb, offImageHeader, SEEK_SET); avio_seek(pb, offImageHeader, SEEK_SET);
avio_skip(pb, 4); //biSize avio_skip(pb, 4); //biSize
st->codec->width = avio_rl32(pb); st->codecpar->width = avio_rl32(pb);
st->codec->height = avio_rl32(pb); st->codecpar->height = avio_rl32(pb);
if (avio_rl16(pb) != 1) // biPlanes if (avio_rl16(pb) != 1) // biPlanes
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -144,7 +144,7 @@ static int cine_read_header(AVFormatContext *avctx)
vflip = 0; vflip = 0;
break; break;
case 0x100: /* BI_PACKED */ case 0x100: /* BI_PACKED */
st->codec->codec_tag = MKTAG('B', 'I', 'T', 0); st->codecpar->codec_tag = MKTAG('B', 'I', 'T', 0);
vflip = 1; vflip = 1;
break; break;
default: default:
@ -167,8 +167,8 @@ static int cine_read_header(AVFormatContext *avctx)
avio_skip(pb, 616); // Binning .. bFlipH avio_skip(pb, 616); // Binning .. bFlipH
if (!avio_rl32(pb) ^ vflip) { if (!avio_rl32(pb) ^ vflip) {
st->codec->extradata = av_strdup("BottomUp"); st->codecpar->extradata = av_strdup("BottomUp");
st->codec->extradata_size = 9; st->codecpar->extradata_size = 9;
} }
avio_skip(pb, 4); // Grid avio_skip(pb, 4); // Grid
@ -193,17 +193,17 @@ static int cine_read_header(AVFormatContext *avctx)
set_metadata_float(&st->metadata, "wbgain[0].b", av_int2float(avio_rl32(pb)), 1); set_metadata_float(&st->metadata, "wbgain[0].b", av_int2float(avio_rl32(pb)), 1);
avio_skip(pb, 36); // WBGain[1].. WBView avio_skip(pb, 36); // WBGain[1].. WBView
st->codec->bits_per_coded_sample = avio_rl32(pb); st->codecpar->bits_per_coded_sample = avio_rl32(pb);
if (compression == CC_RGB) { if (compression == CC_RGB) {
if (biBitCount == 8) { if (biBitCount == 8) {
st->codec->pix_fmt = AV_PIX_FMT_GRAY8; st->codecpar->format = AV_PIX_FMT_GRAY8;
} else if (biBitCount == 16) { } else if (biBitCount == 16) {
st->codec->pix_fmt = AV_PIX_FMT_GRAY16LE; st->codecpar->format = AV_PIX_FMT_GRAY16LE;
} else if (biBitCount == 24) { } else if (biBitCount == 24) {
st->codec->pix_fmt = AV_PIX_FMT_BGR24; st->codecpar->format = AV_PIX_FMT_BGR24;
} else if (biBitCount == 48) { } else if (biBitCount == 48) {
st->codec->pix_fmt = AV_PIX_FMT_BGR48LE; st->codecpar->format = AV_PIX_FMT_BGR48LE;
} else { } else {
avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount); avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -212,9 +212,9 @@ static int cine_read_header(AVFormatContext *avctx)
switch (CFA & 0xFFFFFF) { switch (CFA & 0xFFFFFF) {
case CFA_BAYER: case CFA_BAYER:
if (biBitCount == 8) { if (biBitCount == 8) {
st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG8; st->codecpar->format = AV_PIX_FMT_BAYER_GBRG8;
} else if (biBitCount == 16) { } else if (biBitCount == 16) {
st->codec->pix_fmt = AV_PIX_FMT_BAYER_GBRG16LE; st->codecpar->format = AV_PIX_FMT_BAYER_GBRG16LE;
} else { } else {
avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount); avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -222,9 +222,9 @@ static int cine_read_header(AVFormatContext *avctx)
break; break;
case CFA_BAYERFLIP: case CFA_BAYERFLIP:
if (biBitCount == 8) { if (biBitCount == 8) {
st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB8; st->codecpar->format = AV_PIX_FMT_BAYER_RGGB8;
} else if (biBitCount == 16) { } else if (biBitCount == 16) {
st->codec->pix_fmt = AV_PIX_FMT_BAYER_RGGB16LE; st->codecpar->format = AV_PIX_FMT_BAYER_RGGB16LE;
} else { } else {
avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount); avpriv_request_sample(avctx, "unsupported biBitCount %i", biBitCount);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;

70
libavformat/concatdec.c
Unescape View File

@ -35,6 +35,7 @@ typedef enum ConcatMatchMode {
typedef struct ConcatStream { typedef struct ConcatStream {
AVBitStreamFilterContext *bsf; AVBitStreamFilterContext *bsf;
AVCodecContext *avctx;
int out_stream_index; int out_stream_index;
} ConcatStream; } ConcatStream;
@ -164,19 +165,28 @@ static int copy_stream_props(AVStream *st, AVStream *source_st)
{ {
int ret; int ret;
if (st->codec->codec_id || !source_st->codec->codec_id) { if (st->codecpar->codec_id || !source_st->codecpar->codec_id) {
if (st->codec->extradata_size < source_st->codec->extradata_size) { if (st->codecpar->extradata_size < source_st->codecpar->extradata_size) {
ret = ff_alloc_extradata(st->codec, if (st->codecpar->extradata) {
source_st->codec->extradata_size); av_freep(&st->codecpar->extradata);
st->codecpar->extradata_size = 0;
}
ret = ff_alloc_extradata(st->codecpar,
source_st->codecpar->extradata_size);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
memcpy(st->codec->extradata, source_st->codec->extradata, memcpy(st->codecpar->extradata, source_st->codecpar->extradata,
source_st->codec->extradata_size); source_st->codecpar->extradata_size);
return 0; return 0;
} }
if ((ret = avcodec_copy_context(st->codec, source_st->codec)) < 0) if ((ret = avcodec_parameters_copy(st->codecpar, source_st->codecpar)) < 0)
return ret; return ret;
/* We don't want to carry around MP4-style extradata, since we are usoign a bsf anyway. */
if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
av_freep(&st->codecpar->extradata);
st->codecpar->extradata_size = 0;
}
st->r_frame_rate = source_st->r_frame_rate; st->r_frame_rate = source_st->r_frame_rate;
st->avg_frame_rate = source_st->avg_frame_rate; st->avg_frame_rate = source_st->avg_frame_rate;
st->time_base = source_st->time_base; st->time_base = source_st->time_base;
@ -192,9 +202,10 @@ static int detect_stream_specific(AVFormatContext *avf, int idx)
AVStream *st = cat->avf->streams[idx]; AVStream *st = cat->avf->streams[idx];
ConcatStream *cs = &cat->cur_file->streams[idx]; ConcatStream *cs = &cat->cur_file->streams[idx];
AVBitStreamFilterContext *bsf; AVBitStreamFilterContext *bsf;
int ret;
if (cat->auto_convert && st->codec->codec_id == AV_CODEC_ID_H264 && if (cat->auto_convert && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
(st->codec->extradata_size < 4 || AV_RB32(st->codec->extradata) != 1)) { (st->codecpar->extradata_size < 4 || AV_RB32(st->codecpar->extradata) != 1)) {
av_log(cat->avf, AV_LOG_INFO, av_log(cat->avf, AV_LOG_INFO,
"Auto-inserting h264_mp4toannexb bitstream filter\n"); "Auto-inserting h264_mp4toannexb bitstream filter\n");
if (!(bsf = av_bitstream_filter_init("h264_mp4toannexb"))) { if (!(bsf = av_bitstream_filter_init("h264_mp4toannexb"))) {
@ -203,6 +214,17 @@ static int detect_stream_specific(AVFormatContext *avf, int idx)
return AVERROR_BSF_NOT_FOUND; return AVERROR_BSF_NOT_FOUND;
} }
cs->bsf = bsf; cs->bsf = bsf;
cs->avctx = avcodec_alloc_context3(NULL);
if (!cs->avctx)
return AVERROR(ENOMEM);
ret = avcodec_parameters_to_context(cs->avctx, st->codecpar);
if (ret < 0) {
avcodec_free_context(&cs->avctx);
return ret;
}
} }
return 0; return 0;
} }
@ -338,15 +360,21 @@ static int open_file(AVFormatContext *avf, unsigned fileno)
static int concat_read_close(AVFormatContext *avf) static int concat_read_close(AVFormatContext *avf)
{ {
ConcatContext *cat = avf->priv_data; ConcatContext *cat = avf->priv_data;
unsigned i; unsigned i, j;
if (cat->avf)
avformat_close_input(&cat->avf);
for (i = 0; i < cat->nb_files; i++) { for (i = 0; i < cat->nb_files; i++) {
av_freep(&cat->files[i].url); av_freep(&cat->files[i].url);
for (j = 0; j < cat->avf->nb_streams; j++) {
if (cat->files[i].streams[j].avctx)
avcodec_free_context(&cat->files[i].streams[j].avctx);
if (cat->files[i].streams[j].bsf)
av_bitstream_filter_close(cat->files[i].streams[j].bsf);
}
av_freep(&cat->files[i].streams); av_freep(&cat->files[i].streams);
av_dict_free(&cat->files[i].metadata); av_dict_free(&cat->files[i].metadata);
} }
if (cat->avf)
avformat_close_input(&cat->avf);
av_freep(&cat->files); av_freep(&cat->files);
return 0; return 0;
} }
@ -499,7 +527,8 @@ static int filter_packet(AVFormatContext *avf, ConcatStream *cs, AVPacket *pkt)
av_assert0(cs->out_stream_index >= 0); av_assert0(cs->out_stream_index >= 0);
for (bsf = cs->bsf; bsf; bsf = bsf->next) { for (bsf = cs->bsf; bsf; bsf = bsf->next) {
pkt2 = *pkt; pkt2 = *pkt;
ret = av_bitstream_filter_filter(bsf, st->codec, NULL,
ret = av_bitstream_filter_filter(bsf, cs->avctx, NULL,
&pkt2.data, &pkt2.size, &pkt2.data, &pkt2.size,
pkt->data, pkt->size, pkt->data, pkt->size,
!!(pkt->flags & AV_PKT_FLAG_KEY)); !!(pkt->flags & AV_PKT_FLAG_KEY));
@ -507,6 +536,21 @@ static int filter_packet(AVFormatContext *avf, ConcatStream *cs, AVPacket *pkt)
av_packet_unref(pkt); av_packet_unref(pkt);
return ret; return ret;
} }
if (cs->avctx->extradata_size > st->codecpar->extradata_size) {
int eret;
if (st->codecpar->extradata)
av_freep(&st->codecpar->extradata);
eret = ff_alloc_extradata(st->codecpar, cs->avctx->extradata_size);
if (eret < 0) {
av_packet_unref(pkt);
return AVERROR(ENOMEM);
}
st->codecpar->extradata_size = cs->avctx->extradata_size;
memcpy(st->codecpar->extradata, cs->avctx->extradata, cs->avctx->extradata_size);
}
av_assert0(pkt2.buf); av_assert0(pkt2.buf);
if (ret == 0 && pkt2.data != pkt->data) { if (ret == 0 && pkt2.data != pkt->data) {
if ((ret = av_copy_packet(&pkt2, pkt)) < 0) { if ((ret = av_copy_packet(&pkt2, pkt)) < 0) {

62
libavformat/dashenc.c
Unescape View File

@ -109,19 +109,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)
@ -132,17 +132,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')) {
@ -151,8 +151,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) {
@ -515,10 +515,10 @@ static int write_manifest(AVFormatContext *s, int final)
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\"", 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\"", i, os->codec_str, os->bandwidth_str, st->codecpar->width, st->codecpar->height);
if (st->avg_frame_rate.num) if (st->avg_frame_rate.num)
avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den); avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den);
avio_printf(out, ">\n"); avio_printf(out, ">\n");
@ -534,11 +534,11 @@ static int write_manifest(AVFormatContext *s, int final)
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");
} }
@ -598,9 +598,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;
s->streams[i]->codec->bit_rate :
s->streams[i]->codec->rc_max_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);
@ -630,7 +628,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;
@ -670,7 +668,7 @@ 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) {
AVRational avg_frame_rate = s->streams[i]->avg_frame_rate; AVRational avg_frame_rate = s->streams[i]->avg_frame_rate;
if (avg_frame_rate.num > 0) { if (avg_frame_rate.num > 0) {
if (av_cmp_q(avg_frame_rate, c->min_frame_rate) < 0) if (av_cmp_q(avg_frame_rate, c->min_frame_rate) < 0)
@ -681,11 +679,11 @@ static int dash_write_header(AVFormatContext *s)
c->ambiguous_frame_rate = 1; c->ambiguous_frame_rate = 1;
} }
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;
@ -774,24 +772,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;
} }
@ -817,7 +815,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.
@ -896,7 +894,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;
@ -921,7 +919,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;
} }

22
libavformat/dcstr.c
Unescape View File

@ -39,35 +39,35 @@ static int dcstr_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->channels = avio_rl32(s->pb); st->codecpar->channels = avio_rl32(s->pb);
st->codec->sample_rate = avio_rl32(s->pb); st->codecpar->sample_rate = avio_rl32(s->pb);
codec = avio_rl32(s->pb); codec = avio_rl32(s->pb);
align = avio_rl32(s->pb); align = avio_rl32(s->pb);
avio_skip(s->pb, 4); avio_skip(s->pb, 4);
st->duration = avio_rl32(s->pb); st->duration = avio_rl32(s->pb);
st->codec->channels *= avio_rl32(s->pb); st->codecpar->channels *= avio_rl32(s->pb);
if (!align || align > INT_MAX / st->codec->channels) if (!align || align > INT_MAX / st->codecpar->channels)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
st->codec->block_align = align * st->codec->channels; st->codecpar->block_align = align * st->codecpar->channels;
switch (codec) { switch (codec) {
case 4: st->codec->codec_id = AV_CODEC_ID_ADPCM_AICA; break; case 4: st->codecpar->codec_id = AV_CODEC_ID_ADPCM_AICA; break;
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;
default: avpriv_request_sample(s, "codec %X", codec); default: avpriv_request_sample(s, "codec %X", codec);
return AVERROR_PATCHWELCOME; return AVERROR_PATCHWELCOME;
} }
avio_skip(s->pb, 0x800 - avio_tell(s->pb)); avio_skip(s->pb, 0x800 - avio_tell(s->pb));
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 dcstr_read_packet(AVFormatContext *s, AVPacket *pkt) static int dcstr_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
AVCodecContext *codec = s->streams[0]->codec; AVCodecParameters *par = s->streams[0]->codecpar;
return av_get_packet(s->pb, pkt, codec->block_align); return av_get_packet(s->pb, pkt, par->block_align);
} }
AVInputFormat ff_dcstr_demuxer = { AVInputFormat ff_dcstr_demuxer = {

12
libavformat/dfa.c
Unescape View File

@ -56,10 +56,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");
@ -69,9 +69,9 @@ static int dfa_read_header(AVFormatContext *s)
avio_skip(pb, 128 - 16); // padding avio_skip(pb, 128 - 16); // padding
st->duration = frames; st->duration = frames;
if (ff_alloc_extradata(st->codec, 2)) if (ff_alloc_extradata(st->codecpar, 2))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
AV_WL16(st->codec->extradata, version); AV_WL16(st->codecpar->extradata, version);
if (version == 0x100) if (version == 0x100)
st->sample_aspect_ratio = (AVRational){2, 1}; st->sample_aspect_ratio = (AVRational){2, 1};

22
libavformat/dsfdec.c
Unescape View File

@ -99,29 +99,29 @@ static int dsf_read_header(AVFormatContext *s)
channel_type = avio_rl32(pb); channel_type = avio_rl32(pb);
if (channel_type < FF_ARRAY_ELEMS(dsf_channel_layout)) if (channel_type < FF_ARRAY_ELEMS(dsf_channel_layout))
st->codec->channel_layout = dsf_channel_layout[channel_type]; st->codecpar->channel_layout = dsf_channel_layout[channel_type];
if (!st->codec->channel_layout) if (!st->codecpar->channel_layout)
avpriv_request_sample(s, "channel type %i", channel_type); avpriv_request_sample(s, "channel type %i", channel_type);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->channels = avio_rl32(pb); st->codecpar->channels = avio_rl32(pb);
st->codec->sample_rate = avio_rl32(pb) / 8; st->codecpar->sample_rate = avio_rl32(pb) / 8;
switch(avio_rl32(pb)) { switch(avio_rl32(pb)) {
case 1: st->codec->codec_id = AV_CODEC_ID_DSD_LSBF_PLANAR; break; case 1: st->codecpar->codec_id = AV_CODEC_ID_DSD_LSBF_PLANAR; break;
case 8: st->codec->codec_id = AV_CODEC_ID_DSD_MSBF_PLANAR; break; case 8: st->codecpar->codec_id = AV_CODEC_ID_DSD_MSBF_PLANAR; break;
default: default:
avpriv_request_sample(s, "unknown most significant bit"); avpriv_request_sample(s, "unknown most significant bit");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
avio_skip(pb, 8); avio_skip(pb, 8);
st->codec->block_align = avio_rl32(pb); st->codecpar->block_align = avio_rl32(pb);
if (st->codec->block_align > INT_MAX / st->codec->channels) { if (st->codecpar->block_align > INT_MAX / st->codecpar->channels) {
avpriv_request_sample(s, "block_align overflow"); avpriv_request_sample(s, "block_align overflow");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->block_align *= st->codec->channels; st->codecpar->block_align *= st->codecpar->channels;
avio_skip(pb, 4); avio_skip(pb, 4);
/* data chunk */ /* data chunk */
@ -145,7 +145,7 @@ static int dsf_read_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR_EOF; return AVERROR_EOF;
pkt->stream_index = 0; pkt->stream_index = 0;
return av_get_packet(pb, pkt, FFMIN(dsf->data_end - pos, st->codec->block_align)); return av_get_packet(pb, pkt, FFMIN(dsf->data_end - pos, st->codecpar->block_align));
} }
AVInputFormat ff_dsf_demuxer = { AVInputFormat ff_dsf_demuxer = {

26
libavformat/dsicin.c
Unescape View File

@ -116,11 +116,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);
@ -129,14 +129,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;
} }

20
libavformat/dss.c
Unescape View File

@ -144,22 +144,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 = 11025; st->codecpar->sample_rate = 11025;
} 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 */
@ -235,7 +235,7 @@ static int dss_sp_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->duration = 264; pkt->duration = 264;
pkt->pos = pos; pkt->pos = pos;
pkt->stream_index = 0; pkt->stream_index = 0;
s->bit_rate = 8LL * ctx->packet_size * st->codec->sample_rate * 512 / (506 * pkt->duration); s->bit_rate = 8LL * ctx->packet_size * st->codecpar->sample_rate * 512 / (506 * pkt->duration);
if (ctx->counter < 0) { if (ctx->counter < 0) {
int size2 = ctx->counter + read_size; int size2 = ctx->counter + read_size;
@ -299,7 +299,7 @@ static int dss_723_1_read_packet(AVFormatContext *s, AVPacket *pkt)
pkt->data[0] = byte; pkt->data[0] = byte;
offset = 1; offset = 1;
pkt->duration = 240; pkt->duration = 240;
s->bit_rate = 8LL * size * st->codec->sample_rate * 512 / (506 * pkt->duration); s->bit_rate = 8LL * size * st->codecpar->sample_rate * 512 / (506 * pkt->duration);
pkt->stream_index = 0; pkt->stream_index = 0;

6
libavformat/dtshddec.c
Unescape View File

@ -60,9 +60,9 @@ static int dtshd_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_DTS; st->codecpar->codec_id = AV_CODEC_ID_DTS;
st->need_parsing = AVSTREAM_PARSE_FULL_RAW; st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
while (!avio_feof(pb)) { while (!avio_feof(pb)) {
chunk_type = avio_rb64(pb); chunk_type = avio_rb64(pb);

47
libavformat/dump.c
Unescape View File

@ -440,14 +440,24 @@ static void dump_stream_format(AVFormatContext *ic, int i,
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);
char *separator = ic->dump_separator; char *separator = ic->dump_separator;
char **codec_separator = av_opt_ptr(st->codec->av_class, st->codec, "dump_separator"); AVCodecContext *avctx;
int use_format_separator = !*codec_separator; int ret;
if (use_format_separator) avctx = avcodec_alloc_context3(NULL);
*codec_separator = av_strdup(separator); if (!avctx)
avcodec_string(buf, sizeof(buf), st->codec, is_output); return;
if (use_format_separator)
av_freep(codec_separator); ret = avcodec_parameters_to_context(avctx, st->codecpar);
if (ret < 0) {
avcodec_free_context(&avctx);
return;
}
if (separator)
av_opt_set(avctx, "dump_separator", separator, 0);
avcodec_string(buf, sizeof(buf), avctx, is_output);
avcodec_free_context(&avctx);
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 */
@ -460,35 +470,32 @@ 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)) { av_cmp_q(st->sample_aspect_ratio, st->codecpar->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 * (int64_t)st->sample_aspect_ratio.num, st->codecpar->width * (int64_t)st->sample_aspect_ratio.num,
st->codec->height * (int64_t)st->sample_aspect_ratio.den, st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
1024 * 1024); 1024 * 1024);
av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d", av_log(NULL, AV_LOG_INFO, ", SAR %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 tbr = st->r_frame_rate.den && st->r_frame_rate.num; int tbr = st->r_frame_rate.den && st->r_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 || tbr || tbn || tbc) if (fps || tbr || tbn)
av_log(NULL, AV_LOG_INFO, "%s", separator); av_log(NULL, AV_LOG_INFO, "%s", separator);
if (fps) if (fps)
print_fps(av_q2d(st->avg_frame_rate), tbr || tbn || tbc ? "fps, " : "fps"); print_fps(av_q2d(st->avg_frame_rate), tbr || tbn ? "fps, " : "fps");
if (tbr) if (tbr)
print_fps(av_q2d(st->r_frame_rate), tbn || tbc ? "tbr, " : "tbr"); print_fps(av_q2d(st->r_frame_rate), tbn ? "tbr, " : "tbr");
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)

28
libavformat/dv.c
Unescape View File

@ -259,8 +259,8 @@ static int dv_extract_audio_info(DVDemuxContext *c, const 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;
@ -268,10 +268,10 @@ static int dv_extract_audio_info(DVDemuxContext *c, const 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;
@ -282,10 +282,10 @@ static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame) static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
{ {
const uint8_t *vsc_pack; const uint8_t *vsc_pack;
AVCodecContext *avctx; AVCodecParameters *par;
int apt, is16_9; int apt, is16_9;
avctx = c->vst->codec; 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);
@ -297,7 +297,7 @@ static int dv_extract_video_info(DVDemuxContext *c, const 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);
return c->sys->frame_size; return c->sys->frame_size;
@ -336,9 +336,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;
@ -380,7 +380,7 @@ int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
c->audio_pkt[i].pos = pos; c->audio_pkt[i].pos = pos;
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)
@ -439,7 +439,7 @@ void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
if (c->ach) { if (c->ach) {
if (c->sys) { if (c->sys) {
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 });
} else } else
av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n"); av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n");
} }

47
libavformat/dvenc.c
Unescape View File

@ -105,13 +105,13 @@ static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* bu
case dv_audio_source: /* AAUX source pack */ case dv_audio_source: /* AAUX source pack */
va_start(ap, buf); va_start(ap, buf);
channel = va_arg(ap, int); channel = va_arg(ap, int);
if (c->ast[channel]->codec->sample_rate == 44100) { if (c->ast[channel]->codecpar->sample_rate == 44100) {
audio_type = 1; audio_type = 1;
} else if (c->ast[channel]->codec->sample_rate == 32000) } else if (c->ast[channel]->codecpar->sample_rate == 32000)
audio_type = 2; audio_type = 2;
buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */ buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */
(1 << 6) | /* reserved -- always 1 */ (1 << 6) | /* reserved -- always 1 */
(dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codec->sample_rate) - (dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate) -
c->sys->audio_min_samples[audio_type]); c->sys->audio_min_samples[audio_type]);
/* # of samples */ /* # of samples */
buf[2] = (0 << 7) | /* multi-stereo */ buf[2] = (0 << 7) | /* multi-stereo */
@ -186,7 +186,7 @@ static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* bu
static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr) static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr)
{ {
int i, j, d, of, size; int i, j, d, of, size;
size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codec->sample_rate); size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate);
frame_ptr += channel * c->sys->difseg_size * 150 * 80; frame_ptr += channel * c->sys->difseg_size * 150 * 80;
for (i = 0; i < c->sys->difseg_size; i++) { for (i = 0; i < c->sys->difseg_size; i++) {
frame_ptr += 6 * 80; /* skip DIF segment header */ frame_ptr += 6 * 80; /* skip DIF segment header */
@ -238,20 +238,21 @@ 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;
*frame = &c->frame_buf[0]; *frame = &c->frame_buf[0];
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);
} }
@ -264,10 +265,10 @@ 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);
reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codec->sample_rate); reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
/* 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. */
c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i); c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
@ -283,7 +284,7 @@ static int dv_assemble_frame(DVMuxContext *c, AVStream* st,
c->has_audio = 0; c->has_audio = 0;
for (i=0; i < c->n_ast; i++) { for (i=0; i < c->n_ast; i++) {
dv_inject_audio(c, i, *frame); dv_inject_audio(c, i, *frame);
reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codec->sample_rate); reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
av_fifo_drain(c->audio_data[i], reqasize); av_fifo_drain(c->audio_data[i], reqasize);
c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i); c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);
} }
@ -313,7 +314,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];
@ -328,28 +329,28 @@ 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]) { if (c->ast[i]) {
if(c->ast[i]->codec->codec_id != AV_CODEC_ID_PCM_S16LE || if(c->ast[i]->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE ||
c->ast[i]->codec->channels != 2) c->ast[i]->codecpar->channels != 2)
goto bail_out; goto bail_out;
if (c->ast[i]->codec->sample_rate != 48000 && if (c->ast[i]->codecpar->sample_rate != 48000 &&
c->ast[i]->codec->sample_rate != 44100 && c->ast[i]->codecpar->sample_rate != 44100 &&
c->ast[i]->codec->sample_rate != 32000 ) c->ast[i]->codecpar->sample_rate != 32000 )
goto bail_out; goto bail_out;
} }
} }
c->sys = av_dv_codec_profile2(vst->codec->width, vst->codec->height, c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,
vst->codec->pix_fmt, vst->codec->time_base); vst->codecpar->format, vst->time_base);
if (!c->sys) if (!c->sys)
goto bail_out; goto bail_out;
if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) { if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
if (c->ast[0] && c->ast[0]->codec->sample_rate != 48000) if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)
goto bail_out; goto bail_out;
if (c->ast[1] && c->ast[1]->codec->sample_rate != 48000) if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)
goto bail_out; goto bail_out;
} }
@ -420,7 +421,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 AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = ff_get_wav_header(s, pb, ast->codec, fsize, 0); ret = ff_get_wav_header(s, pb, ast->codecpar, fsize, 0);
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 && !avio_feof(pb)){ while(avio_tell(pb) < c->vidpos && !avio_feof(pb)){
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);

12
libavformat/eacdata.c
Unescape View File

@ -70,12 +70,12 @@ 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->channel_layout = channel_layout; st->codecpar->channel_layout = channel_layout;
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;

34
libavformat/electronicarts.c
Unescape View File

@ -499,14 +499,14 @@ static int init_video_stream(AVFormatContext *s, VideoProperties *video)
if (!st) if (!st)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
video->stream_index = st->index; video->stream_index = st->index;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_id = video->codec; st->codecpar->codec_id = video->codec;
// parsing is necessary to make FFmpeg generate correct timestamps // parsing is necessary to make FFmpeg generate correct timestamps
if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO) if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO)
st->need_parsing = AVSTREAM_PARSE_HEADERS; st->need_parsing = AVSTREAM_PARSE_HEADERS;
st->codec->codec_tag = 0; /* no fourcc */ st->codecpar->codec_tag = 0; /* no fourcc */
st->codec->width = video->width; st->codecpar->width = video->width;
st->codec->height = video->height; st->codecpar->height = video->height;
st->duration = st->nb_frames = video->nb_frames; st->duration = st->nb_frames = video->nb_frames;
if (video->time_base.num) if (video->time_base.num)
avpriv_set_pts_info(st, 64, video->time_base.num, video->time_base.den); avpriv_set_pts_info(st, 64, video->time_base.num, video->time_base.den);
@ -551,17 +551,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;
} }

16
libavformat/epafdec.c
Unescape View File

@ -66,15 +66,15 @@ static int epaf_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->channels = channels; st->codecpar->channels = channels;
st->codec->sample_rate = sample_rate; st->codecpar->sample_rate = sample_rate;
switch (codec) { switch (codec) {
case 0: case 0:
st->codec->codec_id = le ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_S16BE; st->codecpar->codec_id = le ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_S16BE;
break; break;
case 2: case 2:
st->codec->codec_id = AV_CODEC_ID_PCM_S8; st->codecpar->codec_id = AV_CODEC_ID_PCM_S8;
break; break;
case 1: case 1:
avpriv_request_sample(s, "24-bit Paris PCM format"); avpriv_request_sample(s, "24-bit Paris PCM format");
@ -82,10 +82,10 @@ static int epaf_read_header(AVFormatContext *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id); st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
st->codec->block_align = st->codec->bits_per_coded_sample * st->codec->channels / 8; st->codecpar->block_align = st->codecpar->bits_per_coded_sample * st->codecpar->channels / 8;
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate); avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
if (avio_skip(s->pb, 2024) < 0) if (avio_skip(s->pb, 2024) < 0)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;

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

Write Preview
Loading…
Cancel
Save