FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
avcodec.c
Go to the documentation of this file.
1 /*
2  * Copyright 2011 Stefano Sabatini | stefasab at gmail.com
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * libavcodec/libavfilter gluing utilities
24  */
25 
26 #include "avcodec.h"
27 #include "libavutil/avassert.h"
28 #include "libavutil/opt.h"
29 
31 {
32  dst->pts = src->pts;
33  dst->pos = av_frame_get_pkt_pos(src);
34  dst->format = src->format;
35 
36  av_dict_free(&dst->metadata);
38 
39  switch (dst->type) {
40  case AVMEDIA_TYPE_VIDEO:
41  dst->video->w = src->width;
42  dst->video->h = src->height;
44  dst->video->interlaced = src->interlaced_frame;
46  dst->video->key_frame = src->key_frame;
47  dst->video->pict_type = src->pict_type;
48  av_freep(&dst->video->qp_table);
49  dst->video->qp_table_linesize = 0;
50  if (src->qscale_table) {
51  int qsize = src->qstride ? src->qstride * ((src->height+15)/16) : (src->width+15)/16;
52  dst->video->qp_table = av_malloc(qsize);
53  if (!dst->video->qp_table)
54  return AVERROR(ENOMEM);
55  dst->video->qp_table_linesize = src->qstride;
56  dst->video->qp_table_size = qsize;
57  memcpy(dst->video->qp_table, src->qscale_table, qsize);
58  }
59  break;
60  case AVMEDIA_TYPE_AUDIO:
61  dst->audio->sample_rate = src->sample_rate;
62  dst->audio->channel_layout = src->channel_layout;
63  dst->audio->channels = src->channels;
65  av_log(NULL, AV_LOG_ERROR, "libavfilter does not support this channel layout\n");
66  return AVERROR(EINVAL);
67  }
68  break;
69  default:
70  return AVERROR(EINVAL);
71  }
72 
73  return 0;
74 }
75 
77  int perms)
78 {
79  AVFilterBufferRef *picref =
81  frame->width, frame->height,
82  frame->format);
83  if (!picref)
84  return NULL;
85  if (avfilter_copy_frame_props(picref, frame) < 0) {
86  picref->buf->data[0] = NULL;
87  avfilter_unref_bufferp(&picref);
88  }
89  return picref;
90 }
91 
93  int perms)
94 {
95  AVFilterBufferRef *samplesref;
96  int channels = av_frame_get_channels(frame);
97  int64_t layout = av_frame_get_channel_layout(frame);
98 
99  if (layout && av_get_channel_layout_nb_channels(layout) != av_frame_get_channels(frame)) {
100  av_log(0, AV_LOG_ERROR, "Layout indicates a different number of channels than actually present\n");
101  return NULL;
102  }
103 
105  (uint8_t **)frame->extended_data, frame->linesize[0], perms,
106  frame->nb_samples, frame->format, channels, layout);
107  if (!samplesref)
108  return NULL;
109  if (avfilter_copy_frame_props(samplesref, frame) < 0) {
110  samplesref->buf->data[0] = NULL;
111  avfilter_unref_bufferp(&samplesref);
112  }
113  return samplesref;
114 }
115 
117  const AVFrame *frame,
118  int perms)
119 {
120  switch (type) {
121  case AVMEDIA_TYPE_VIDEO:
122  return avfilter_get_video_buffer_ref_from_frame(frame, perms);
123  case AVMEDIA_TYPE_AUDIO:
124  return avfilter_get_audio_buffer_ref_from_frame(frame, perms);
125  default:
126  return NULL;
127  }
128 }
129 
131 {
132  int planes, nb_channels;
133 
134  if (!dst)
135  return AVERROR(EINVAL);
136  /* abort in case the src is NULL and dst is not, avoid inconsistent state in dst */
137  av_assert0(src);
138 
139  memcpy(dst->data, src->data, sizeof(dst->data));
140  memcpy(dst->linesize, src->linesize, sizeof(dst->linesize));
141 
142  dst->pts = src->pts;
143  dst->format = src->format;
144  av_frame_set_pkt_pos(dst, src->pos);
145 
146  switch (src->type) {
147  case AVMEDIA_TYPE_VIDEO:
148  av_assert0(src->video);
149  dst->width = src->video->w;
150  dst->height = src->video->h;
152  dst->interlaced_frame = src->video->interlaced;
154  dst->key_frame = src->video->key_frame;
155  dst->pict_type = src->video->pict_type;
156  break;
157  case AVMEDIA_TYPE_AUDIO:
158  av_assert0(src->audio);
160  planes = av_sample_fmt_is_planar(src->format) ? nb_channels : 1;
161 
162  if (planes > FF_ARRAY_ELEMS(dst->data)) {
163  dst->extended_data = av_mallocz(planes * sizeof(*dst->extended_data));
164  if (!dst->extended_data)
165  return AVERROR(ENOMEM);
166  memcpy(dst->extended_data, src->extended_data,
167  planes * sizeof(*dst->extended_data));
168  } else
169  dst->extended_data = dst->data;
170  dst->nb_samples = src->audio->nb_samples;
173  av_frame_set_channels (dst, src->audio->channels);
174  break;
175  default:
176  return AVERROR(EINVAL);
177  }
178 
179  return 0;
180 }
181 
182 #ifdef FF_API_FILL_FRAME
183 int avfilter_fill_frame_from_audio_buffer_ref(AVFrame *frame,
184  const AVFilterBufferRef *samplesref)
185 {
186  return avfilter_copy_buf_props(frame, samplesref);
187 }
188 
189 int avfilter_fill_frame_from_video_buffer_ref(AVFrame *frame,
190  const AVFilterBufferRef *picref)
191 {
192  return avfilter_copy_buf_props(frame, picref);
193 }
194 
195 int avfilter_fill_frame_from_buffer_ref(AVFrame *frame,
196  const AVFilterBufferRef *ref)
197 {
198  return avfilter_copy_buf_props(frame, ref);
199 }
200 #endif