| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * generic encoding-related code | ||
| 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 | #include "libavutil/avassert.h" | ||
| 22 | #include "libavutil/channel_layout.h" | ||
| 23 | #include "libavutil/emms.h" | ||
| 24 | #include "libavutil/frame.h" | ||
| 25 | #include "libavutil/internal.h" | ||
| 26 | #include "libavutil/mem.h" | ||
| 27 | #include "libavutil/pixdesc.h" | ||
| 28 | #include "libavutil/samplefmt.h" | ||
| 29 | |||
| 30 | #include "avcodec.h" | ||
| 31 | #include "avcodec_internal.h" | ||
| 32 | #include "codec_desc.h" | ||
| 33 | #include "codec_internal.h" | ||
| 34 | #include "encode.h" | ||
| 35 | #include "frame_thread_encoder.h" | ||
| 36 | #include "internal.h" | ||
| 37 | |||
| 38 | typedef struct EncodeContext { | ||
| 39 | AVCodecInternal avci; | ||
| 40 | |||
| 41 | /** | ||
| 42 | * This is set to AV_PKT_FLAG_KEY for encoders that encode intra-only | ||
| 43 | * formats (i.e. whose codec descriptor has AV_CODEC_PROP_INTRA_ONLY set). | ||
| 44 | * This is used to set said flag generically for said encoders. | ||
| 45 | */ | ||
| 46 | int intra_only_flag; | ||
| 47 | |||
| 48 | /** | ||
| 49 | * An audio frame with less than required samples has been submitted (and | ||
| 50 | * potentially padded with silence). Reject all subsequent frames. | ||
| 51 | */ | ||
| 52 | int last_audio_frame; | ||
| 53 | } EncodeContext; | ||
| 54 | |||
| 55 | 927700 | static EncodeContext *encode_ctx(AVCodecInternal *avci) | |
| 56 | { | ||
| 57 | 927700 | return (EncodeContext*)avci; | |
| 58 | } | ||
| 59 | |||
| 60 | 29330 | int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size) | |
| 61 | { | ||
| 62 |
2/4✓ Branch 0 taken 29330 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 29330 times.
|
29330 | if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) { |
| 63 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n", | |
| 64 | size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE); | ||
| 65 | ✗ | return AVERROR(EINVAL); | |
| 66 | } | ||
| 67 | |||
| 68 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29330 times.
|
29330 | av_assert0(!avpkt->data); |
| 69 | |||
| 70 | 29330 | av_fast_padded_malloc(&avctx->internal->byte_buffer, | |
| 71 | 29330 | &avctx->internal->byte_buffer_size, size); | |
| 72 | 29330 | avpkt->data = avctx->internal->byte_buffer; | |
| 73 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29330 times.
|
29330 | if (!avpkt->data) { |
| 74 | ✗ | av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size); | |
| 75 | ✗ | return AVERROR(ENOMEM); | |
| 76 | } | ||
| 77 | 29330 | avpkt->size = size; | |
| 78 | |||
| 79 | 29330 | return 0; | |
| 80 | } | ||
| 81 | |||
| 82 | 449467 | int avcodec_default_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int flags) | |
| 83 | { | ||
| 84 | int ret; | ||
| 85 | |||
| 86 |
2/4✓ Branch 0 taken 449467 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 449467 times.
|
449467 | if (avpkt->size < 0 || avpkt->size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) |
| 87 | ✗ | return AVERROR(EINVAL); | |
| 88 | |||
| 89 |
2/4✓ Branch 0 taken 449467 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 449467 times.
|
449467 | if (avpkt->data || avpkt->buf) { |
| 90 | ✗ | av_log(avctx, AV_LOG_ERROR, "avpkt->{data,buf} != NULL in avcodec_default_get_encode_buffer()\n"); | |
| 91 | ✗ | return AVERROR(EINVAL); | |
| 92 | } | ||
| 93 | |||
| 94 | 449467 | ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE); | |
| 95 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 449467 times.
|
449467 | if (ret < 0) { |
| 96 | ✗ | av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %d\n", avpkt->size); | |
| 97 | ✗ | return ret; | |
| 98 | } | ||
| 99 | 449467 | avpkt->data = avpkt->buf->data; | |
| 100 | |||
| 101 | 449467 | return 0; | |
| 102 | } | ||
| 103 | |||
| 104 | 449467 | int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags) | |
| 105 | { | ||
| 106 | int ret; | ||
| 107 | |||
| 108 |
2/4✓ Branch 0 taken 449467 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 449467 times.
|
449467 | if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) |
| 109 | ✗ | return AVERROR(EINVAL); | |
| 110 | |||
| 111 |
2/4✓ Branch 0 taken 449467 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 449467 times.
|
449467 | av_assert0(!avpkt->data && !avpkt->buf); |
| 112 | |||
| 113 | 449467 | avpkt->size = size; | |
| 114 | 449467 | ret = avctx->get_encode_buffer(avctx, avpkt, flags); | |
| 115 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 449467 times.
|
449467 | if (ret < 0) |
| 116 | ✗ | goto fail; | |
| 117 | |||
| 118 |
2/4✓ Branch 0 taken 449467 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 449467 times.
|
449467 | if (!avpkt->data || !avpkt->buf) { |
| 119 | ✗ | av_log(avctx, AV_LOG_ERROR, "No buffer returned by get_encode_buffer()\n"); | |
| 120 | ✗ | ret = AVERROR(EINVAL); | |
| 121 | ✗ | goto fail; | |
| 122 | } | ||
| 123 | 449467 | memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE); | |
| 124 | |||
| 125 | 449467 | ret = 0; | |
| 126 | 449467 | fail: | |
| 127 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 449467 times.
|
449467 | if (ret < 0) { |
| 128 | ✗ | av_log(avctx, AV_LOG_ERROR, "get_encode_buffer() failed\n"); | |
| 129 | ✗ | av_packet_unref(avpkt); | |
| 130 | } | ||
| 131 | |||
| 132 | 449467 | return ret; | |
| 133 | } | ||
| 134 | |||
| 135 | 450041 | static int encode_make_refcounted(AVCodecContext *avctx, AVPacket *avpkt) | |
| 136 | { | ||
| 137 | 450041 | uint8_t *data = avpkt->data; | |
| 138 | int ret; | ||
| 139 | |||
| 140 |
2/2✓ Branch 0 taken 420711 times.
✓ Branch 1 taken 29330 times.
|
450041 | if (avpkt->buf) |
| 141 | 420711 | return 0; | |
| 142 | |||
| 143 | 29330 | avpkt->data = NULL; | |
| 144 | 29330 | ret = ff_get_encode_buffer(avctx, avpkt, avpkt->size, 0); | |
| 145 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29330 times.
|
29330 | if (ret < 0) |
| 146 | ✗ | return ret; | |
| 147 | 29330 | memcpy(avpkt->data, data, avpkt->size); | |
| 148 | |||
| 149 | 29330 | return 0; | |
| 150 | } | ||
| 151 | |||
| 152 | /** | ||
| 153 | * Pad last frame with silence. | ||
| 154 | */ | ||
| 155 | 55 | static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src, int out_samples) | |
| 156 | { | ||
| 157 | int ret; | ||
| 158 | |||
| 159 | 55 | frame->format = src->format; | |
| 160 | 55 | frame->nb_samples = out_samples; | |
| 161 | 55 | ret = av_channel_layout_copy(&frame->ch_layout, &s->ch_layout); | |
| 162 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if (ret < 0) |
| 163 | ✗ | goto fail; | |
| 164 | 55 | ret = av_frame_get_buffer(frame, 0); | |
| 165 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if (ret < 0) |
| 166 | ✗ | goto fail; | |
| 167 | |||
| 168 | 55 | ret = av_frame_copy_props(frame, src); | |
| 169 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if (ret < 0) |
| 170 | ✗ | goto fail; | |
| 171 | |||
| 172 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0, |
| 173 | 55 | src->nb_samples, s->ch_layout.nb_channels, | |
| 174 | s->sample_fmt)) < 0) | ||
| 175 | ✗ | goto fail; | |
| 176 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples, |
| 177 | 55 | frame->nb_samples - src->nb_samples, | |
| 178 | s->ch_layout.nb_channels, s->sample_fmt)) < 0) | ||
| 179 | ✗ | goto fail; | |
| 180 | |||
| 181 | 55 | return 0; | |
| 182 | |||
| 183 | ✗ | fail: | |
| 184 | ✗ | av_frame_unref(frame); | |
| 185 | ✗ | encode_ctx(s->internal)->last_audio_frame = 0; | |
| 186 | ✗ | return ret; | |
| 187 | } | ||
| 188 | |||
| 189 | 982 | int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, | |
| 190 | const AVSubtitle *sub) | ||
| 191 | { | ||
| 192 | int ret; | ||
| 193 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 982 times.
|
982 | if (sub->start_display_time) { |
| 194 | ✗ | av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n"); | |
| 195 | ✗ | return -1; | |
| 196 | } | ||
| 197 | |||
| 198 | 982 | ret = ffcodec(avctx->codec)->cb.encode_sub(avctx, buf, buf_size, sub); | |
| 199 | 982 | avctx->frame_num++; | |
| 200 | 982 | return ret; | |
| 201 | } | ||
| 202 | |||
| 203 | 921721 | int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame) | |
| 204 | { | ||
| 205 | 921721 | AVCodecInternal *avci = avctx->internal; | |
| 206 | |||
| 207 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 921721 times.
|
921721 | if (avci->draining) |
| 208 | ✗ | return AVERROR_EOF; | |
| 209 | |||
| 210 |
2/2✓ Branch 0 taken 465550 times.
✓ Branch 1 taken 456171 times.
|
921721 | if (!avci->buffer_frame->buf[0]) |
| 211 | 465550 | return AVERROR(EAGAIN); | |
| 212 | |||
| 213 | 456171 | av_frame_move_ref(frame, avci->buffer_frame); | |
| 214 | |||
| 215 | 456171 | return 0; | |
| 216 | } | ||
| 217 | |||
| 218 | 445385 | int ff_encode_reordered_opaque(AVCodecContext *avctx, | |
| 219 | AVPacket *pkt, const AVFrame *frame) | ||
| 220 | { | ||
| 221 |
2/2✓ Branch 0 taken 441844 times.
✓ Branch 1 taken 3541 times.
|
445385 | if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) { |
| 222 | 441844 | int ret = av_buffer_replace(&pkt->opaque_ref, frame->opaque_ref); | |
| 223 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 441844 times.
|
441844 | if (ret < 0) |
| 224 | ✗ | return ret; | |
| 225 | 441844 | pkt->opaque = frame->opaque; | |
| 226 | } | ||
| 227 | |||
| 228 | 445385 | return 0; | |
| 229 | } | ||
| 230 | |||
| 231 | 456649 | int ff_encode_encode_cb(AVCodecContext *avctx, AVPacket *avpkt, | |
| 232 | AVFrame *frame, int *got_packet) | ||
| 233 | { | ||
| 234 | 456649 | const FFCodec *const codec = ffcodec(avctx->codec); | |
| 235 | int ret; | ||
| 236 | |||
| 237 | 456649 | ret = codec->cb.encode(avctx, avpkt, frame, got_packet); | |
| 238 | 456649 | emms_c(); | |
| 239 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 456649 times.
|
456649 | av_assert0(ret <= 0); |
| 240 | |||
| 241 |
3/4✓ Branch 0 taken 456649 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6538 times.
✓ Branch 3 taken 450111 times.
|
456649 | if (!ret && *got_packet) { |
| 242 |
2/2✓ Branch 0 taken 450041 times.
✓ Branch 1 taken 70 times.
|
450111 | if (avpkt->data) { |
| 243 | 450041 | ret = encode_make_refcounted(avctx, avpkt); | |
| 244 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 450041 times.
|
450041 | if (ret < 0) |
| 245 | ✗ | goto unref; | |
| 246 | // Date returned by encoders must always be ref-counted | ||
| 247 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 450041 times.
|
450041 | av_assert0(avpkt->buf); |
| 248 | } | ||
| 249 | |||
| 250 | // set the timestamps for the simple no-delay case | ||
| 251 | // encoders with delay have to set the timestamps themselves | ||
| 252 |
4/4✓ Branch 0 taken 27807 times.
✓ Branch 1 taken 422304 times.
✓ Branch 2 taken 27587 times.
✓ Branch 3 taken 220 times.
|
450111 | if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || |
| 253 |
2/2✓ Branch 0 taken 15763 times.
✓ Branch 1 taken 11824 times.
|
27587 | (frame && (codec->caps_internal & FF_CODEC_CAP_EOF_FLUSH))) { |
| 254 |
2/2✓ Branch 0 taken 422758 times.
✓ Branch 1 taken 15309 times.
|
438067 | if (avpkt->pts == AV_NOPTS_VALUE) |
| 255 | 422758 | avpkt->pts = frame->pts; | |
| 256 | |||
| 257 |
2/2✓ Branch 0 taken 433068 times.
✓ Branch 1 taken 4999 times.
|
438067 | if (!avpkt->duration) { |
| 258 |
2/2✓ Branch 0 taken 412414 times.
✓ Branch 1 taken 20654 times.
|
433068 | if (frame->duration) |
| 259 | 412414 | avpkt->duration = frame->duration; | |
| 260 |
2/2✓ Branch 0 taken 3200 times.
✓ Branch 1 taken 17454 times.
|
20654 | else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) { |
| 261 | 3200 | avpkt->duration = ff_samples_to_time_base(avctx, | |
| 262 | 3200 | frame->nb_samples); | |
| 263 | } | ||
| 264 | } | ||
| 265 | |||
| 266 | 438067 | ret = ff_encode_reordered_opaque(avctx, avpkt, frame); | |
| 267 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 438067 times.
|
438067 | if (ret < 0) |
| 268 | ✗ | goto unref; | |
| 269 | } | ||
| 270 | |||
| 271 | // dts equals pts unless there is reordering | ||
| 272 | // there can be no reordering if there is no encoder delay | ||
| 273 |
2/2✓ Branch 0 taken 8057 times.
✓ Branch 1 taken 442054 times.
|
450111 | if (!(avctx->codec_descriptor->props & AV_CODEC_PROP_REORDER) || |
| 274 |
2/2✓ Branch 0 taken 7292 times.
✓ Branch 1 taken 765 times.
|
8057 | !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || |
| 275 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7292 times.
|
7292 | (codec->caps_internal & FF_CODEC_CAP_EOF_FLUSH)) |
| 276 | 442819 | avpkt->dts = avpkt->pts; | |
| 277 | } else { | ||
| 278 | 6538 | unref: | |
| 279 | 6538 | av_packet_unref(avpkt); | |
| 280 | } | ||
| 281 | |||
| 282 |
2/2✓ Branch 0 taken 456171 times.
✓ Branch 1 taken 478 times.
|
456649 | if (frame) |
| 283 | 456171 | av_frame_unref(frame); | |
| 284 | |||
| 285 | 456649 | return ret; | |
| 286 | } | ||
| 287 | |||
| 288 | 935145 | static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt) | |
| 289 | { | ||
| 290 | 935145 | AVCodecInternal *avci = avctx->internal; | |
| 291 | 935145 | AVFrame *frame = avci->in_frame; | |
| 292 | 935145 | const FFCodec *const codec = ffcodec(avctx->codec); | |
| 293 | int got_packet; | ||
| 294 | int ret; | ||
| 295 | |||
| 296 |
2/2✓ Branch 0 taken 1913 times.
✓ Branch 1 taken 933232 times.
|
935145 | if (avci->draining_done) |
| 297 | 1913 | return AVERROR_EOF; | |
| 298 | |||
| 299 |
3/4✓ Branch 0 taken 933232 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 921721 times.
✓ Branch 3 taken 11511 times.
|
933232 | if (!frame->buf[0] && !avci->draining) { |
| 300 | 921721 | av_frame_unref(frame); | |
| 301 | 921721 | ret = ff_encode_get_frame(avctx, frame); | |
| 302 |
3/4✓ Branch 0 taken 465550 times.
✓ Branch 1 taken 456171 times.
✓ Branch 2 taken 465550 times.
✗ Branch 3 not taken.
|
921721 | if (ret < 0 && ret != AVERROR_EOF) |
| 303 | 465550 | return ret; | |
| 304 | } | ||
| 305 | |||
| 306 |
2/2✓ Branch 0 taken 11511 times.
✓ Branch 1 taken 456171 times.
|
467682 | if (!frame->buf[0]) { |
| 307 |
2/2✓ Branch 0 taken 11033 times.
✓ Branch 1 taken 478 times.
|
11511 | if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY || |
| 308 |
2/2✓ Branch 0 taken 6217 times.
✓ Branch 1 taken 4816 times.
|
11033 | avci->frame_thread_encoder)) |
| 309 | 6217 | return AVERROR_EOF; | |
| 310 | |||
| 311 | // Flushing is signaled with a NULL frame | ||
| 312 | 5294 | frame = NULL; | |
| 313 | } | ||
| 314 | |||
| 315 | 461465 | got_packet = 0; | |
| 316 | |||
| 317 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 461465 times.
|
461465 | av_assert0(codec->cb_type == FF_CODEC_CB_TYPE_ENCODE); |
| 318 | |||
| 319 |
2/2✓ Branch 0 taken 62719 times.
✓ Branch 1 taken 398746 times.
|
461465 | if (CONFIG_FRAME_THREAD_ENCODER && avci->frame_thread_encoder) |
| 320 | /* This will unref frame. */ | ||
| 321 | 62719 | ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet); | |
| 322 | else { | ||
| 323 | 398746 | ret = ff_encode_encode_cb(avctx, avpkt, frame, &got_packet); | |
| 324 | } | ||
| 325 | |||
| 326 |
4/4✓ Branch 0 taken 5294 times.
✓ Branch 1 taken 456171 times.
✓ Branch 2 taken 1913 times.
✓ Branch 3 taken 3381 times.
|
461465 | if (avci->draining && !got_packet) |
| 327 | 1913 | avci->draining_done = 1; | |
| 328 | |||
| 329 | 461465 | return ret; | |
| 330 | } | ||
| 331 | |||
| 332 | 923791 | static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt) | |
| 333 | { | ||
| 334 | int ret; | ||
| 335 | |||
| 336 |
4/4✓ Branch 0 taken 935215 times.
✓ Branch 1 taken 450041 times.
✓ Branch 2 taken 935145 times.
✓ Branch 3 taken 70 times.
|
1385256 | while (!avpkt->data && !avpkt->side_data) { |
| 337 | 935145 | ret = encode_simple_internal(avctx, avpkt); | |
| 338 |
2/2✓ Branch 0 taken 473680 times.
✓ Branch 1 taken 461465 times.
|
935145 | if (ret < 0) |
| 339 | 473680 | return ret; | |
| 340 | } | ||
| 341 | |||
| 342 | 450111 | return 0; | |
| 343 | } | ||
| 344 | |||
| 345 | 930120 | static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt) | |
| 346 | { | ||
| 347 | 930120 | AVCodecInternal *avci = avctx->internal; | |
| 348 | int ret; | ||
| 349 | |||
| 350 |
2/2✓ Branch 0 taken 6329 times.
✓ Branch 1 taken 923791 times.
|
930120 | if (avci->draining_done) |
| 351 | 6329 | return AVERROR_EOF; | |
| 352 | |||
| 353 |
2/4✓ Branch 0 taken 923791 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 923791 times.
|
923791 | av_assert0(!avpkt->data && !avpkt->side_data); |
| 354 | |||
| 355 |
2/2✓ Branch 0 taken 292821 times.
✓ Branch 1 taken 630970 times.
|
923791 | if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) { |
| 356 |
3/4✓ Branch 0 taken 808 times.
✓ Branch 1 taken 292013 times.
✓ Branch 2 taken 808 times.
✗ Branch 3 not taken.
|
292821 | if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out) |
| 357 | 808 | avctx->stats_out[0] = '\0'; | |
| 358 | } | ||
| 359 | |||
| 360 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 923791 times.
|
923791 | if (ffcodec(avctx->codec)->cb_type == FF_CODEC_CB_TYPE_RECEIVE_PACKET) { |
| 361 | ✗ | ret = ffcodec(avctx->codec)->cb.receive_packet(avctx, avpkt); | |
| 362 | ✗ | if (ret < 0) | |
| 363 | ✗ | av_packet_unref(avpkt); | |
| 364 | else | ||
| 365 | // Encoders must always return ref-counted buffers. | ||
| 366 | // Side-data only packets have no data and can be not ref-counted. | ||
| 367 | ✗ | av_assert0(!avpkt->data || avpkt->buf); | |
| 368 | } else | ||
| 369 | 923791 | ret = encode_simple_receive_packet(avctx, avpkt); | |
| 370 |
2/2✓ Branch 0 taken 450111 times.
✓ Branch 1 taken 473680 times.
|
923791 | if (ret >= 0) |
| 371 | 450111 | avpkt->flags |= encode_ctx(avci)->intra_only_flag; | |
| 372 | |||
| 373 |
2/2✓ Branch 0 taken 8130 times.
✓ Branch 1 taken 915661 times.
|
923791 | if (ret == AVERROR_EOF) |
| 374 | 8130 | avci->draining_done = 1; | |
| 375 | |||
| 376 | 923791 | return ret; | |
| 377 | } | ||
| 378 | |||
| 379 | #if CONFIG_LCMS2 | ||
| 380 | static int encode_generate_icc_profile(AVCodecContext *avctx, AVFrame *frame) | ||
| 381 | { | ||
| 382 | enum AVColorTransferCharacteristic trc = frame->color_trc; | ||
| 383 | enum AVColorPrimaries prim = frame->color_primaries; | ||
| 384 | const FFCodec *const codec = ffcodec(avctx->codec); | ||
| 385 | AVCodecInternal *avci = avctx->internal; | ||
| 386 | cmsHPROFILE profile; | ||
| 387 | int ret; | ||
| 388 | |||
| 389 | /* don't generate ICC profiles if disabled or unsupported */ | ||
| 390 | if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES)) | ||
| 391 | return 0; | ||
| 392 | if (!(codec->caps_internal & FF_CODEC_CAP_ICC_PROFILES)) | ||
| 393 | return 0; | ||
| 394 | |||
| 395 | if (trc == AVCOL_TRC_UNSPECIFIED) | ||
| 396 | trc = avctx->color_trc; | ||
| 397 | if (prim == AVCOL_PRI_UNSPECIFIED) | ||
| 398 | prim = avctx->color_primaries; | ||
| 399 | if (trc == AVCOL_TRC_UNSPECIFIED || prim == AVCOL_PRI_UNSPECIFIED) | ||
| 400 | return 0; /* can't generate ICC profile with missing csp tags */ | ||
| 401 | |||
| 402 | if (av_frame_get_side_data(frame, AV_FRAME_DATA_ICC_PROFILE)) | ||
| 403 | return 0; /* don't overwrite existing ICC profile */ | ||
| 404 | |||
| 405 | if (!avci->icc.avctx) { | ||
| 406 | ret = ff_icc_context_init(&avci->icc, avctx); | ||
| 407 | if (ret < 0) | ||
| 408 | return ret; | ||
| 409 | } | ||
| 410 | |||
| 411 | ret = ff_icc_profile_generate(&avci->icc, prim, trc, &profile); | ||
| 412 | if (ret < 0) | ||
| 413 | return ret; | ||
| 414 | |||
| 415 | ret = ff_icc_profile_attach(&avci->icc, profile, frame); | ||
| 416 | cmsCloseProfile(profile); | ||
| 417 | return ret; | ||
| 418 | } | ||
| 419 | #else /* !CONFIG_LCMS2 */ | ||
| 420 | 141402 | static int encode_generate_icc_profile(av_unused AVCodecContext *c, av_unused AVFrame *f) | |
| 421 | { | ||
| 422 | 141402 | return 0; | |
| 423 | } | ||
| 424 | #endif | ||
| 425 | |||
| 426 | 456171 | static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src) | |
| 427 | { | ||
| 428 | 456171 | AVCodecInternal *avci = avctx->internal; | |
| 429 | 456171 | EncodeContext *ec = encode_ctx(avci); | |
| 430 | 456171 | AVFrame *dst = avci->buffer_frame; | |
| 431 | int ret; | ||
| 432 | |||
| 433 |
2/2✓ Branch 0 taken 314769 times.
✓ Branch 1 taken 141402 times.
|
456171 | if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) { |
| 434 | /* extract audio service type metadata */ | ||
| 435 | 314769 | AVFrameSideData *sd = av_frame_get_side_data(src, AV_FRAME_DATA_AUDIO_SERVICE_TYPE); | |
| 436 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 314769 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
314769 | if (sd && sd->size >= sizeof(enum AVAudioServiceType)) |
| 437 | ✗ | avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data; | |
| 438 | |||
| 439 | /* check for valid frame size */ | ||
| 440 |
2/2✓ Branch 0 taken 73596 times.
✓ Branch 1 taken 241173 times.
|
314769 | if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) { |
| 441 | /* if we already got an undersized frame, that must have been the last */ | ||
| 442 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73596 times.
|
73596 | if (ec->last_audio_frame) { |
| 443 | ✗ | av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame\n", avctx->frame_size); | |
| 444 | ✗ | return AVERROR(EINVAL); | |
| 445 | } | ||
| 446 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73596 times.
|
73596 | if (src->nb_samples > avctx->frame_size) { |
| 447 | ✗ | av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) > frame_size (%d)\n", src->nb_samples, avctx->frame_size); | |
| 448 | ✗ | return AVERROR(EINVAL); | |
| 449 | } | ||
| 450 |
2/2✓ Branch 0 taken 162 times.
✓ Branch 1 taken 73434 times.
|
73596 | if (src->nb_samples < avctx->frame_size) { |
| 451 | 162 | ec->last_audio_frame = 1; | |
| 452 |
2/2✓ Branch 0 taken 55 times.
✓ Branch 1 taken 107 times.
|
162 | if (!(avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)) { |
| 453 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 52 times.
|
55 | int pad_samples = avci->pad_samples ? avci->pad_samples : avctx->frame_size; |
| 454 | 55 | int out_samples = (src->nb_samples + pad_samples - 1) / pad_samples * pad_samples; | |
| 455 | |||
| 456 |
1/2✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
|
55 | if (out_samples != src->nb_samples) { |
| 457 | 55 | ret = pad_last_frame(avctx, dst, src, out_samples); | |
| 458 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 55 times.
|
55 | if (ret < 0) |
| 459 | ✗ | return ret; | |
| 460 | 55 | goto finish; | |
| 461 | } | ||
| 462 | } | ||
| 463 | } | ||
| 464 | } | ||
| 465 | } | ||
| 466 | |||
| 467 | 456116 | ret = av_frame_ref(dst, src); | |
| 468 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 456116 times.
|
456116 | if (ret < 0) |
| 469 | ✗ | return ret; | |
| 470 | |||
| 471 | 456116 | finish: | |
| 472 | |||
| 473 |
2/2✓ Branch 0 taken 141402 times.
✓ Branch 1 taken 314769 times.
|
456171 | if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) { |
| 474 | 141402 | ret = encode_generate_icc_profile(avctx, dst); | |
| 475 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 141402 times.
|
141402 | if (ret < 0) |
| 476 | ✗ | return ret; | |
| 477 | } | ||
| 478 | |||
| 479 | // unset frame duration unless AV_CODEC_FLAG_FRAME_DURATION is set, | ||
| 480 | // since otherwise we cannot be sure that whatever value it has is in the | ||
| 481 | // right timebase, so we would produce an incorrect value, which is worse | ||
| 482 | // than none at all | ||
| 483 |
2/2✓ Branch 0 taken 3262 times.
✓ Branch 1 taken 452909 times.
|
456171 | if (!(avctx->flags & AV_CODEC_FLAG_FRAME_DURATION)) |
| 484 | 3262 | dst->duration = 0; | |
| 485 | |||
| 486 | 456171 | return 0; | |
| 487 | } | ||
| 488 | |||
| 489 | 464301 | int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame) | |
| 490 | { | ||
| 491 | 464301 | AVCodecInternal *avci = avctx->internal; | |
| 492 | int ret; | ||
| 493 | |||
| 494 |
2/4✓ Branch 1 taken 464301 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 464301 times.
|
464301 | if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec)) |
| 495 | ✗ | return AVERROR(EINVAL); | |
| 496 | |||
| 497 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 464301 times.
|
464301 | if (avci->draining) |
| 498 | ✗ | return AVERROR_EOF; | |
| 499 | |||
| 500 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 464301 times.
|
464301 | if (avci->buffer_frame->buf[0]) |
| 501 | ✗ | return AVERROR(EAGAIN); | |
| 502 | |||
| 503 |
2/2✓ Branch 0 taken 8130 times.
✓ Branch 1 taken 456171 times.
|
464301 | if (!frame) { |
| 504 | 8130 | avci->draining = 1; | |
| 505 | } else { | ||
| 506 | 456171 | ret = encode_send_frame_internal(avctx, frame); | |
| 507 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 456171 times.
|
456171 | if (ret < 0) |
| 508 | ✗ | return ret; | |
| 509 | } | ||
| 510 | |||
| 511 |
2/4✓ Branch 0 taken 464301 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 464301 times.
✗ Branch 3 not taken.
|
464301 | if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) { |
| 512 | 464301 | ret = encode_receive_packet_internal(avctx, avci->buffer_pkt); | |
| 513 |
5/6✓ Branch 0 taken 15770 times.
✓ Branch 1 taken 448531 times.
✓ Branch 2 taken 6329 times.
✓ Branch 3 taken 9441 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6329 times.
|
464301 | if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) |
| 514 | ✗ | return ret; | |
| 515 | } | ||
| 516 | |||
| 517 | 464301 | avctx->frame_num++; | |
| 518 | |||
| 519 | 464301 | return 0; | |
| 520 | } | ||
| 521 | |||
| 522 | 914350 | int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt) | |
| 523 | { | ||
| 524 | 914350 | AVCodecInternal *avci = avctx->internal; | |
| 525 | int ret; | ||
| 526 | |||
| 527 | 914350 | av_packet_unref(avpkt); | |
| 528 | |||
| 529 |
2/4✓ Branch 1 taken 914350 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 914350 times.
|
914350 | if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec)) |
| 530 | ✗ | return AVERROR(EINVAL); | |
| 531 | |||
| 532 |
4/4✓ Branch 0 taken 465889 times.
✓ Branch 1 taken 448461 times.
✓ Branch 2 taken 70 times.
✓ Branch 3 taken 465819 times.
|
914350 | if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) { |
| 533 | 448531 | av_packet_move_ref(avpkt, avci->buffer_pkt); | |
| 534 | } else { | ||
| 535 | 465819 | ret = encode_receive_packet_internal(avctx, avpkt); | |
| 536 |
2/2✓ Branch 0 taken 464239 times.
✓ Branch 1 taken 1580 times.
|
465819 | if (ret < 0) |
| 537 | 464239 | return ret; | |
| 538 | } | ||
| 539 | |||
| 540 | 450111 | return 0; | |
| 541 | } | ||
| 542 | |||
| 543 | 20023 | static int encode_preinit_video(AVCodecContext *avctx) | |
| 544 | { | ||
| 545 | 20023 | const AVCodec *c = avctx->codec; | |
| 546 | 20023 | const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt); | |
| 547 | const enum AVPixelFormat *pix_fmts; | ||
| 548 | int ret, i, num_pix_fmts; | ||
| 549 | |||
| 550 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20023 times.
|
20023 | if (!pixdesc) { |
| 551 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid video pixel format: %d\n", | |
| 552 | ✗ | avctx->pix_fmt); | |
| 553 | ✗ | return AVERROR(EINVAL); | |
| 554 | } | ||
| 555 | |||
| 556 | 20023 | ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_PIX_FORMAT, | |
| 557 | 0, (const void **) &pix_fmts, &num_pix_fmts); | ||
| 558 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20023 times.
|
20023 | if (ret < 0) |
| 559 | ✗ | return ret; | |
| 560 | |||
| 561 |
2/2✓ Branch 0 taken 819 times.
✓ Branch 1 taken 19204 times.
|
20023 | if (pix_fmts) { |
| 562 |
1/2✓ Branch 0 taken 2705 times.
✗ Branch 1 not taken.
|
2705 | for (i = 0; i < num_pix_fmts; i++) |
| 563 |
2/2✓ Branch 0 taken 819 times.
✓ Branch 1 taken 1886 times.
|
2705 | if (avctx->pix_fmt == pix_fmts[i]) |
| 564 | 819 | break; | |
| 565 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 819 times.
|
819 | if (i == num_pix_fmts) { |
| 566 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 567 | "Specified pixel format %s is not supported by the %s encoder.\n", | ||
| 568 | ✗ | av_get_pix_fmt_name(avctx->pix_fmt), c->name); | |
| 569 | |||
| 570 | ✗ | av_log(avctx, AV_LOG_ERROR, "Supported pixel formats:\n"); | |
| 571 | ✗ | for (int p = 0; pix_fmts[p] != AV_PIX_FMT_NONE; p++) { | |
| 572 | ✗ | av_log(avctx, AV_LOG_ERROR, " %s\n", | |
| 573 | ✗ | av_get_pix_fmt_name(pix_fmts[p])); | |
| 574 | } | ||
| 575 | |||
| 576 | ✗ | return AVERROR(EINVAL); | |
| 577 | } | ||
| 578 |
2/2✓ Branch 0 taken 798 times.
✓ Branch 1 taken 21 times.
|
819 | if (pix_fmts[i] == AV_PIX_FMT_YUVJ420P || |
| 579 |
1/2✓ Branch 0 taken 798 times.
✗ Branch 1 not taken.
|
798 | pix_fmts[i] == AV_PIX_FMT_YUVJ411P || |
| 580 |
2/2✓ Branch 0 taken 794 times.
✓ Branch 1 taken 4 times.
|
798 | pix_fmts[i] == AV_PIX_FMT_YUVJ422P || |
| 581 |
1/2✓ Branch 0 taken 794 times.
✗ Branch 1 not taken.
|
794 | pix_fmts[i] == AV_PIX_FMT_YUVJ440P || |
| 582 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 786 times.
|
794 | pix_fmts[i] == AV_PIX_FMT_YUVJ444P) |
| 583 | 33 | avctx->color_range = AVCOL_RANGE_JPEG; | |
| 584 | } | ||
| 585 | |||
| 586 |
2/2✓ Branch 0 taken 2465 times.
✓ Branch 1 taken 17558 times.
|
20023 | if (pixdesc->flags & AV_PIX_FMT_FLAG_ALPHA) { |
| 587 | const enum AVAlphaMode *alpha_modes; | ||
| 588 | int num_alpha_modes; | ||
| 589 | 2465 | ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_ALPHA_MODE, | |
| 590 | 0, (const void **) &alpha_modes, &num_alpha_modes); | ||
| 591 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2465 times.
|
2465 | if (ret < 0) |
| 592 | ✗ | return ret; | |
| 593 | |||
| 594 |
4/4✓ Branch 0 taken 476 times.
✓ Branch 1 taken 1989 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 472 times.
|
2465 | if (avctx->alpha_mode != AVALPHA_MODE_UNSPECIFIED && alpha_modes) { |
| 595 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | for (i = 0; i < num_alpha_modes; i++) { |
| 596 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | if (avctx->alpha_mode == alpha_modes[i]) |
| 597 | 4 | break; | |
| 598 | } | ||
| 599 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (i == num_alpha_modes) { |
| 600 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 601 | "Specified alpha mode '%s' is not supported by the %s encoder.\n", | ||
| 602 | ✗ | av_alpha_mode_name(avctx->alpha_mode), c->name); | |
| 603 | ✗ | av_log(avctx, AV_LOG_ERROR, "Supported alpha modes:\n"); | |
| 604 | ✗ | for (int p = 0; alpha_modes[p] != AVALPHA_MODE_UNSPECIFIED; p++) { | |
| 605 | ✗ | av_log(avctx, AV_LOG_ERROR, " %s\n", | |
| 606 | ✗ | av_alpha_mode_name(alpha_modes[p])); | |
| 607 | } | ||
| 608 | ✗ | return AVERROR(EINVAL); | |
| 609 | } | ||
| 610 | } | ||
| 611 | } | ||
| 612 | |||
| 613 |
1/2✓ Branch 0 taken 20023 times.
✗ Branch 1 not taken.
|
20023 | if ( avctx->bits_per_raw_sample < 0 |
| 614 |
3/4✓ Branch 0 taken 83 times.
✓ Branch 1 taken 19940 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 83 times.
|
20023 | || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) { |
| 615 | ✗ | av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n", | |
| 616 | ✗ | avctx->bits_per_raw_sample, pixdesc->comp[0].depth); | |
| 617 | ✗ | avctx->bits_per_raw_sample = pixdesc->comp[0].depth; | |
| 618 | } | ||
| 619 |
2/4✓ Branch 0 taken 20023 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 20023 times.
|
20023 | if (avctx->width <= 0 || avctx->height <= 0) { |
| 620 | ✗ | av_log(avctx, AV_LOG_ERROR, "dimensions not set\n"); | |
| 621 | ✗ | return AVERROR(EINVAL); | |
| 622 | } | ||
| 623 | |||
| 624 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20023 times.
|
20023 | if (avctx->hw_frames_ctx) { |
| 625 | ✗ | AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data; | |
| 626 | ✗ | if (frames_ctx->format != avctx->pix_fmt) { | |
| 627 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 628 | "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n"); | ||
| 629 | ✗ | return AVERROR(EINVAL); | |
| 630 | } | ||
| 631 | ✗ | if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE && | |
| 632 | ✗ | avctx->sw_pix_fmt != frames_ctx->sw_format) { | |
| 633 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 634 | "Mismatching AVCodecContext.sw_pix_fmt (%s) " | ||
| 635 | "and AVHWFramesContext.sw_format (%s)\n", | ||
| 636 | av_get_pix_fmt_name(avctx->sw_pix_fmt), | ||
| 637 | av_get_pix_fmt_name(frames_ctx->sw_format)); | ||
| 638 | ✗ | return AVERROR(EINVAL); | |
| 639 | } | ||
| 640 | ✗ | avctx->sw_pix_fmt = frames_ctx->sw_format; | |
| 641 | } | ||
| 642 | |||
| 643 | 20023 | return 0; | |
| 644 | } | ||
| 645 | |||
| 646 | 1353 | static int encode_preinit_audio(AVCodecContext *avctx) | |
| 647 | { | ||
| 648 | 1353 | const AVCodec *c = avctx->codec; | |
| 649 | const enum AVSampleFormat *sample_fmts; | ||
| 650 | const int *supported_samplerates; | ||
| 651 | const AVChannelLayout *ch_layouts; | ||
| 652 | int ret, i, num_sample_fmts, num_samplerates, num_ch_layouts; | ||
| 653 | |||
| 654 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1353 times.
|
1353 | if (!av_get_sample_fmt_name(avctx->sample_fmt)) { |
| 655 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid audio sample format: %d\n", | |
| 656 | ✗ | avctx->sample_fmt); | |
| 657 | ✗ | return AVERROR(EINVAL); | |
| 658 | } | ||
| 659 | |||
| 660 | 1353 | ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_SAMPLE_FORMAT, | |
| 661 | 0, (const void **) &sample_fmts, | ||
| 662 | &num_sample_fmts); | ||
| 663 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1353 times.
|
1353 | if (ret < 0) |
| 664 | ✗ | return ret; | |
| 665 |
1/2✓ Branch 0 taken 1353 times.
✗ Branch 1 not taken.
|
1353 | if (sample_fmts) { |
| 666 |
1/2✓ Branch 0 taken 1370 times.
✗ Branch 1 not taken.
|
1370 | for (i = 0; i < num_sample_fmts; i++) { |
| 667 |
2/2✓ Branch 0 taken 1353 times.
✓ Branch 1 taken 17 times.
|
1370 | if (avctx->sample_fmt == sample_fmts[i]) |
| 668 | 1353 | break; | |
| 669 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
21 | if (avctx->ch_layout.nb_channels == 1 && |
| 670 | 4 | av_get_planar_sample_fmt(avctx->sample_fmt) == | |
| 671 | 4 | av_get_planar_sample_fmt(sample_fmts[i])) { | |
| 672 | ✗ | avctx->sample_fmt = sample_fmts[i]; | |
| 673 | ✗ | break; | |
| 674 | } | ||
| 675 | } | ||
| 676 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1353 times.
|
1353 | if (i == num_sample_fmts) { |
| 677 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 678 | "Specified sample format %s is not supported by the %s encoder\n", | ||
| 679 | ✗ | av_get_sample_fmt_name(avctx->sample_fmt), c->name); | |
| 680 | |||
| 681 | ✗ | av_log(avctx, AV_LOG_ERROR, "Supported sample formats:\n"); | |
| 682 | ✗ | for (int p = 0; sample_fmts[p] != AV_SAMPLE_FMT_NONE; p++) { | |
| 683 | ✗ | av_log(avctx, AV_LOG_ERROR, " %s\n", | |
| 684 | ✗ | av_get_sample_fmt_name(sample_fmts[p])); | |
| 685 | } | ||
| 686 | |||
| 687 | ✗ | return AVERROR(EINVAL); | |
| 688 | } | ||
| 689 | } | ||
| 690 | |||
| 691 | 1353 | ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_SAMPLE_RATE, | |
| 692 | 0, (const void **) &supported_samplerates, | ||
| 693 | &num_samplerates); | ||
| 694 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1353 times.
|
1353 | if (ret < 0) |
| 695 | ✗ | return ret; | |
| 696 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 1292 times.
|
1353 | if (supported_samplerates) { |
| 697 |
1/2✓ Branch 0 taken 132 times.
✗ Branch 1 not taken.
|
132 | for (i = 0; i < num_samplerates; i++) |
| 698 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 71 times.
|
132 | if (avctx->sample_rate == supported_samplerates[i]) |
| 699 | 61 | break; | |
| 700 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (i == num_samplerates) { |
| 701 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 702 | "Specified sample rate %d is not supported by the %s encoder\n", | ||
| 703 | ✗ | avctx->sample_rate, c->name); | |
| 704 | |||
| 705 | ✗ | av_log(avctx, AV_LOG_ERROR, "Supported sample rates:\n"); | |
| 706 | ✗ | for (int p = 0; supported_samplerates[p]; p++) | |
| 707 | ✗ | av_log(avctx, AV_LOG_ERROR, " %d\n", supported_samplerates[p]); | |
| 708 | |||
| 709 | ✗ | return AVERROR(EINVAL); | |
| 710 | } | ||
| 711 | } | ||
| 712 | 1353 | ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_CHANNEL_LAYOUT, | |
| 713 | 0, (const void **) &ch_layouts, &num_ch_layouts); | ||
| 714 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1353 times.
|
1353 | if (ret < 0) |
| 715 | ✗ | return ret; | |
| 716 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 1274 times.
|
1353 | if (ch_layouts) { |
| 717 |
1/2✓ Branch 0 taken 140 times.
✗ Branch 1 not taken.
|
140 | for (i = 0; i < num_ch_layouts; i++) { |
| 718 |
2/2✓ Branch 1 taken 79 times.
✓ Branch 2 taken 61 times.
|
140 | if (!av_channel_layout_compare(&avctx->ch_layout, &ch_layouts[i])) |
| 719 | 79 | break; | |
| 720 | } | ||
| 721 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
|
79 | if (i == num_ch_layouts) { |
| 722 | char buf[512]; | ||
| 723 | ✗ | int ret = av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf)); | |
| 724 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
| 725 | "Specified channel layout '%s' is not supported by the %s encoder\n", | ||
| 726 | ✗ | ret > 0 ? buf : "?", c->name); | |
| 727 | |||
| 728 | ✗ | av_log(avctx, AV_LOG_ERROR, "Supported channel layouts:\n"); | |
| 729 | ✗ | for (int p = 0; ch_layouts[p].nb_channels; p++) { | |
| 730 | ✗ | ret = av_channel_layout_describe(&ch_layouts[p], buf, sizeof(buf)); | |
| 731 | ✗ | av_log(avctx, AV_LOG_ERROR, " %s\n", ret > 0 ? buf : "?"); | |
| 732 | } | ||
| 733 | ✗ | return AVERROR(EINVAL); | |
| 734 | } | ||
| 735 | } | ||
| 736 | |||
| 737 |
2/2✓ Branch 0 taken 1300 times.
✓ Branch 1 taken 53 times.
|
1353 | if (!avctx->bits_per_raw_sample) |
| 738 | 1300 | avctx->bits_per_raw_sample = av_get_exact_bits_per_sample(avctx->codec_id); | |
| 739 |
2/2✓ Branch 0 taken 171 times.
✓ Branch 1 taken 1182 times.
|
1353 | if (!avctx->bits_per_raw_sample) |
| 740 | 171 | avctx->bits_per_raw_sample = 8 * av_get_bytes_per_sample(avctx->sample_fmt); | |
| 741 | |||
| 742 | 1353 | return 0; | |
| 743 | } | ||
| 744 | |||
| 745 | 21418 | int ff_encode_preinit(AVCodecContext *avctx) | |
| 746 | { | ||
| 747 | 21418 | AVCodecInternal *avci = avctx->internal; | |
| 748 | 21418 | EncodeContext *ec = encode_ctx(avci); | |
| 749 | 21418 | int ret = 0; | |
| 750 | |||
| 751 |
2/4✓ Branch 0 taken 21418 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21418 times.
|
21418 | if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) { |
| 752 | ✗ | av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n"); | |
| 753 | ✗ | return AVERROR(EINVAL); | |
| 754 | } | ||
| 755 | |||
| 756 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21418 times.
|
21418 | if (avctx->bit_rate < 0) { |
| 757 | ✗ | av_log(avctx, AV_LOG_ERROR, "The encoder bitrate is negative.\n"); | |
| 758 | ✗ | return AVERROR(EINVAL); | |
| 759 | } | ||
| 760 | |||
| 761 |
2/2✓ Branch 0 taken 21325 times.
✓ Branch 1 taken 93 times.
|
21418 | if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE && |
| 762 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21325 times.
|
21325 | !(avctx->codec->capabilities & AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE)) { |
| 763 | ✗ | av_log(avctx, AV_LOG_ERROR, "The copy_opaque flag is set, but the " | |
| 764 | "encoder does not support it.\n"); | ||
| 765 | ✗ | return AVERROR(EINVAL); | |
| 766 | } | ||
| 767 | |||
| 768 |
3/3✓ Branch 0 taken 20023 times.
✓ Branch 1 taken 1353 times.
✓ Branch 2 taken 42 times.
|
21418 | switch (avctx->codec_type) { |
| 769 | 20023 | case AVMEDIA_TYPE_VIDEO: ret = encode_preinit_video(avctx); break; | |
| 770 | 1353 | case AVMEDIA_TYPE_AUDIO: ret = encode_preinit_audio(avctx); break; | |
| 771 | } | ||
| 772 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21418 times.
|
21418 | if (ret < 0) |
| 773 | ✗ | return ret; | |
| 774 | |||
| 775 |
4/4✓ Branch 0 taken 1395 times.
✓ Branch 1 taken 20023 times.
✓ Branch 2 taken 1353 times.
✓ Branch 3 taken 42 times.
|
21418 | if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO) |
| 776 |
3/4✓ Branch 0 taken 21355 times.
✓ Branch 1 taken 21 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 21355 times.
|
21376 | && avctx->bit_rate>0 && avctx->bit_rate<1000) { |
| 777 | ✗ | av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate); | |
| 778 | } | ||
| 779 | |||
| 780 |
2/2✓ Branch 0 taken 21416 times.
✓ Branch 1 taken 2 times.
|
21418 | if (!avctx->rc_initial_buffer_occupancy) |
| 781 | 21416 | avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4; | |
| 782 | |||
| 783 |
2/2✓ Branch 0 taken 21015 times.
✓ Branch 1 taken 403 times.
|
21418 | if (avctx->codec_descriptor->props & AV_CODEC_PROP_INTRA_ONLY) |
| 784 | 21015 | ec->intra_only_flag = AV_PKT_FLAG_KEY; | |
| 785 | |||
| 786 |
2/2✓ Branch 1 taken 21376 times.
✓ Branch 2 taken 42 times.
|
21418 | if (ffcodec(avctx->codec)->cb_type == FF_CODEC_CB_TYPE_ENCODE) { |
| 787 | 21376 | avci->in_frame = av_frame_alloc(); | |
| 788 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21376 times.
|
21376 | if (!avci->in_frame) |
| 789 | ✗ | return AVERROR(ENOMEM); | |
| 790 | } | ||
| 791 | |||
| 792 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 21416 times.
|
21418 | if ((avctx->flags & AV_CODEC_FLAG_RECON_FRAME)) { |
| 793 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!(avctx->codec->capabilities & AV_CODEC_CAP_ENCODER_RECON_FRAME)) { |
| 794 | ✗ | av_log(avctx, AV_LOG_ERROR, "Reconstructed frame output requested " | |
| 795 | "from an encoder not supporting it\n"); | ||
| 796 | ✗ | return AVERROR(ENOSYS); | |
| 797 | } | ||
| 798 | |||
| 799 | 2 | avci->recon_frame = av_frame_alloc(); | |
| 800 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!avci->recon_frame) |
| 801 | ✗ | return AVERROR(ENOMEM); | |
| 802 | } | ||
| 803 | |||
| 804 |
2/2✓ Branch 0 taken 235598 times.
✓ Branch 1 taken 21418 times.
|
257016 | for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) { |
| 805 | 235598 | const enum AVPacketSideDataType type_packet = ff_sd_global_map[i].packet; | |
| 806 | 235598 | const enum AVFrameSideDataType type_frame = ff_sd_global_map[i].frame; | |
| 807 | const AVFrameSideData *sd_frame; | ||
| 808 | AVPacketSideData *sd_packet; | ||
| 809 | |||
| 810 | 235598 | sd_frame = av_frame_side_data_get(avctx->decoded_side_data, | |
| 811 | avctx->nb_decoded_side_data, | ||
| 812 | type_frame); | ||
| 813 |
3/4✓ Branch 0 taken 255 times.
✓ Branch 1 taken 235343 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 255 times.
|
235853 | if (!sd_frame || |
| 814 | 255 | av_packet_side_data_get(avctx->coded_side_data, avctx->nb_coded_side_data, | |
| 815 | type_packet)) | ||
| 816 | |||
| 817 | 235343 | continue; | |
| 818 | |||
| 819 | 255 | sd_packet = av_packet_side_data_new(&avctx->coded_side_data, &avctx->nb_coded_side_data, | |
| 820 | 255 | type_packet, sd_frame->size, 0); | |
| 821 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 255 times.
|
255 | if (!sd_packet) |
| 822 | ✗ | return AVERROR(ENOMEM); | |
| 823 | |||
| 824 | 255 | memcpy(sd_packet->data, sd_frame->data, sd_frame->size); | |
| 825 | } | ||
| 826 | |||
| 827 | if (CONFIG_FRAME_THREAD_ENCODER) { | ||
| 828 | 21418 | ret = ff_frame_thread_encoder_init(avctx); | |
| 829 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21418 times.
|
21418 | if (ret < 0) |
| 830 | ✗ | return ret; | |
| 831 | } | ||
| 832 | |||
| 833 | 21418 | return 0; | |
| 834 | } | ||
| 835 | |||
| 836 | 12060 | int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame) | |
| 837 | { | ||
| 838 | int ret; | ||
| 839 | |||
| 840 | av_assert1(avctx->codec_type == AVMEDIA_TYPE_VIDEO); | ||
| 841 | |||
| 842 | 12060 | frame->format = avctx->pix_fmt; | |
| 843 |
3/4✓ Branch 0 taken 12044 times.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12044 times.
|
12060 | if (frame->width <= 0 || frame->height <= 0) { |
| 844 | 16 | frame->width = avctx->width; | |
| 845 | 16 | frame->height = avctx->height; | |
| 846 | } | ||
| 847 | |||
| 848 | 12060 | ret = avcodec_default_get_buffer2(avctx, frame, 0); | |
| 849 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12060 times.
|
12060 | if (ret < 0) { |
| 850 | ✗ | av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
| 851 | ✗ | av_frame_unref(frame); | |
| 852 | ✗ | return ret; | |
| 853 | } | ||
| 854 | |||
| 855 | 12060 | return 0; | |
| 856 | } | ||
| 857 | |||
| 858 | 62 | int ff_encode_receive_frame(AVCodecContext *avctx, AVFrame *frame) | |
| 859 | { | ||
| 860 | 62 | AVCodecInternal *avci = avctx->internal; | |
| 861 | |||
| 862 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
|
62 | if (!avci->recon_frame) |
| 863 | ✗ | return AVERROR(EINVAL); | |
| 864 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
|
62 | if (!avci->recon_frame->buf[0]) |
| 865 | ✗ | return avci->draining_done ? AVERROR_EOF : AVERROR(EAGAIN); | |
| 866 | |||
| 867 | 62 | av_frame_move_ref(frame, avci->recon_frame); | |
| 868 | 62 | return 0; | |
| 869 | } | ||
| 870 | |||
| 871 | ✗ | void ff_encode_flush_buffers(AVCodecContext *avctx) | |
| 872 | { | ||
| 873 | ✗ | AVCodecInternal *avci = avctx->internal; | |
| 874 | |||
| 875 | ✗ | if (avci->in_frame) | |
| 876 | ✗ | av_frame_unref(avci->in_frame); | |
| 877 | ✗ | if (avci->recon_frame) | |
| 878 | ✗ | av_frame_unref(avci->recon_frame); | |
| 879 | ✗ | } | |
| 880 | |||
| 881 | 21418 | AVCodecInternal *ff_encode_internal_alloc(void) | |
| 882 | { | ||
| 883 | 21418 | return av_mallocz(sizeof(EncodeContext)); | |
| 884 | } | ||
| 885 | |||
| 886 | 206 | AVCPBProperties *ff_encode_add_cpb_side_data(AVCodecContext *avctx) | |
| 887 | { | ||
| 888 | AVPacketSideData *tmp; | ||
| 889 | AVCPBProperties *props; | ||
| 890 | size_t size; | ||
| 891 | int i; | ||
| 892 | |||
| 893 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 206 times.
|
207 | for (i = 0; i < avctx->nb_coded_side_data; i++) |
| 894 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (avctx->coded_side_data[i].type == AV_PKT_DATA_CPB_PROPERTIES) |
| 895 | ✗ | return (AVCPBProperties *)avctx->coded_side_data[i].data; | |
| 896 | |||
| 897 | 206 | props = av_cpb_properties_alloc(&size); | |
| 898 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 206 times.
|
206 | if (!props) |
| 899 | ✗ | return NULL; | |
| 900 | |||
| 901 | 206 | tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp)); | |
| 902 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 206 times.
|
206 | if (!tmp) { |
| 903 | ✗ | av_freep(&props); | |
| 904 | ✗ | return NULL; | |
| 905 | } | ||
| 906 | |||
| 907 | 206 | avctx->coded_side_data = tmp; | |
| 908 | 206 | avctx->nb_coded_side_data++; | |
| 909 | |||
| 910 | 206 | avctx->coded_side_data[avctx->nb_coded_side_data - 1].type = AV_PKT_DATA_CPB_PROPERTIES; | |
| 911 | 206 | avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props; | |
| 912 | 206 | avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size; | |
| 913 | |||
| 914 | 206 | return props; | |
| 915 | } | ||
| 916 | |||
| 917 | 1614 | int ff_check_codec_matrices(AVCodecContext *avctx, unsigned types, uint16_t min, uint16_t max) | |
| 918 | { | ||
| 919 | 1614 | uint16_t *matrices[] = {avctx->intra_matrix, avctx->inter_matrix, avctx->chroma_intra_matrix}; | |
| 920 | 1614 | const char *names[] = {"Intra", "Inter", "Chroma Intra"}; | |
| 921 | static_assert(FF_ARRAY_ELEMS(matrices) == FF_ARRAY_ELEMS(names), "matrix count mismatch"); | ||
| 922 |
2/2✓ Branch 0 taken 4842 times.
✓ Branch 1 taken 1614 times.
|
6456 | for (int m = 0; m < FF_ARRAY_ELEMS(matrices); m++) { |
| 923 | 4842 | uint16_t *matrix = matrices[m]; | |
| 924 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 4842 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
4842 | if (matrix && (types & (1U << m))) { |
| 925 | ✗ | for (int i = 0; i < 64; i++) { | |
| 926 | ✗ | if (matrix[i] < min || matrix[i] > max) { | |
| 927 | ✗ | av_log(avctx, AV_LOG_ERROR, "%s matrix[%d] is %d which is out of the allowed range [%"PRIu16"-%"PRIu16"].\n", names[m], i, matrix[i], min, max); | |
| 928 | ✗ | return AVERROR(EINVAL); | |
| 929 | } | ||
| 930 | } | ||
| 931 | } | ||
| 932 | } | ||
| 933 | 1614 | return 0; | |
| 934 | } | ||
| 935 |