1 /*
2  * AVCodecContext functions for libavcodec
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  * AVCodecContext functions for libavcodec
24  */
25 
26 #include "config.h"
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/thread.h"
33 #include "avcodec.h"
34 #include "decode.h"
35 #include "encode.h"
36 #include "frame_thread_encoder.h"
37 #include "internal.h"
38 #include "thread.h"
39 #if CONFIG_ICONV
40 # include <iconv.h>
41 #endif
42 
43 #include "libavutil/ffversion.h"
44 const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
45 
avcodec_version(void)46 unsigned avcodec_version(void)
47 {
48     av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
49     av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
50     av_assert0(AV_CODEC_ID_SRT==94216);
51     av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
52 
53     return LIBAVCODEC_VERSION_INT;
54 }
55 
avcodec_configuration(void)56 const char *avcodec_configuration(void)
57 {
58     return FFMPEG_CONFIGURATION;
59 }
60 
avcodec_license(void)61 const char *avcodec_license(void)
62 {
63 #define LICENSE_PREFIX "libavcodec license: "
64     return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
65 }
66 
avcodec_default_execute(AVCodecContext * c,int (* func)(AVCodecContext * c2,void * arg2),void * arg,int * ret,int count,int size)67 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
68 {
69     int i;
70 
71     for (i = 0; i < count; i++) {
72         int r = func(c, (char *)arg + i * size);
73         if (ret)
74             ret[i] = r;
75     }
76     emms_c();
77     return 0;
78 }
79 
avcodec_default_execute2(AVCodecContext * c,int (* func)(AVCodecContext * c2,void * arg2,int jobnr,int threadnr),void * arg,int * ret,int count)80 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
81 {
82     int i;
83 
84     for (i = 0; i < count; i++) {
85         int r = func(c, arg, i, 0);
86         if (ret)
87             ret[i] = r;
88     }
89     emms_c();
90     return 0;
91 }
92 
93 static AVMutex codec_mutex = AV_MUTEX_INITIALIZER;
94 
lock_avcodec(const AVCodec * codec)95 static void lock_avcodec(const AVCodec *codec)
96 {
97     if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
98         ff_mutex_lock(&codec_mutex);
99 }
100 
unlock_avcodec(const AVCodec * codec)101 static void unlock_avcodec(const AVCodec *codec)
102 {
103     if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
104         ff_mutex_unlock(&codec_mutex);
105 }
106 
107 #if FF_API_LOCKMGR
av_lockmgr_register(int (* cb)(void ** mutex,enum AVLockOp op))108 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
109 {
110     return 0;
111 }
112 #endif
113 
get_bit_rate(AVCodecContext * ctx)114 static int64_t get_bit_rate(AVCodecContext *ctx)
115 {
116     int64_t bit_rate;
117     int bits_per_sample;
118 
119     switch (ctx->codec_type) {
120     case AVMEDIA_TYPE_VIDEO:
121     case AVMEDIA_TYPE_DATA:
122     case AVMEDIA_TYPE_SUBTITLE:
123     case AVMEDIA_TYPE_ATTACHMENT:
124         bit_rate = ctx->bit_rate;
125         break;
126     case AVMEDIA_TYPE_AUDIO:
127         bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
128         if (bits_per_sample) {
129             bit_rate = ctx->sample_rate * (int64_t)ctx->channels;
130             if (bit_rate > INT64_MAX / bits_per_sample) {
131                 bit_rate = 0;
132             } else
133                 bit_rate *= bits_per_sample;
134         } else
135             bit_rate = ctx->bit_rate;
136         break;
137     default:
138         bit_rate = 0;
139         break;
140     }
141     return bit_rate;
142 }
143 
avcodec_open2(AVCodecContext * avctx,const AVCodec * codec,AVDictionary ** options)144 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
145 {
146     int ret = 0;
147     int codec_init_ok = 0;
148     AVDictionary *tmp = NULL;
149     AVCodecInternal *avci;
150 
151     if (avcodec_is_open(avctx))
152         return 0;
153 
154     if (!codec && !avctx->codec) {
155         av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
156         return AVERROR(EINVAL);
157     }
158     if (codec && avctx->codec && codec != avctx->codec) {
159         av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
160                                     "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
161         return AVERROR(EINVAL);
162     }
163     if (!codec)
164         codec = avctx->codec;
165 
166     if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
167         return AVERROR(EINVAL);
168 
169     if (options)
170         av_dict_copy(&tmp, *options, 0);
171 
172     lock_avcodec(codec);
173 
174     avci = av_mallocz(sizeof(*avci));
175     if (!avci) {
176         ret = AVERROR(ENOMEM);
177         goto end;
178     }
179     avctx->internal = avci;
180 
181 #if FF_API_OLD_ENCDEC
182     avci->to_free = av_frame_alloc();
183     avci->compat_decode_frame = av_frame_alloc();
184     avci->compat_encode_packet = av_packet_alloc();
185     if (!avci->to_free || !avci->compat_decode_frame || !avci->compat_encode_packet) {
186         ret = AVERROR(ENOMEM);
187         goto free_and_end;
188     }
189 #endif
190     avci->buffer_frame = av_frame_alloc();
191     avci->buffer_pkt = av_packet_alloc();
192     avci->es.in_frame = av_frame_alloc();
193     avci->ds.in_pkt = av_packet_alloc();
194     avci->last_pkt_props = av_packet_alloc();
195     avci->pkt_props = av_fifo_alloc(sizeof(*avci->last_pkt_props));
196     if (!avci->buffer_frame || !avci->buffer_pkt          ||
197         !avci->es.in_frame  || !avci->ds.in_pkt           ||
198         !avci->last_pkt_props || !avci->pkt_props) {
199         ret = AVERROR(ENOMEM);
200         goto free_and_end;
201     }
202 
203     avci->skip_samples_multiplier = 1;
204 
205     if (codec->priv_data_size > 0) {
206         if (!avctx->priv_data) {
207             avctx->priv_data = av_mallocz(codec->priv_data_size);
208             if (!avctx->priv_data) {
209                 ret = AVERROR(ENOMEM);
210                 goto free_and_end;
211             }
212             if (codec->priv_class) {
213                 *(const AVClass **)avctx->priv_data = codec->priv_class;
214                 av_opt_set_defaults(avctx->priv_data);
215             }
216         }
217         if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
218             goto free_and_end;
219     } else {
220         avctx->priv_data = NULL;
221     }
222     if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
223         goto free_and_end;
224 
225     if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
226         av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
227         ret = AVERROR(EINVAL);
228         goto free_and_end;
229     }
230 
231     // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
232     if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
233           (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
234         if (avctx->coded_width && avctx->coded_height)
235             ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
236         else if (avctx->width && avctx->height)
237             ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
238         if (ret < 0)
239             goto free_and_end;
240     }
241 
242     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
243         && (  av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
244            || av_image_check_size2(avctx->width,       avctx->height,       avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
245         av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
246         ff_set_dimensions(avctx, 0, 0);
247     }
248 
249     if (avctx->width > 0 && avctx->height > 0) {
250         if (av_image_check_sar(avctx->width, avctx->height,
251                                avctx->sample_aspect_ratio) < 0) {
252             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
253                    avctx->sample_aspect_ratio.num,
254                    avctx->sample_aspect_ratio.den);
255             avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
256         }
257     }
258 
259     if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
260         av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
261         ret = AVERROR(EINVAL);
262         goto free_and_end;
263     }
264     if (av_codec_is_decoder(codec) &&
265         codec->type == AVMEDIA_TYPE_AUDIO &&
266         !(codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF) &&
267         avctx->channels == 0) {
268         av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
269         ret = AVERROR(EINVAL);
270         goto free_and_end;
271     }
272 
273     if (avctx->sample_rate < 0) {
274         av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
275         ret = AVERROR(EINVAL);
276         goto free_and_end;
277     }
278     if (avctx->block_align < 0) {
279         av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
280         ret = AVERROR(EINVAL);
281         goto free_and_end;
282     }
283 
284     avctx->codec = codec;
285     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
286         avctx->codec_id == AV_CODEC_ID_NONE) {
287         avctx->codec_type = codec->type;
288         avctx->codec_id   = codec->id;
289     }
290     if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
291                                          && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
292         av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
293         ret = AVERROR(EINVAL);
294         goto free_and_end;
295     }
296     avctx->frame_number = 0;
297     avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
298 
299     if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
300         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
301         const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
302         const AVCodec *codec2;
303         av_log(avctx, AV_LOG_ERROR,
304                "The %s '%s' is experimental but experimental codecs are not enabled, "
305                "add '-strict %d' if you want to use it.\n",
306                codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
307         codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
308         if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
309             av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
310                 codec_string, codec2->name);
311         ret = AVERROR_EXPERIMENTAL;
312         goto free_and_end;
313     }
314 
315     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
316         (!avctx->time_base.num || !avctx->time_base.den)) {
317         avctx->time_base.num = 1;
318         avctx->time_base.den = avctx->sample_rate;
319     }
320 
321     if (av_codec_is_encoder(avctx->codec))
322         ret = ff_encode_preinit(avctx);
323     else
324         ret = ff_decode_preinit(avctx);
325     if (ret < 0)
326         goto free_and_end;
327 
328     if (!HAVE_THREADS)
329         av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
330 
331     if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
332         unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
333         ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
334         lock_avcodec(codec);
335         if (ret < 0)
336             goto free_and_end;
337     }
338 
339     if (HAVE_THREADS
340         && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
341         ret = ff_thread_init(avctx);
342         if (ret < 0) {
343             goto free_and_end;
344         }
345     }
346     if (!HAVE_THREADS && !(codec->caps_internal & FF_CODEC_CAP_AUTO_THREADS))
347         avctx->thread_count = 1;
348 
349     if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
350         || avci->frame_thread_encoder)) {
351         ret = avctx->codec->init(avctx);
352         if (ret < 0) {
353             codec_init_ok = -1;
354             goto free_and_end;
355         }
356         codec_init_ok = 1;
357     }
358 
359     ret=0;
360 
361     if (av_codec_is_decoder(avctx->codec)) {
362         if (!avctx->bit_rate)
363             avctx->bit_rate = get_bit_rate(avctx);
364         /* validate channel layout from the decoder */
365         if (avctx->channel_layout) {
366             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
367             if (!avctx->channels)
368                 avctx->channels = channels;
369             else if (channels != avctx->channels) {
370                 char buf[512];
371                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
372                 av_log(avctx, AV_LOG_WARNING,
373                        "Channel layout '%s' with %d channels does not match specified number of channels %d: "
374                        "ignoring specified channel layout\n",
375                        buf, channels, avctx->channels);
376                 avctx->channel_layout = 0;
377             }
378         }
379         if (avctx->channels && avctx->channels < 0 ||
380             avctx->channels > FF_SANE_NB_CHANNELS) {
381             ret = AVERROR(EINVAL);
382             goto free_and_end;
383         }
384         if (avctx->bits_per_coded_sample < 0) {
385             ret = AVERROR(EINVAL);
386             goto free_and_end;
387         }
388         if (avctx->sub_charenc) {
389             if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
390                 av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
391                        "supported with subtitles codecs\n");
392                 ret = AVERROR(EINVAL);
393                 goto free_and_end;
394             } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
395                 av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
396                        "subtitles character encoding will be ignored\n",
397                        avctx->codec_descriptor->name);
398                 avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
399             } else {
400                 /* input character encoding is set for a text based subtitle
401                  * codec at this point */
402                 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
403                     avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
404 
405                 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
406 #if CONFIG_ICONV
407                     iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
408                     if (cd == (iconv_t)-1) {
409                         ret = AVERROR(errno);
410                         av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
411                                "with input character encoding \"%s\"\n", avctx->sub_charenc);
412                         goto free_and_end;
413                     }
414                     iconv_close(cd);
415 #else
416                     av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
417                            "conversion needs a libavcodec built with iconv support "
418                            "for this codec\n");
419                     ret = AVERROR(ENOSYS);
420                     goto free_and_end;
421 #endif
422                 }
423             }
424         }
425 
426 #if FF_API_AVCTX_TIMEBASE
427         if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
428             avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
429 #endif
430     }
431     if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
432         av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
433     }
434 
435 end:
436     unlock_avcodec(codec);
437     if (options) {
438         av_dict_free(options);
439         *options = tmp;
440     }
441 
442     return ret;
443 free_and_end:
444     if (avctx->codec && avctx->codec->close &&
445         (codec_init_ok > 0 || (codec_init_ok < 0 &&
446          avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)))
447         avctx->codec->close(avctx);
448 
449     if (HAVE_THREADS && avci->thread_ctx)
450         ff_thread_free(avctx);
451 
452     if (codec->priv_class && avctx->priv_data)
453         av_opt_free(avctx->priv_data);
454     av_opt_free(avctx);
455 
456     if (av_codec_is_encoder(avctx->codec)) {
457 #if FF_API_CODED_FRAME
458 FF_DISABLE_DEPRECATION_WARNINGS
459         av_frame_free(&avctx->coded_frame);
460 FF_ENABLE_DEPRECATION_WARNINGS
461 #endif
462         av_freep(&avctx->extradata);
463         avctx->extradata_size = 0;
464     }
465 
466     av_dict_free(&tmp);
467     av_freep(&avctx->priv_data);
468     av_freep(&avctx->subtitle_header);
469 
470 #if FF_API_OLD_ENCDEC
471     av_frame_free(&avci->to_free);
472     av_frame_free(&avci->compat_decode_frame);
473     av_packet_free(&avci->compat_encode_packet);
474 #endif
475     av_frame_free(&avci->buffer_frame);
476     av_packet_free(&avci->buffer_pkt);
477     av_packet_free(&avci->last_pkt_props);
478     av_fifo_freep(&avci->pkt_props);
479 
480     av_packet_free(&avci->ds.in_pkt);
481     av_frame_free(&avci->es.in_frame);
482     av_bsf_free(&avci->bsf);
483 
484     av_buffer_unref(&avci->pool);
485     av_freep(&avci);
486     avctx->internal = NULL;
487     avctx->codec = NULL;
488     goto end;
489 }
490 
avcodec_flush_buffers(AVCodecContext * avctx)491 void avcodec_flush_buffers(AVCodecContext *avctx)
492 {
493     AVCodecInternal *avci = avctx->internal;
494 
495     if (av_codec_is_encoder(avctx->codec)) {
496         int caps = avctx->codec->capabilities;
497 
498         if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
499             // Only encoders that explicitly declare support for it can be
500             // flushed. Otherwise, this is a no-op.
501             av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
502                    "that doesn't support it\n");
503             return;
504         }
505 
506         // We haven't implemented flushing for frame-threaded encoders.
507         av_assert0(!(caps & AV_CODEC_CAP_FRAME_THREADS));
508     }
509 
510     avci->draining      = 0;
511     avci->draining_done = 0;
512     avci->nb_draining_errors = 0;
513     av_frame_unref(avci->buffer_frame);
514 #if FF_API_OLD_ENCDEC
515     av_frame_unref(avci->compat_decode_frame);
516     av_packet_unref(avci->compat_encode_packet);
517 #endif
518     av_packet_unref(avci->buffer_pkt);
519 
520     av_packet_unref(avci->last_pkt_props);
521     while (av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props)) {
522         av_fifo_generic_read(avci->pkt_props,
523                              avci->last_pkt_props, sizeof(*avci->last_pkt_props),
524                              NULL);
525         av_packet_unref(avci->last_pkt_props);
526     }
527     av_fifo_reset(avci->pkt_props);
528 
529     av_frame_unref(avci->es.in_frame);
530     av_packet_unref(avci->ds.in_pkt);
531 
532     if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
533         ff_thread_flush(avctx);
534     else if (avctx->codec->flush)
535         avctx->codec->flush(avctx);
536 
537     avctx->pts_correction_last_pts =
538     avctx->pts_correction_last_dts = INT64_MIN;
539 
540     if (av_codec_is_decoder(avctx->codec))
541         av_bsf_flush(avci->bsf);
542 
543 #if FF_API_OLD_ENCDEC
544 FF_DISABLE_DEPRECATION_WARNINGS
545     if (!avctx->refcounted_frames)
546         av_frame_unref(avci->to_free);
547 FF_ENABLE_DEPRECATION_WARNINGS
548 #endif
549 }
550 
avsubtitle_free(AVSubtitle * sub)551 void avsubtitle_free(AVSubtitle *sub)
552 {
553     int i;
554 
555     for (i = 0; i < sub->num_rects; i++) {
556         av_freep(&sub->rects[i]->data[0]);
557         av_freep(&sub->rects[i]->data[1]);
558         av_freep(&sub->rects[i]->data[2]);
559         av_freep(&sub->rects[i]->data[3]);
560         av_freep(&sub->rects[i]->text);
561         av_freep(&sub->rects[i]->ass);
562         av_freep(&sub->rects[i]);
563     }
564 
565     av_freep(&sub->rects);
566 
567     memset(sub, 0, sizeof(*sub));
568 }
569 
avcodec_close(AVCodecContext * avctx)570 av_cold int avcodec_close(AVCodecContext *avctx)
571 {
572     int i;
573 
574     if (!avctx)
575         return 0;
576 
577     if (avcodec_is_open(avctx)) {
578         if (CONFIG_FRAME_THREAD_ENCODER &&
579             avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
580             ff_frame_thread_encoder_free(avctx);
581         }
582         if (HAVE_THREADS && avctx->internal->thread_ctx)
583             ff_thread_free(avctx);
584         if (avctx->codec && avctx->codec->close)
585             avctx->codec->close(avctx);
586         avctx->internal->byte_buffer_size = 0;
587         av_freep(&avctx->internal->byte_buffer);
588 #if FF_API_OLD_ENCDEC
589         av_frame_free(&avctx->internal->to_free);
590         av_frame_free(&avctx->internal->compat_decode_frame);
591         av_packet_free(&avctx->internal->compat_encode_packet);
592 #endif
593         av_frame_free(&avctx->internal->buffer_frame);
594         av_packet_free(&avctx->internal->buffer_pkt);
595         av_packet_unref(avctx->internal->last_pkt_props);
596         while (av_fifo_size(avctx->internal->pkt_props) >=
597                sizeof(*avctx->internal->last_pkt_props)) {
598             av_fifo_generic_read(avctx->internal->pkt_props,
599                                  avctx->internal->last_pkt_props,
600                                  sizeof(*avctx->internal->last_pkt_props),
601                                  NULL);
602             av_packet_unref(avctx->internal->last_pkt_props);
603         }
604         av_packet_free(&avctx->internal->last_pkt_props);
605         av_fifo_freep(&avctx->internal->pkt_props);
606 
607         av_packet_free(&avctx->internal->ds.in_pkt);
608         av_frame_free(&avctx->internal->es.in_frame);
609 
610         av_buffer_unref(&avctx->internal->pool);
611 
612         if (avctx->hwaccel && avctx->hwaccel->uninit)
613             avctx->hwaccel->uninit(avctx);
614         av_freep(&avctx->internal->hwaccel_priv_data);
615 
616         av_bsf_free(&avctx->internal->bsf);
617 
618         av_freep(&avctx->internal);
619     }
620 
621     for (i = 0; i < avctx->nb_coded_side_data; i++)
622         av_freep(&avctx->coded_side_data[i].data);
623     av_freep(&avctx->coded_side_data);
624     avctx->nb_coded_side_data = 0;
625 
626     av_buffer_unref(&avctx->hw_frames_ctx);
627     av_buffer_unref(&avctx->hw_device_ctx);
628 
629     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
630         av_opt_free(avctx->priv_data);
631     av_opt_free(avctx);
632     av_freep(&avctx->priv_data);
633     if (av_codec_is_encoder(avctx->codec)) {
634         av_freep(&avctx->extradata);
635 #if FF_API_CODED_FRAME
636 FF_DISABLE_DEPRECATION_WARNINGS
637         av_frame_free(&avctx->coded_frame);
638 FF_ENABLE_DEPRECATION_WARNINGS
639 #endif
640     }
641     avctx->codec = NULL;
642     avctx->active_thread_type = 0;
643 
644     return 0;
645 }
646 
unknown_if_null(const char * str)647 static const char *unknown_if_null(const char *str)
648 {
649     return str ? str : "unknown";
650 }
651 
avcodec_string(char * buf,int buf_size,AVCodecContext * enc,int encode)652 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
653 {
654     const char *codec_type;
655     const char *codec_name;
656     const char *profile = NULL;
657     int64_t bitrate;
658     int new_line = 0;
659     AVRational display_aspect_ratio;
660     const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
661     const char *str;
662 
663     if (!buf || buf_size <= 0)
664         return;
665     codec_type = av_get_media_type_string(enc->codec_type);
666     codec_name = avcodec_get_name(enc->codec_id);
667     profile = avcodec_profile_name(enc->codec_id, enc->profile);
668 
669     snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
670              codec_name);
671     buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
672 
673     if (enc->codec && strcmp(enc->codec->name, codec_name))
674         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
675 
676     if (profile)
677         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
678     if (   enc->codec_type == AVMEDIA_TYPE_VIDEO
679         && av_log_get_level() >= AV_LOG_VERBOSE
680         && enc->refs)
681         snprintf(buf + strlen(buf), buf_size - strlen(buf),
682                  ", %d reference frame%s",
683                  enc->refs, enc->refs > 1 ? "s" : "");
684 
685     if (enc->codec_tag)
686         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
687                  av_fourcc2str(enc->codec_tag), enc->codec_tag);
688 
689     switch (enc->codec_type) {
690     case AVMEDIA_TYPE_VIDEO:
691         {
692             char detail[256] = "(";
693 
694             av_strlcat(buf, separator, buf_size);
695 
696             snprintf(buf + strlen(buf), buf_size - strlen(buf),
697                      "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
698                      unknown_if_null(av_get_pix_fmt_name(enc->pix_fmt)));
699             if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
700                 enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
701                 av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
702             if (enc->color_range != AVCOL_RANGE_UNSPECIFIED &&
703                 (str = av_color_range_name(enc->color_range)))
704                 av_strlcatf(detail, sizeof(detail), "%s, ", str);
705 
706             if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
707                 enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
708                 enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
709                 const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
710                 const char *pri = unknown_if_null(av_color_primaries_name(enc->color_primaries));
711                 const char *trc = unknown_if_null(av_color_transfer_name(enc->color_trc));
712                 if (strcmp(col, pri) || strcmp(col, trc)) {
713                     new_line = 1;
714                     av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
715                                 col, pri, trc);
716                 } else
717                     av_strlcatf(detail, sizeof(detail), "%s, ", col);
718             }
719 
720             if (enc->field_order != AV_FIELD_UNKNOWN) {
721                 const char *field_order = "progressive";
722                 if (enc->field_order == AV_FIELD_TT)
723                     field_order = "top first";
724                 else if (enc->field_order == AV_FIELD_BB)
725                     field_order = "bottom first";
726                 else if (enc->field_order == AV_FIELD_TB)
727                     field_order = "top coded first (swapped)";
728                 else if (enc->field_order == AV_FIELD_BT)
729                     field_order = "bottom coded first (swapped)";
730 
731                 av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
732             }
733 
734             if (av_log_get_level() >= AV_LOG_VERBOSE &&
735                 enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED &&
736                 (str = av_chroma_location_name(enc->chroma_sample_location)))
737                 av_strlcatf(detail, sizeof(detail), "%s, ", str);
738 
739             if (strlen(detail) > 1) {
740                 detail[strlen(detail) - 2] = 0;
741                 av_strlcatf(buf, buf_size, "%s)", detail);
742             }
743         }
744 
745         if (enc->width) {
746             av_strlcat(buf, new_line ? separator : ", ", buf_size);
747 
748             snprintf(buf + strlen(buf), buf_size - strlen(buf),
749                      "%dx%d",
750                      enc->width, enc->height);
751 
752             if (av_log_get_level() >= AV_LOG_VERBOSE &&
753                 (enc->width != enc->coded_width ||
754                  enc->height != enc->coded_height))
755                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
756                          " (%dx%d)", enc->coded_width, enc->coded_height);
757 
758             if (enc->sample_aspect_ratio.num) {
759                 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
760                           enc->width * (int64_t)enc->sample_aspect_ratio.num,
761                           enc->height * (int64_t)enc->sample_aspect_ratio.den,
762                           1024 * 1024);
763                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
764                          " [SAR %d:%d DAR %d:%d]",
765                          enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
766                          display_aspect_ratio.num, display_aspect_ratio.den);
767             }
768             if (av_log_get_level() >= AV_LOG_DEBUG) {
769                 int g = av_gcd(enc->time_base.num, enc->time_base.den);
770                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
771                          ", %d/%d",
772                          enc->time_base.num / g, enc->time_base.den / g);
773             }
774         }
775         if (encode) {
776             snprintf(buf + strlen(buf), buf_size - strlen(buf),
777                      ", q=%d-%d", enc->qmin, enc->qmax);
778         } else {
779             if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
780                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
781                          ", Closed Captions");
782             if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
783                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
784                          ", lossless");
785         }
786         break;
787     case AVMEDIA_TYPE_AUDIO:
788         av_strlcat(buf, separator, buf_size);
789 
790         if (enc->sample_rate) {
791             snprintf(buf + strlen(buf), buf_size - strlen(buf),
792                      "%d Hz, ", enc->sample_rate);
793         }
794         av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
795         if (enc->sample_fmt != AV_SAMPLE_FMT_NONE &&
796             (str = av_get_sample_fmt_name(enc->sample_fmt))) {
797             snprintf(buf + strlen(buf), buf_size - strlen(buf),
798                      ", %s", str);
799         }
800         if (   enc->bits_per_raw_sample > 0
801             && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
802             snprintf(buf + strlen(buf), buf_size - strlen(buf),
803                      " (%d bit)", enc->bits_per_raw_sample);
804         if (av_log_get_level() >= AV_LOG_VERBOSE) {
805             if (enc->initial_padding)
806                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
807                          ", delay %d", enc->initial_padding);
808             if (enc->trailing_padding)
809                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
810                          ", padding %d", enc->trailing_padding);
811         }
812         break;
813     case AVMEDIA_TYPE_DATA:
814         if (av_log_get_level() >= AV_LOG_DEBUG) {
815             int g = av_gcd(enc->time_base.num, enc->time_base.den);
816             if (g)
817                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
818                          ", %d/%d",
819                          enc->time_base.num / g, enc->time_base.den / g);
820         }
821         break;
822     case AVMEDIA_TYPE_SUBTITLE:
823         if (enc->width)
824             snprintf(buf + strlen(buf), buf_size - strlen(buf),
825                      ", %dx%d", enc->width, enc->height);
826         break;
827     default:
828         return;
829     }
830     if (encode) {
831         if (enc->flags & AV_CODEC_FLAG_PASS1)
832             snprintf(buf + strlen(buf), buf_size - strlen(buf),
833                      ", pass 1");
834         if (enc->flags & AV_CODEC_FLAG_PASS2)
835             snprintf(buf + strlen(buf), buf_size - strlen(buf),
836                      ", pass 2");
837     }
838     bitrate = get_bit_rate(enc);
839     if (bitrate != 0) {
840         snprintf(buf + strlen(buf), buf_size - strlen(buf),
841                  ", %"PRId64" kb/s", bitrate / 1000);
842     } else if (enc->rc_max_rate > 0) {
843         snprintf(buf + strlen(buf), buf_size - strlen(buf),
844                  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
845     }
846 }
847 
avcodec_is_open(AVCodecContext * s)848 int avcodec_is_open(AVCodecContext *s)
849 {
850     return !!s->internal;
851 }
852