You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

2555 lines
77KB

  1. /*
  2. * utils for libavcodec
  3. * Copyright (c) 2001 Fabrice Bellard
  4. * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
  5. *
  6. * This file is part of Libav.
  7. *
  8. * Libav is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public
  10. * License as published by the Free Software Foundation; either
  11. * version 2.1 of the License, or (at your option) any later version.
  12. *
  13. * Libav is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * Lesser General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public
  19. * License along with Libav; if not, write to the Free Software
  20. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21. */
  22. /**
  23. * @file
  24. * utils.
  25. */
  26. #include "config.h"
  27. #include "libavutil/attributes.h"
  28. #include "libavutil/avassert.h"
  29. #include "libavutil/avstring.h"
  30. #include "libavutil/channel_layout.h"
  31. #include "libavutil/crc.h"
  32. #include "libavutil/frame.h"
  33. #include "libavutil/internal.h"
  34. #include "libavutil/mathematics.h"
  35. #include "libavutil/pixdesc.h"
  36. #include "libavutil/imgutils.h"
  37. #include "libavutil/samplefmt.h"
  38. #include "libavutil/dict.h"
  39. #include "avcodec.h"
  40. #include "libavutil/opt.h"
  41. #include "me_cmp.h"
  42. #include "mpegvideo.h"
  43. #include "thread.h"
  44. #include "internal.h"
  45. #include "bytestream.h"
  46. #include "version.h"
  47. #include <stdlib.h>
  48. #include <stdarg.h>
  49. #include <limits.h>
  50. #include <float.h>
  51. static int volatile entangled_thread_counter = 0;
  52. static int (*lockmgr_cb)(void **mutex, enum AVLockOp op);
  53. static void *codec_mutex;
  54. static void *avformat_mutex;
  55. void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
  56. {
  57. void **p = ptr;
  58. if (min_size > SIZE_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
  59. av_freep(p);
  60. *size = 0;
  61. return;
  62. }
  63. av_fast_malloc(p, size, min_size + FF_INPUT_BUFFER_PADDING_SIZE);
  64. if (*size)
  65. memset((uint8_t *)*p + min_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  66. }
  67. /* encoder management */
  68. static AVCodec *first_avcodec = NULL;
  69. AVCodec *av_codec_next(const AVCodec *c)
  70. {
  71. if (c)
  72. return c->next;
  73. else
  74. return first_avcodec;
  75. }
  76. static av_cold void avcodec_init(void)
  77. {
  78. static int initialized = 0;
  79. if (initialized != 0)
  80. return;
  81. initialized = 1;
  82. if (CONFIG_ME_CMP)
  83. ff_me_cmp_init_static();
  84. }
  85. int av_codec_is_encoder(const AVCodec *codec)
  86. {
  87. return codec && (codec->encode_sub || codec->encode2);
  88. }
  89. int av_codec_is_decoder(const AVCodec *codec)
  90. {
  91. return codec && codec->decode;
  92. }
  93. av_cold void avcodec_register(AVCodec *codec)
  94. {
  95. AVCodec **p;
  96. avcodec_init();
  97. p = &first_avcodec;
  98. while (*p)
  99. p = &(*p)->next;
  100. *p = codec;
  101. codec->next = NULL;
  102. if (codec->init_static_data)
  103. codec->init_static_data(codec);
  104. }
  105. #if FF_API_EMU_EDGE
  106. unsigned avcodec_get_edge_width(void)
  107. {
  108. return EDGE_WIDTH;
  109. }
  110. #endif
  111. #if FF_API_SET_DIMENSIONS
  112. void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
  113. {
  114. ff_set_dimensions(s, width, height);
  115. }
  116. #endif
  117. int ff_set_dimensions(AVCodecContext *s, int width, int height)
  118. {
  119. int ret = av_image_check_size(width, height, 0, s);
  120. if (ret < 0)
  121. width = height = 0;
  122. s->width = s->coded_width = width;
  123. s->height = s->coded_height = height;
  124. return ret;
  125. }
  126. int ff_set_sar(AVCodecContext *avctx, AVRational sar)
  127. {
  128. int ret = av_image_check_sar(avctx->width, avctx->height, sar);
  129. if (ret < 0) {
  130. av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
  131. sar.num, sar.den);
  132. avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
  133. return ret;
  134. } else {
  135. avctx->sample_aspect_ratio = sar;
  136. }
  137. return 0;
  138. }
  139. int ff_side_data_update_matrix_encoding(AVFrame *frame,
  140. enum AVMatrixEncoding matrix_encoding)
  141. {
  142. AVFrameSideData *side_data;
  143. enum AVMatrixEncoding *data;
  144. side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
  145. if (!side_data)
  146. side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
  147. sizeof(enum AVMatrixEncoding));
  148. if (!side_data)
  149. return AVERROR(ENOMEM);
  150. data = (enum AVMatrixEncoding*)side_data->data;
  151. *data = matrix_encoding;
  152. return 0;
  153. }
  154. #if HAVE_SIMD_ALIGN_16
  155. # define STRIDE_ALIGN 16
  156. #else
  157. # define STRIDE_ALIGN 8
  158. #endif
  159. void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
  160. int linesize_align[AV_NUM_DATA_POINTERS])
  161. {
  162. int i;
  163. int w_align = 1;
  164. int h_align = 1;
  165. switch (s->pix_fmt) {
  166. case AV_PIX_FMT_YUV420P:
  167. case AV_PIX_FMT_YUYV422:
  168. case AV_PIX_FMT_YVYU422:
  169. case AV_PIX_FMT_UYVY422:
  170. case AV_PIX_FMT_YUV422P:
  171. case AV_PIX_FMT_YUV440P:
  172. case AV_PIX_FMT_YUV444P:
  173. case AV_PIX_FMT_GBRP:
  174. case AV_PIX_FMT_GBRAP:
  175. case AV_PIX_FMT_GRAY8:
  176. case AV_PIX_FMT_GRAY16BE:
  177. case AV_PIX_FMT_GRAY16LE:
  178. case AV_PIX_FMT_YUVJ420P:
  179. case AV_PIX_FMT_YUVJ422P:
  180. case AV_PIX_FMT_YUVJ440P:
  181. case AV_PIX_FMT_YUVJ444P:
  182. case AV_PIX_FMT_YUVA420P:
  183. case AV_PIX_FMT_YUVA422P:
  184. case AV_PIX_FMT_YUVA444P:
  185. case AV_PIX_FMT_YUV420P9LE:
  186. case AV_PIX_FMT_YUV420P9BE:
  187. case AV_PIX_FMT_YUV420P10LE:
  188. case AV_PIX_FMT_YUV420P10BE:
  189. case AV_PIX_FMT_YUV422P9LE:
  190. case AV_PIX_FMT_YUV422P9BE:
  191. case AV_PIX_FMT_YUV422P10LE:
  192. case AV_PIX_FMT_YUV422P10BE:
  193. case AV_PIX_FMT_YUVA422P10LE:
  194. case AV_PIX_FMT_YUVA422P10BE:
  195. case AV_PIX_FMT_YUV444P9LE:
  196. case AV_PIX_FMT_YUV444P9BE:
  197. case AV_PIX_FMT_YUV444P10LE:
  198. case AV_PIX_FMT_YUV444P10BE:
  199. case AV_PIX_FMT_YUVA444P10LE:
  200. case AV_PIX_FMT_YUVA444P10BE:
  201. case AV_PIX_FMT_GBRP9LE:
  202. case AV_PIX_FMT_GBRP9BE:
  203. case AV_PIX_FMT_GBRP10LE:
  204. case AV_PIX_FMT_GBRP10BE:
  205. w_align = 16; //FIXME assume 16 pixel per macroblock
  206. h_align = 16 * 2; // interlaced needs 2 macroblocks height
  207. break;
  208. case AV_PIX_FMT_YUV411P:
  209. case AV_PIX_FMT_UYYVYY411:
  210. w_align = 32;
  211. h_align = 8;
  212. break;
  213. case AV_PIX_FMT_YUV410P:
  214. if (s->codec_id == AV_CODEC_ID_SVQ1) {
  215. w_align = 64;
  216. h_align = 64;
  217. }
  218. case AV_PIX_FMT_RGB555:
  219. if (s->codec_id == AV_CODEC_ID_RPZA) {
  220. w_align = 4;
  221. h_align = 4;
  222. }
  223. case AV_PIX_FMT_PAL8:
  224. case AV_PIX_FMT_BGR8:
  225. case AV_PIX_FMT_RGB8:
  226. if (s->codec_id == AV_CODEC_ID_SMC) {
  227. w_align = 4;
  228. h_align = 4;
  229. }
  230. break;
  231. case AV_PIX_FMT_BGR24:
  232. if ((s->codec_id == AV_CODEC_ID_MSZH) ||
  233. (s->codec_id == AV_CODEC_ID_ZLIB)) {
  234. w_align = 4;
  235. h_align = 4;
  236. }
  237. break;
  238. default:
  239. w_align = 1;
  240. h_align = 1;
  241. break;
  242. }
  243. *width = FFALIGN(*width, w_align);
  244. *height = FFALIGN(*height, h_align);
  245. if (s->codec_id == AV_CODEC_ID_H264)
  246. // some of the optimized chroma MC reads one line too much
  247. *height += 2;
  248. for (i = 0; i < 4; i++)
  249. linesize_align[i] = STRIDE_ALIGN;
  250. }
  251. void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
  252. {
  253. const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
  254. int chroma_shift = desc->log2_chroma_w;
  255. int linesize_align[AV_NUM_DATA_POINTERS];
  256. int align;
  257. avcodec_align_dimensions2(s, width, height, linesize_align);
  258. align = FFMAX(linesize_align[0], linesize_align[3]);
  259. linesize_align[1] <<= chroma_shift;
  260. linesize_align[2] <<= chroma_shift;
  261. align = FFMAX3(align, linesize_align[1], linesize_align[2]);
  262. *width = FFALIGN(*width, align);
  263. }
  264. int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
  265. enum AVSampleFormat sample_fmt, const uint8_t *buf,
  266. int buf_size, int align)
  267. {
  268. int ch, planar, needed_size, ret = 0;
  269. needed_size = av_samples_get_buffer_size(NULL, nb_channels,
  270. frame->nb_samples, sample_fmt,
  271. align);
  272. if (buf_size < needed_size)
  273. return AVERROR(EINVAL);
  274. planar = av_sample_fmt_is_planar(sample_fmt);
  275. if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
  276. if (!(frame->extended_data = av_mallocz(nb_channels *
  277. sizeof(*frame->extended_data))))
  278. return AVERROR(ENOMEM);
  279. } else {
  280. frame->extended_data = frame->data;
  281. }
  282. if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
  283. buf, nb_channels, frame->nb_samples,
  284. sample_fmt, align)) < 0) {
  285. if (frame->extended_data != frame->data)
  286. av_free(frame->extended_data);
  287. return ret;
  288. }
  289. if (frame->extended_data != frame->data) {
  290. for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
  291. frame->data[ch] = frame->extended_data[ch];
  292. }
  293. return ret;
  294. }
  295. static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
  296. {
  297. FramePool *pool = avctx->internal->pool;
  298. int i, ret;
  299. switch (avctx->codec_type) {
  300. case AVMEDIA_TYPE_VIDEO: {
  301. AVPicture picture;
  302. int size[4] = { 0 };
  303. int w = frame->width;
  304. int h = frame->height;
  305. int tmpsize, unaligned;
  306. if (pool->format == frame->format &&
  307. pool->width == frame->width && pool->height == frame->height)
  308. return 0;
  309. avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
  310. do {
  311. // NOTE: do not align linesizes individually, this breaks e.g. assumptions
  312. // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
  313. av_image_fill_linesizes(picture.linesize, avctx->pix_fmt, w);
  314. // increase alignment of w for next try (rhs gives the lowest bit set in w)
  315. w += w & ~(w - 1);
  316. unaligned = 0;
  317. for (i = 0; i < 4; i++)
  318. unaligned |= picture.linesize[i] % pool->stride_align[i];
  319. } while (unaligned);
  320. tmpsize = av_image_fill_pointers(picture.data, avctx->pix_fmt, h,
  321. NULL, picture.linesize);
  322. if (tmpsize < 0)
  323. return -1;
  324. for (i = 0; i < 3 && picture.data[i + 1]; i++)
  325. size[i] = picture.data[i + 1] - picture.data[i];
  326. size[i] = tmpsize - (picture.data[i] - picture.data[0]);
  327. for (i = 0; i < 4; i++) {
  328. av_buffer_pool_uninit(&pool->pools[i]);
  329. pool->linesize[i] = picture.linesize[i];
  330. if (size[i]) {
  331. pool->pools[i] = av_buffer_pool_init(size[i] + 16, NULL);
  332. if (!pool->pools[i]) {
  333. ret = AVERROR(ENOMEM);
  334. goto fail;
  335. }
  336. }
  337. }
  338. pool->format = frame->format;
  339. pool->width = frame->width;
  340. pool->height = frame->height;
  341. break;
  342. }
  343. case AVMEDIA_TYPE_AUDIO: {
  344. int ch = av_get_channel_layout_nb_channels(frame->channel_layout);
  345. int planar = av_sample_fmt_is_planar(frame->format);
  346. int planes = planar ? ch : 1;
  347. if (pool->format == frame->format && pool->planes == planes &&
  348. pool->channels == ch && frame->nb_samples == pool->samples)
  349. return 0;
  350. av_buffer_pool_uninit(&pool->pools[0]);
  351. ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
  352. frame->nb_samples, frame->format, 0);
  353. if (ret < 0)
  354. goto fail;
  355. pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
  356. if (!pool->pools[0]) {
  357. ret = AVERROR(ENOMEM);
  358. goto fail;
  359. }
  360. pool->format = frame->format;
  361. pool->planes = planes;
  362. pool->channels = ch;
  363. pool->samples = frame->nb_samples;
  364. break;
  365. }
  366. default: av_assert0(0);
  367. }
  368. return 0;
  369. fail:
  370. for (i = 0; i < 4; i++)
  371. av_buffer_pool_uninit(&pool->pools[i]);
  372. pool->format = -1;
  373. pool->planes = pool->channels = pool->samples = 0;
  374. pool->width = pool->height = 0;
  375. return ret;
  376. }
  377. static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
  378. {
  379. FramePool *pool = avctx->internal->pool;
  380. int planes = pool->planes;
  381. int i;
  382. frame->linesize[0] = pool->linesize[0];
  383. if (planes > AV_NUM_DATA_POINTERS) {
  384. frame->extended_data = av_mallocz(planes * sizeof(*frame->extended_data));
  385. frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
  386. frame->extended_buf = av_mallocz(frame->nb_extended_buf *
  387. sizeof(*frame->extended_buf));
  388. if (!frame->extended_data || !frame->extended_buf) {
  389. av_freep(&frame->extended_data);
  390. av_freep(&frame->extended_buf);
  391. return AVERROR(ENOMEM);
  392. }
  393. } else
  394. frame->extended_data = frame->data;
  395. for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
  396. frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
  397. if (!frame->buf[i])
  398. goto fail;
  399. frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
  400. }
  401. for (i = 0; i < frame->nb_extended_buf; i++) {
  402. frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
  403. if (!frame->extended_buf[i])
  404. goto fail;
  405. frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
  406. }
  407. if (avctx->debug & FF_DEBUG_BUFFERS)
  408. av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
  409. return 0;
  410. fail:
  411. av_frame_unref(frame);
  412. return AVERROR(ENOMEM);
  413. }
  414. static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
  415. {
  416. FramePool *pool = s->internal->pool;
  417. int i;
  418. if (pic->data[0]) {
  419. av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
  420. return -1;
  421. }
  422. memset(pic->data, 0, sizeof(pic->data));
  423. pic->extended_data = pic->data;
  424. for (i = 0; i < 4 && pool->pools[i]; i++) {
  425. pic->linesize[i] = pool->linesize[i];
  426. pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
  427. if (!pic->buf[i])
  428. goto fail;
  429. pic->data[i] = pic->buf[i]->data;
  430. }
  431. for (; i < AV_NUM_DATA_POINTERS; i++) {
  432. pic->data[i] = NULL;
  433. pic->linesize[i] = 0;
  434. }
  435. if (pic->data[1] && !pic->data[2])
  436. avpriv_set_systematic_pal2((uint32_t *)pic->data[1], s->pix_fmt);
  437. if (s->debug & FF_DEBUG_BUFFERS)
  438. av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
  439. return 0;
  440. fail:
  441. av_frame_unref(pic);
  442. return AVERROR(ENOMEM);
  443. }
  444. int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
  445. {
  446. int ret;
  447. if ((ret = update_frame_pool(avctx, frame)) < 0)
  448. return ret;
  449. #if FF_API_GET_BUFFER
  450. FF_DISABLE_DEPRECATION_WARNINGS
  451. frame->type = FF_BUFFER_TYPE_INTERNAL;
  452. FF_ENABLE_DEPRECATION_WARNINGS
  453. #endif
  454. switch (avctx->codec_type) {
  455. case AVMEDIA_TYPE_VIDEO:
  456. return video_get_buffer(avctx, frame);
  457. case AVMEDIA_TYPE_AUDIO:
  458. return audio_get_buffer(avctx, frame);
  459. default:
  460. return -1;
  461. }
  462. }
  463. #if FF_API_GET_BUFFER
  464. FF_DISABLE_DEPRECATION_WARNINGS
  465. int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
  466. {
  467. return avcodec_default_get_buffer2(avctx, frame, 0);
  468. }
  469. typedef struct CompatReleaseBufPriv {
  470. AVCodecContext avctx;
  471. AVFrame frame;
  472. } CompatReleaseBufPriv;
  473. static void compat_free_buffer(void *opaque, uint8_t *data)
  474. {
  475. CompatReleaseBufPriv *priv = opaque;
  476. if (priv->avctx.release_buffer)
  477. priv->avctx.release_buffer(&priv->avctx, &priv->frame);
  478. av_freep(&priv);
  479. }
  480. static void compat_release_buffer(void *opaque, uint8_t *data)
  481. {
  482. AVBufferRef *buf = opaque;
  483. av_buffer_unref(&buf);
  484. }
  485. FF_ENABLE_DEPRECATION_WARNINGS
  486. #endif
  487. int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
  488. {
  489. AVPacket *pkt = avctx->internal->pkt;
  490. int i;
  491. struct {
  492. enum AVPacketSideDataType packet;
  493. enum AVFrameSideDataType frame;
  494. } sd[] = {
  495. { AV_PKT_DATA_REPLAYGAIN , AV_FRAME_DATA_REPLAYGAIN },
  496. { AV_PKT_DATA_DISPLAYMATRIX, AV_FRAME_DATA_DISPLAYMATRIX },
  497. { AV_PKT_DATA_STEREO3D, AV_FRAME_DATA_STEREO3D },
  498. { AV_PKT_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
  499. };
  500. frame->color_primaries = avctx->color_primaries;
  501. frame->color_trc = avctx->color_trc;
  502. frame->colorspace = avctx->colorspace;
  503. frame->color_range = avctx->color_range;
  504. frame->chroma_location = avctx->chroma_sample_location;
  505. frame->reordered_opaque = avctx->reordered_opaque;
  506. if (!pkt) {
  507. frame->pkt_pts = AV_NOPTS_VALUE;
  508. return 0;
  509. }
  510. frame->pkt_pts = pkt->pts;
  511. for (i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
  512. int size;
  513. uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
  514. if (packet_sd) {
  515. AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
  516. sd[i].frame,
  517. size);
  518. if (!frame_sd)
  519. return AVERROR(ENOMEM);
  520. memcpy(frame_sd->data, packet_sd, size);
  521. }
  522. }
  523. return 0;
  524. }
  525. int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
  526. {
  527. const AVHWAccel *hwaccel = avctx->hwaccel;
  528. int override_dimensions = 1;
  529. int ret;
  530. switch (avctx->codec_type) {
  531. case AVMEDIA_TYPE_VIDEO:
  532. if (frame->width <= 0 || frame->height <= 0) {
  533. frame->width = FFMAX(avctx->width, avctx->coded_width);
  534. frame->height = FFMAX(avctx->height, avctx->coded_height);
  535. override_dimensions = 0;
  536. }
  537. if (frame->format < 0)
  538. frame->format = avctx->pix_fmt;
  539. if (!frame->sample_aspect_ratio.num)
  540. frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
  541. if (av_image_check_sar(frame->width, frame->height,
  542. frame->sample_aspect_ratio) < 0) {
  543. av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
  544. frame->sample_aspect_ratio.num,
  545. frame->sample_aspect_ratio.den);
  546. frame->sample_aspect_ratio = (AVRational){ 0, 1 };
  547. }
  548. if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
  549. return ret;
  550. break;
  551. case AVMEDIA_TYPE_AUDIO:
  552. if (!frame->sample_rate)
  553. frame->sample_rate = avctx->sample_rate;
  554. if (frame->format < 0)
  555. frame->format = avctx->sample_fmt;
  556. if (!frame->channel_layout) {
  557. if (avctx->channel_layout) {
  558. if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
  559. avctx->channels) {
  560. av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
  561. "configuration.\n");
  562. return AVERROR(EINVAL);
  563. }
  564. frame->channel_layout = avctx->channel_layout;
  565. } else {
  566. if (avctx->channels > FF_SANE_NB_CHANNELS) {
  567. av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
  568. avctx->channels);
  569. return AVERROR(ENOSYS);
  570. }
  571. frame->channel_layout = av_get_default_channel_layout(avctx->channels);
  572. if (!frame->channel_layout)
  573. frame->channel_layout = (1ULL << avctx->channels) - 1;
  574. }
  575. }
  576. break;
  577. default: return AVERROR(EINVAL);
  578. }
  579. ret = ff_decode_frame_props(avctx, frame);
  580. if (ret < 0)
  581. return ret;
  582. if (hwaccel) {
  583. if (hwaccel->alloc_frame) {
  584. ret = hwaccel->alloc_frame(avctx, frame);
  585. goto end;
  586. }
  587. } else
  588. avctx->sw_pix_fmt = avctx->pix_fmt;
  589. #if FF_API_GET_BUFFER
  590. FF_DISABLE_DEPRECATION_WARNINGS
  591. /*
  592. * Wrap an old get_buffer()-allocated buffer in an bunch of AVBuffers.
  593. * We wrap each plane in its own AVBuffer. Each of those has a reference to
  594. * a dummy AVBuffer as its private data, unreffing it on free.
  595. * When all the planes are freed, the dummy buffer's free callback calls
  596. * release_buffer().
  597. */
  598. if (avctx->get_buffer) {
  599. CompatReleaseBufPriv *priv = NULL;
  600. AVBufferRef *dummy_buf = NULL;
  601. int planes, i, ret;
  602. if (flags & AV_GET_BUFFER_FLAG_REF)
  603. frame->reference = 1;
  604. ret = avctx->get_buffer(avctx, frame);
  605. if (ret < 0)
  606. return ret;
  607. /* return if the buffers are already set up
  608. * this would happen e.g. when a custom get_buffer() calls
  609. * avcodec_default_get_buffer
  610. */
  611. if (frame->buf[0])
  612. return 0;
  613. priv = av_mallocz(sizeof(*priv));
  614. if (!priv) {
  615. ret = AVERROR(ENOMEM);
  616. goto fail;
  617. }
  618. priv->avctx = *avctx;
  619. priv->frame = *frame;
  620. dummy_buf = av_buffer_create(NULL, 0, compat_free_buffer, priv, 0);
  621. if (!dummy_buf) {
  622. ret = AVERROR(ENOMEM);
  623. goto fail;
  624. }
  625. #define WRAP_PLANE(ref_out, data, data_size) \
  626. do { \
  627. AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf); \
  628. if (!dummy_ref) { \
  629. ret = AVERROR(ENOMEM); \
  630. goto fail; \
  631. } \
  632. ref_out = av_buffer_create(data, data_size, compat_release_buffer, \
  633. dummy_ref, 0); \
  634. if (!ref_out) { \
  635. av_frame_unref(frame); \
  636. ret = AVERROR(ENOMEM); \
  637. goto fail; \
  638. } \
  639. } while (0)
  640. if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
  641. const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
  642. planes = av_pix_fmt_count_planes(frame->format);
  643. /* workaround for AVHWAccel plane count of 0, buf[0] is used as
  644. check for allocated buffers: make libavcodec happy */
  645. if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
  646. planes = 1;
  647. if (!desc || planes <= 0) {
  648. ret = AVERROR(EINVAL);
  649. goto fail;
  650. }
  651. for (i = 0; i < planes; i++) {
  652. int v_shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
  653. int plane_size = (frame->height >> v_shift) * frame->linesize[i];
  654. WRAP_PLANE(frame->buf[i], frame->data[i], plane_size);
  655. }
  656. } else {
  657. int planar = av_sample_fmt_is_planar(frame->format);
  658. planes = planar ? avctx->channels : 1;
  659. if (planes > FF_ARRAY_ELEMS(frame->buf)) {
  660. frame->nb_extended_buf = planes - FF_ARRAY_ELEMS(frame->buf);
  661. frame->extended_buf = av_malloc(sizeof(*frame->extended_buf) *
  662. frame->nb_extended_buf);
  663. if (!frame->extended_buf) {
  664. ret = AVERROR(ENOMEM);
  665. goto fail;
  666. }
  667. }
  668. for (i = 0; i < FFMIN(planes, FF_ARRAY_ELEMS(frame->buf)); i++)
  669. WRAP_PLANE(frame->buf[i], frame->extended_data[i], frame->linesize[0]);
  670. for (i = 0; i < frame->nb_extended_buf; i++)
  671. WRAP_PLANE(frame->extended_buf[i],
  672. frame->extended_data[i + FF_ARRAY_ELEMS(frame->buf)],
  673. frame->linesize[0]);
  674. }
  675. av_buffer_unref(&dummy_buf);
  676. frame->width = avctx->width;
  677. frame->height = avctx->height;
  678. return 0;
  679. fail:
  680. avctx->release_buffer(avctx, frame);
  681. av_freep(&priv);
  682. av_buffer_unref(&dummy_buf);
  683. return ret;
  684. }
  685. FF_ENABLE_DEPRECATION_WARNINGS
  686. #endif
  687. ret = avctx->get_buffer2(avctx, frame, flags);
  688. end:
  689. if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions) {
  690. frame->width = avctx->width;
  691. frame->height = avctx->height;
  692. }
  693. return ret;
  694. }
  695. int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
  696. {
  697. AVFrame *tmp;
  698. int ret;
  699. av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
  700. if (!frame->data[0])
  701. return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
  702. if (av_frame_is_writable(frame))
  703. return ff_decode_frame_props(avctx, frame);
  704. tmp = av_frame_alloc();
  705. if (!tmp)
  706. return AVERROR(ENOMEM);
  707. av_frame_move_ref(tmp, frame);
  708. ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
  709. if (ret < 0) {
  710. av_frame_free(&tmp);
  711. return ret;
  712. }
  713. av_frame_copy(frame, tmp);
  714. av_frame_free(&tmp);
  715. return 0;
  716. }
  717. #if FF_API_GET_BUFFER
  718. void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
  719. {
  720. av_frame_unref(pic);
  721. }
  722. int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic)
  723. {
  724. av_assert0(0);
  725. return AVERROR_BUG;
  726. }
  727. #endif
  728. int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
  729. {
  730. int i;
  731. for (i = 0; i < count; i++) {
  732. int r = func(c, (char *)arg + i * size);
  733. if (ret)
  734. ret[i] = r;
  735. }
  736. return 0;
  737. }
  738. int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
  739. {
  740. int i;
  741. for (i = 0; i < count; i++) {
  742. int r = func(c, arg, i, 0);
  743. if (ret)
  744. ret[i] = r;
  745. }
  746. return 0;
  747. }
  748. static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
  749. {
  750. const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
  751. return desc->flags & AV_PIX_FMT_FLAG_HWACCEL;
  752. }
  753. enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
  754. {
  755. while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
  756. ++fmt;
  757. return fmt[0];
  758. }
  759. static AVHWAccel *find_hwaccel(enum AVCodecID codec_id,
  760. enum AVPixelFormat pix_fmt)
  761. {
  762. AVHWAccel *hwaccel = NULL;
  763. while ((hwaccel = av_hwaccel_next(hwaccel)))
  764. if (hwaccel->id == codec_id
  765. && hwaccel->pix_fmt == pix_fmt)
  766. return hwaccel;
  767. return NULL;
  768. }
  769. static int setup_hwaccel(AVCodecContext *avctx,
  770. const enum AVPixelFormat fmt,
  771. const char *name)
  772. {
  773. AVHWAccel *hwa = find_hwaccel(avctx->codec_id, fmt);
  774. int ret = 0;
  775. if (!hwa) {
  776. av_log(avctx, AV_LOG_ERROR,
  777. "Could not find an AVHWAccel for the pixel format: %s",
  778. name);
  779. return AVERROR(ENOENT);
  780. }
  781. if (hwa->priv_data_size) {
  782. avctx->internal->hwaccel_priv_data = av_mallocz(hwa->priv_data_size);
  783. if (!avctx->internal->hwaccel_priv_data)
  784. return AVERROR(ENOMEM);
  785. }
  786. if (hwa->init) {
  787. ret = hwa->init(avctx);
  788. if (ret < 0) {
  789. av_freep(&avctx->internal->hwaccel_priv_data);
  790. return ret;
  791. }
  792. }
  793. avctx->hwaccel = hwa;
  794. return 0;
  795. }
  796. int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
  797. {
  798. const AVPixFmtDescriptor *desc;
  799. enum AVPixelFormat *choices;
  800. enum AVPixelFormat ret;
  801. unsigned n = 0;
  802. while (fmt[n] != AV_PIX_FMT_NONE)
  803. ++n;
  804. av_assert0(n >= 1);
  805. avctx->sw_pix_fmt = fmt[n - 1];
  806. av_assert2(!is_hwaccel_pix_fmt(avctx->sw_pix_fmt));
  807. choices = av_malloc_array(n + 1, sizeof(*choices));
  808. if (!choices)
  809. return AV_PIX_FMT_NONE;
  810. memcpy(choices, fmt, (n + 1) * sizeof(*choices));
  811. for (;;) {
  812. if (avctx->hwaccel && avctx->hwaccel->uninit)
  813. avctx->hwaccel->uninit(avctx);
  814. av_freep(&avctx->internal->hwaccel_priv_data);
  815. avctx->hwaccel = NULL;
  816. ret = avctx->get_format(avctx, choices);
  817. desc = av_pix_fmt_desc_get(ret);
  818. if (!desc) {
  819. ret = AV_PIX_FMT_NONE;
  820. break;
  821. }
  822. if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
  823. break;
  824. if (!setup_hwaccel(avctx, ret, desc->name))
  825. break;
  826. /* Remove failed hwaccel from choices */
  827. for (n = 0; choices[n] != ret; n++)
  828. av_assert0(choices[n] != AV_PIX_FMT_NONE);
  829. do
  830. choices[n] = choices[n + 1];
  831. while (choices[n++] != AV_PIX_FMT_NONE);
  832. }
  833. av_freep(&choices);
  834. return ret;
  835. }
  836. #if FF_API_AVFRAME_LAVC
  837. void avcodec_get_frame_defaults(AVFrame *frame)
  838. {
  839. if (frame->extended_data != frame->data)
  840. av_freep(&frame->extended_data);
  841. memset(frame, 0, sizeof(AVFrame));
  842. frame->pts = AV_NOPTS_VALUE;
  843. frame->key_frame = 1;
  844. frame->sample_aspect_ratio = (AVRational) {0, 1 };
  845. frame->format = -1; /* unknown */
  846. frame->extended_data = frame->data;
  847. }
  848. AVFrame *avcodec_alloc_frame(void)
  849. {
  850. AVFrame *frame = av_mallocz(sizeof(AVFrame));
  851. if (!frame)
  852. return NULL;
  853. FF_DISABLE_DEPRECATION_WARNINGS
  854. avcodec_get_frame_defaults(frame);
  855. FF_ENABLE_DEPRECATION_WARNINGS
  856. return frame;
  857. }
  858. void avcodec_free_frame(AVFrame **frame)
  859. {
  860. av_frame_free(frame);
  861. }
  862. #endif
  863. int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
  864. {
  865. int ret = 0;
  866. AVDictionary *tmp = NULL;
  867. if (avcodec_is_open(avctx))
  868. return 0;
  869. if ((!codec && !avctx->codec)) {
  870. av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
  871. return AVERROR(EINVAL);
  872. }
  873. if ((codec && avctx->codec && codec != avctx->codec)) {
  874. av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
  875. "but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
  876. return AVERROR(EINVAL);
  877. }
  878. if (!codec)
  879. codec = avctx->codec;
  880. if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
  881. return AVERROR(EINVAL);
  882. if (options)
  883. av_dict_copy(&tmp, *options, 0);
  884. /* If there is a user-supplied mutex locking routine, call it. */
  885. if (lockmgr_cb) {
  886. if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
  887. return -1;
  888. }
  889. entangled_thread_counter++;
  890. if (entangled_thread_counter != 1 &&
  891. !(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE)) {
  892. av_log(avctx, AV_LOG_ERROR,
  893. "Insufficient thread locking. At least %d threads are "
  894. "calling avcodec_open2() at the same time right now.\n",
  895. entangled_thread_counter);
  896. ret = -1;
  897. goto end;
  898. }
  899. avctx->internal = av_mallocz(sizeof(AVCodecInternal));
  900. if (!avctx->internal) {
  901. ret = AVERROR(ENOMEM);
  902. goto end;
  903. }
  904. avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
  905. if (!avctx->internal->pool) {
  906. ret = AVERROR(ENOMEM);
  907. goto free_and_end;
  908. }
  909. avctx->internal->to_free = av_frame_alloc();
  910. if (!avctx->internal->to_free) {
  911. ret = AVERROR(ENOMEM);
  912. goto free_and_end;
  913. }
  914. if (codec->priv_data_size > 0) {
  915. if (!avctx->priv_data) {
  916. avctx->priv_data = av_mallocz(codec->priv_data_size);
  917. if (!avctx->priv_data) {
  918. ret = AVERROR(ENOMEM);
  919. goto end;
  920. }
  921. if (codec->priv_class) {
  922. *(const AVClass **)avctx->priv_data = codec->priv_class;
  923. av_opt_set_defaults(avctx->priv_data);
  924. }
  925. }
  926. if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
  927. goto free_and_end;
  928. } else {
  929. avctx->priv_data = NULL;
  930. }
  931. if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
  932. goto free_and_end;
  933. if (avctx->coded_width && avctx->coded_height && !avctx->width && !avctx->height)
  934. ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
  935. else if (avctx->width && avctx->height)
  936. ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
  937. if (ret < 0)
  938. goto free_and_end;
  939. if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
  940. && ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
  941. || av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {
  942. av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
  943. ff_set_dimensions(avctx, 0, 0);
  944. }
  945. if (avctx->width > 0 && avctx->height > 0) {
  946. if (av_image_check_sar(avctx->width, avctx->height,
  947. avctx->sample_aspect_ratio) < 0) {
  948. av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
  949. avctx->sample_aspect_ratio.num,
  950. avctx->sample_aspect_ratio.den);
  951. avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
  952. }
  953. }
  954. /* if the decoder init function was already called previously,
  955. * free the already allocated subtitle_header before overwriting it */
  956. if (av_codec_is_decoder(codec))
  957. av_freep(&avctx->subtitle_header);
  958. if (avctx->channels > FF_SANE_NB_CHANNELS) {
  959. ret = AVERROR(EINVAL);
  960. goto free_and_end;
  961. }
  962. avctx->codec = codec;
  963. if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
  964. avctx->codec_id == AV_CODEC_ID_NONE) {
  965. avctx->codec_type = codec->type;
  966. avctx->codec_id = codec->id;
  967. }
  968. if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
  969. && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
  970. av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
  971. ret = AVERROR(EINVAL);
  972. goto free_and_end;
  973. }
  974. avctx->frame_number = 0;
  975. if (avctx->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
  976. avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
  977. ret = AVERROR_EXPERIMENTAL;
  978. goto free_and_end;
  979. }
  980. if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
  981. (!avctx->time_base.num || !avctx->time_base.den)) {
  982. avctx->time_base.num = 1;
  983. avctx->time_base.den = avctx->sample_rate;
  984. }
  985. if (HAVE_THREADS) {
  986. ret = ff_thread_init(avctx);
  987. if (ret < 0) {
  988. goto free_and_end;
  989. }
  990. }
  991. if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
  992. avctx->thread_count = 1;
  993. if (av_codec_is_encoder(avctx->codec)) {
  994. int i;
  995. if (avctx->codec->sample_fmts) {
  996. for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
  997. if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
  998. break;
  999. if (avctx->channels == 1 &&
  1000. av_get_planar_sample_fmt(avctx->sample_fmt) ==
  1001. av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
  1002. avctx->sample_fmt = avctx->codec->sample_fmts[i];
  1003. break;
  1004. }
  1005. }
  1006. if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
  1007. av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
  1008. ret = AVERROR(EINVAL);
  1009. goto free_and_end;
  1010. }
  1011. }
  1012. if (avctx->codec->pix_fmts) {
  1013. for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
  1014. if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
  1015. break;
  1016. if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE) {
  1017. av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
  1018. ret = AVERROR(EINVAL);
  1019. goto free_and_end;
  1020. }
  1021. if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
  1022. avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
  1023. avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
  1024. avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
  1025. avctx->color_range = AVCOL_RANGE_JPEG;
  1026. }
  1027. if (avctx->codec->supported_samplerates) {
  1028. for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
  1029. if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
  1030. break;
  1031. if (avctx->codec->supported_samplerates[i] == 0) {
  1032. av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
  1033. ret = AVERROR(EINVAL);
  1034. goto free_and_end;
  1035. }
  1036. }
  1037. if (avctx->codec->channel_layouts) {
  1038. if (!avctx->channel_layout) {
  1039. av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
  1040. } else {
  1041. for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
  1042. if (avctx->channel_layout == avctx->codec->channel_layouts[i])
  1043. break;
  1044. if (avctx->codec->channel_layouts[i] == 0) {
  1045. av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
  1046. ret = AVERROR(EINVAL);
  1047. goto free_and_end;
  1048. }
  1049. }
  1050. }
  1051. if (avctx->channel_layout && avctx->channels) {
  1052. if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
  1053. av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
  1054. ret = AVERROR(EINVAL);
  1055. goto free_and_end;
  1056. }
  1057. } else if (avctx->channel_layout) {
  1058. avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
  1059. }
  1060. if (!avctx->rc_initial_buffer_occupancy)
  1061. avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;
  1062. }
  1063. if (avctx->codec->init && !(avctx->active_thread_type & FF_THREAD_FRAME)) {
  1064. ret = avctx->codec->init(avctx);
  1065. if (ret < 0) {
  1066. goto free_and_end;
  1067. }
  1068. }
  1069. #if FF_API_AUDIOENC_DELAY
  1070. if (av_codec_is_encoder(avctx->codec))
  1071. avctx->delay = avctx->initial_padding;
  1072. #endif
  1073. if (av_codec_is_decoder(avctx->codec)) {
  1074. /* validate channel layout from the decoder */
  1075. if (avctx->channel_layout) {
  1076. int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
  1077. if (!avctx->channels)
  1078. avctx->channels = channels;
  1079. else if (channels != avctx->channels) {
  1080. av_log(avctx, AV_LOG_WARNING,
  1081. "channel layout does not match number of channels\n");
  1082. avctx->channel_layout = 0;
  1083. }
  1084. }
  1085. if (avctx->channels && avctx->channels < 0 ||
  1086. avctx->channels > FF_SANE_NB_CHANNELS) {
  1087. ret = AVERROR(EINVAL);
  1088. goto free_and_end;
  1089. }
  1090. #if FF_API_AVCTX_TIMEBASE
  1091. if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
  1092. avctx->time_base = av_inv_q(avctx->framerate);
  1093. #endif
  1094. }
  1095. end:
  1096. entangled_thread_counter--;
  1097. /* Release any user-supplied mutex. */
  1098. if (lockmgr_cb) {
  1099. (*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
  1100. }
  1101. if (options) {
  1102. av_dict_free(options);
  1103. *options = tmp;
  1104. }
  1105. return ret;
  1106. free_and_end:
  1107. if (avctx->codec &&
  1108. (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))
  1109. avctx->codec->close(avctx);
  1110. av_dict_free(&tmp);
  1111. av_freep(&avctx->priv_data);
  1112. if (avctx->internal) {
  1113. av_frame_free(&avctx->internal->to_free);
  1114. av_freep(&avctx->internal->pool);
  1115. }
  1116. av_freep(&avctx->internal);
  1117. avctx->codec = NULL;
  1118. goto end;
  1119. }
  1120. int ff_alloc_packet(AVPacket *avpkt, int size)
  1121. {
  1122. if (size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
  1123. return AVERROR(EINVAL);
  1124. if (avpkt->data) {
  1125. AVBufferRef *buf = avpkt->buf;
  1126. #if FF_API_DESTRUCT_PACKET
  1127. FF_DISABLE_DEPRECATION_WARNINGS
  1128. void *destruct = avpkt->destruct;
  1129. FF_ENABLE_DEPRECATION_WARNINGS
  1130. #endif
  1131. if (avpkt->size < size)
  1132. return AVERROR(EINVAL);
  1133. av_init_packet(avpkt);
  1134. #if FF_API_DESTRUCT_PACKET
  1135. FF_DISABLE_DEPRECATION_WARNINGS
  1136. avpkt->destruct = destruct;
  1137. FF_ENABLE_DEPRECATION_WARNINGS
  1138. #endif
  1139. avpkt->buf = buf;
  1140. avpkt->size = size;
  1141. return 0;
  1142. } else {
  1143. return av_new_packet(avpkt, size);
  1144. }
  1145. }
  1146. /**
  1147. * Pad last frame with silence.
  1148. */
  1149. static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
  1150. {
  1151. AVFrame *frame = NULL;
  1152. int ret;
  1153. if (!(frame = av_frame_alloc()))
  1154. return AVERROR(ENOMEM);
  1155. frame->format = src->format;
  1156. frame->channel_layout = src->channel_layout;
  1157. frame->nb_samples = s->frame_size;
  1158. ret = av_frame_get_buffer(frame, 32);
  1159. if (ret < 0)
  1160. goto fail;
  1161. ret = av_frame_copy_props(frame, src);
  1162. if (ret < 0)
  1163. goto fail;
  1164. if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
  1165. src->nb_samples, s->channels, s->sample_fmt)) < 0)
  1166. goto fail;
  1167. if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
  1168. frame->nb_samples - src->nb_samples,
  1169. s->channels, s->sample_fmt)) < 0)
  1170. goto fail;
  1171. *dst = frame;
  1172. return 0;
  1173. fail:
  1174. av_frame_free(&frame);
  1175. return ret;
  1176. }
  1177. int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
  1178. AVPacket *avpkt,
  1179. const AVFrame *frame,
  1180. int *got_packet_ptr)
  1181. {
  1182. AVFrame tmp;
  1183. AVFrame *padded_frame = NULL;
  1184. int ret;
  1185. int user_packet = !!avpkt->data;
  1186. *got_packet_ptr = 0;
  1187. if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
  1188. av_free_packet(avpkt);
  1189. av_init_packet(avpkt);
  1190. return 0;
  1191. }
  1192. /* ensure that extended_data is properly set */
  1193. if (frame && !frame->extended_data) {
  1194. if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
  1195. avctx->channels > AV_NUM_DATA_POINTERS) {
  1196. av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
  1197. "with more than %d channels, but extended_data is not set.\n",
  1198. AV_NUM_DATA_POINTERS);
  1199. return AVERROR(EINVAL);
  1200. }
  1201. av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
  1202. tmp = *frame;
  1203. tmp.extended_data = tmp.data;
  1204. frame = &tmp;
  1205. }
  1206. /* extract audio service type metadata */
  1207. if (frame) {
  1208. AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
  1209. if (sd && sd->size >= sizeof(enum AVAudioServiceType))
  1210. avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
  1211. }
  1212. /* check for valid frame size */
  1213. if (frame) {
  1214. if (avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
  1215. if (frame->nb_samples > avctx->frame_size)
  1216. return AVERROR(EINVAL);
  1217. } else if (!(avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
  1218. if (frame->nb_samples < avctx->frame_size &&
  1219. !avctx->internal->last_audio_frame) {
  1220. ret = pad_last_frame(avctx, &padded_frame, frame);
  1221. if (ret < 0)
  1222. return ret;
  1223. frame = padded_frame;
  1224. avctx->internal->last_audio_frame = 1;
  1225. }
  1226. if (frame->nb_samples != avctx->frame_size) {
  1227. ret = AVERROR(EINVAL);
  1228. goto end;
  1229. }
  1230. }
  1231. }
  1232. ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
  1233. if (!ret) {
  1234. if (*got_packet_ptr) {
  1235. if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {
  1236. if (avpkt->pts == AV_NOPTS_VALUE)
  1237. avpkt->pts = frame->pts;
  1238. if (!avpkt->duration)
  1239. avpkt->duration = ff_samples_to_time_base(avctx,
  1240. frame->nb_samples);
  1241. }
  1242. avpkt->dts = avpkt->pts;
  1243. } else {
  1244. avpkt->size = 0;
  1245. }
  1246. if (!user_packet && avpkt->size) {
  1247. ret = av_buffer_realloc(&avpkt->buf, avpkt->size);
  1248. if (ret >= 0)
  1249. avpkt->data = avpkt->buf->data;
  1250. }
  1251. avctx->frame_number++;
  1252. }
  1253. if (ret < 0 || !*got_packet_ptr) {
  1254. av_free_packet(avpkt);
  1255. av_init_packet(avpkt);
  1256. goto end;
  1257. }
  1258. /* NOTE: if we add any audio encoders which output non-keyframe packets,
  1259. * this needs to be moved to the encoders, but for now we can do it
  1260. * here to simplify things */
  1261. avpkt->flags |= AV_PKT_FLAG_KEY;
  1262. end:
  1263. av_frame_free(&padded_frame);
  1264. #if FF_API_AUDIOENC_DELAY
  1265. avctx->delay = avctx->initial_padding;
  1266. #endif
  1267. return ret;
  1268. }
  1269. int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
  1270. AVPacket *avpkt,
  1271. const AVFrame *frame,
  1272. int *got_packet_ptr)
  1273. {
  1274. int ret;
  1275. int user_packet = !!avpkt->data;
  1276. *got_packet_ptr = 0;
  1277. if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
  1278. av_free_packet(avpkt);
  1279. av_init_packet(avpkt);
  1280. avpkt->size = 0;
  1281. return 0;
  1282. }
  1283. if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
  1284. return AVERROR(EINVAL);
  1285. av_assert0(avctx->codec->encode2);
  1286. ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
  1287. if (!ret) {
  1288. if (!*got_packet_ptr)
  1289. avpkt->size = 0;
  1290. else if (!(avctx->codec->capabilities & CODEC_CAP_DELAY))
  1291. avpkt->pts = avpkt->dts = frame->pts;
  1292. if (!user_packet && avpkt->size) {
  1293. ret = av_buffer_realloc(&avpkt->buf, avpkt->size);
  1294. if (ret >= 0)
  1295. avpkt->data = avpkt->buf->data;
  1296. }
  1297. avctx->frame_number++;
  1298. }
  1299. if (ret < 0 || !*got_packet_ptr)
  1300. av_free_packet(avpkt);
  1301. emms_c();
  1302. return ret;
  1303. }
  1304. int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
  1305. const AVSubtitle *sub)
  1306. {
  1307. int ret;
  1308. if (sub->start_display_time) {
  1309. av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
  1310. return -1;
  1311. }
  1312. if (sub->num_rects == 0 || !sub->rects)
  1313. return -1;
  1314. ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
  1315. avctx->frame_number++;
  1316. return ret;
  1317. }
  1318. static int apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
  1319. {
  1320. int size = 0, ret;
  1321. const uint8_t *data;
  1322. uint32_t flags;
  1323. data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
  1324. if (!data)
  1325. return 0;
  1326. if (!(avctx->codec->capabilities & CODEC_CAP_PARAM_CHANGE)) {
  1327. av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
  1328. "changes, but PARAM_CHANGE side data was sent to it.\n");
  1329. return AVERROR(EINVAL);
  1330. }
  1331. if (size < 4)
  1332. goto fail;
  1333. flags = bytestream_get_le32(&data);
  1334. size -= 4;
  1335. if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
  1336. if (size < 4)
  1337. goto fail;
  1338. avctx->channels = bytestream_get_le32(&data);
  1339. size -= 4;
  1340. }
  1341. if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
  1342. if (size < 8)
  1343. goto fail;
  1344. avctx->channel_layout = bytestream_get_le64(&data);
  1345. size -= 8;
  1346. }
  1347. if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
  1348. if (size < 4)
  1349. goto fail;
  1350. avctx->sample_rate = bytestream_get_le32(&data);
  1351. size -= 4;
  1352. }
  1353. if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
  1354. if (size < 8)
  1355. goto fail;
  1356. avctx->width = bytestream_get_le32(&data);
  1357. avctx->height = bytestream_get_le32(&data);
  1358. size -= 8;
  1359. ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
  1360. if (ret < 0)
  1361. return ret;
  1362. }
  1363. return 0;
  1364. fail:
  1365. av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
  1366. return AVERROR_INVALIDDATA;
  1367. }
  1368. static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
  1369. {
  1370. int ret;
  1371. /* move the original frame to our backup */
  1372. av_frame_unref(avci->to_free);
  1373. av_frame_move_ref(avci->to_free, frame);
  1374. /* now copy everything except the AVBufferRefs back
  1375. * note that we make a COPY of the side data, so calling av_frame_free() on
  1376. * the caller's frame will work properly */
  1377. ret = av_frame_copy_props(frame, avci->to_free);
  1378. if (ret < 0)
  1379. return ret;
  1380. memcpy(frame->data, avci->to_free->data, sizeof(frame->data));
  1381. memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
  1382. if (avci->to_free->extended_data != avci->to_free->data) {
  1383. int planes = av_get_channel_layout_nb_channels(avci->to_free->channel_layout);
  1384. int size = planes * sizeof(*frame->extended_data);
  1385. if (!size) {
  1386. av_frame_unref(frame);
  1387. return AVERROR_BUG;
  1388. }
  1389. frame->extended_data = av_malloc(size);
  1390. if (!frame->extended_data) {
  1391. av_frame_unref(frame);
  1392. return AVERROR(ENOMEM);
  1393. }
  1394. memcpy(frame->extended_data, avci->to_free->extended_data,
  1395. size);
  1396. } else
  1397. frame->extended_data = frame->data;
  1398. frame->format = avci->to_free->format;
  1399. frame->width = avci->to_free->width;
  1400. frame->height = avci->to_free->height;
  1401. frame->channel_layout = avci->to_free->channel_layout;
  1402. frame->nb_samples = avci->to_free->nb_samples;
  1403. return 0;
  1404. }
  1405. int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
  1406. int *got_picture_ptr,
  1407. AVPacket *avpkt)
  1408. {
  1409. AVCodecInternal *avci = avctx->internal;
  1410. int ret;
  1411. *got_picture_ptr = 0;
  1412. if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
  1413. return -1;
  1414. avctx->internal->pkt = avpkt;
  1415. ret = apply_param_change(avctx, avpkt);
  1416. if (ret < 0) {
  1417. av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
  1418. if (avctx->err_recognition & AV_EF_EXPLODE)
  1419. return ret;
  1420. }
  1421. av_frame_unref(picture);
  1422. if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
  1423. if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
  1424. ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
  1425. avpkt);
  1426. else {
  1427. ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
  1428. avpkt);
  1429. picture->pkt_dts = avpkt->dts;
  1430. /* get_buffer is supposed to set frame parameters */
  1431. if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {
  1432. picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
  1433. picture->width = avctx->width;
  1434. picture->height = avctx->height;
  1435. picture->format = avctx->pix_fmt;
  1436. }
  1437. }
  1438. emms_c(); //needed to avoid an emms_c() call before every return;
  1439. if (*got_picture_ptr) {
  1440. if (!avctx->refcounted_frames) {
  1441. int err = unrefcount_frame(avci, picture);
  1442. if (err < 0)
  1443. return err;
  1444. }
  1445. avctx->frame_number++;
  1446. } else
  1447. av_frame_unref(picture);
  1448. } else
  1449. ret = 0;
  1450. #if FF_API_AVCTX_TIMEBASE
  1451. if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
  1452. avctx->time_base = av_inv_q(avctx->framerate);
  1453. #endif
  1454. return ret;
  1455. }
  1456. int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
  1457. AVFrame *frame,
  1458. int *got_frame_ptr,
  1459. AVPacket *avpkt)
  1460. {
  1461. AVCodecInternal *avci = avctx->internal;
  1462. int ret = 0;
  1463. *got_frame_ptr = 0;
  1464. avctx->internal->pkt = avpkt;
  1465. if (!avpkt->data && avpkt->size) {
  1466. av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
  1467. return AVERROR(EINVAL);
  1468. }
  1469. ret = apply_param_change(avctx, avpkt);
  1470. if (ret < 0) {
  1471. av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
  1472. if (avctx->err_recognition & AV_EF_EXPLODE)
  1473. return ret;
  1474. }
  1475. av_frame_unref(frame);
  1476. if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size) {
  1477. ret = avctx->codec->decode(avctx, frame, got_frame_ptr, avpkt);
  1478. if (ret >= 0 && *got_frame_ptr) {
  1479. avctx->frame_number++;
  1480. frame->pkt_dts = avpkt->dts;
  1481. if (frame->format == AV_SAMPLE_FMT_NONE)
  1482. frame->format = avctx->sample_fmt;
  1483. if (!avctx->refcounted_frames) {
  1484. int err = unrefcount_frame(avci, frame);
  1485. if (err < 0)
  1486. return err;
  1487. }
  1488. } else
  1489. av_frame_unref(frame);
  1490. }
  1491. return ret;
  1492. }
  1493. int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
  1494. int *got_sub_ptr,
  1495. AVPacket *avpkt)
  1496. {
  1497. int ret;
  1498. avctx->internal->pkt = avpkt;
  1499. *got_sub_ptr = 0;
  1500. ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
  1501. if (*got_sub_ptr)
  1502. avctx->frame_number++;
  1503. return ret;
  1504. }
  1505. void avsubtitle_free(AVSubtitle *sub)
  1506. {
  1507. int i;
  1508. for (i = 0; i < sub->num_rects; i++) {
  1509. av_freep(&sub->rects[i]->pict.data[0]);
  1510. av_freep(&sub->rects[i]->pict.data[1]);
  1511. av_freep(&sub->rects[i]->pict.data[2]);
  1512. av_freep(&sub->rects[i]->pict.data[3]);
  1513. av_freep(&sub->rects[i]->text);
  1514. av_freep(&sub->rects[i]->ass);
  1515. av_freep(&sub->rects[i]);
  1516. }
  1517. av_freep(&sub->rects);
  1518. memset(sub, 0, sizeof(AVSubtitle));
  1519. }
  1520. av_cold int avcodec_close(AVCodecContext *avctx)
  1521. {
  1522. if (avcodec_is_open(avctx)) {
  1523. FramePool *pool = avctx->internal->pool;
  1524. int i;
  1525. if (HAVE_THREADS && avctx->internal->thread_ctx)
  1526. ff_thread_free(avctx);
  1527. if (avctx->codec && avctx->codec->close)
  1528. avctx->codec->close(avctx);
  1529. avctx->coded_frame = NULL;
  1530. av_frame_free(&avctx->internal->to_free);
  1531. for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
  1532. av_buffer_pool_uninit(&pool->pools[i]);
  1533. av_freep(&avctx->internal->pool);
  1534. if (avctx->hwaccel && avctx->hwaccel->uninit)
  1535. avctx->hwaccel->uninit(avctx);
  1536. av_freep(&avctx->internal->hwaccel_priv_data);
  1537. av_freep(&avctx->internal);
  1538. }
  1539. if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
  1540. av_opt_free(avctx->priv_data);
  1541. av_opt_free(avctx);
  1542. av_freep(&avctx->priv_data);
  1543. if (av_codec_is_encoder(avctx->codec))
  1544. av_freep(&avctx->extradata);
  1545. avctx->codec = NULL;
  1546. avctx->active_thread_type = 0;
  1547. return 0;
  1548. }
  1549. static AVCodec *find_encdec(enum AVCodecID id, int encoder)
  1550. {
  1551. AVCodec *p, *experimental = NULL;
  1552. p = first_avcodec;
  1553. while (p) {
  1554. if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
  1555. p->id == id) {
  1556. if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
  1557. experimental = p;
  1558. } else
  1559. return p;
  1560. }
  1561. p = p->next;
  1562. }
  1563. return experimental;
  1564. }
  1565. AVCodec *avcodec_find_encoder(enum AVCodecID id)
  1566. {
  1567. return find_encdec(id, 1);
  1568. }
  1569. AVCodec *avcodec_find_encoder_by_name(const char *name)
  1570. {
  1571. AVCodec *p;
  1572. if (!name)
  1573. return NULL;
  1574. p = first_avcodec;
  1575. while (p) {
  1576. if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
  1577. return p;
  1578. p = p->next;
  1579. }
  1580. return NULL;
  1581. }
  1582. AVCodec *avcodec_find_decoder(enum AVCodecID id)
  1583. {
  1584. return find_encdec(id, 0);
  1585. }
  1586. AVCodec *avcodec_find_decoder_by_name(const char *name)
  1587. {
  1588. AVCodec *p;
  1589. if (!name)
  1590. return NULL;
  1591. p = first_avcodec;
  1592. while (p) {
  1593. if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
  1594. return p;
  1595. p = p->next;
  1596. }
  1597. return NULL;
  1598. }
  1599. static int get_bit_rate(AVCodecContext *ctx)
  1600. {
  1601. int bit_rate;
  1602. int bits_per_sample;
  1603. switch (ctx->codec_type) {
  1604. case AVMEDIA_TYPE_VIDEO:
  1605. case AVMEDIA_TYPE_DATA:
  1606. case AVMEDIA_TYPE_SUBTITLE:
  1607. case AVMEDIA_TYPE_ATTACHMENT:
  1608. bit_rate = ctx->bit_rate;
  1609. break;
  1610. case AVMEDIA_TYPE_AUDIO:
  1611. bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
  1612. bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
  1613. break;
  1614. default:
  1615. bit_rate = 0;
  1616. break;
  1617. }
  1618. return bit_rate;
  1619. }
  1620. size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
  1621. {
  1622. int i, len, ret = 0;
  1623. #define TAG_PRINT(x) \
  1624. (((x) >= '0' && (x) <= '9') || \
  1625. ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
  1626. ((x) == '.' || (x) == ' '))
  1627. for (i = 0; i < 4; i++) {
  1628. len = snprintf(buf, buf_size,
  1629. TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
  1630. buf += len;
  1631. buf_size = buf_size > len ? buf_size - len : 0;
  1632. ret += len;
  1633. codec_tag >>= 8;
  1634. }
  1635. return ret;
  1636. }
  1637. void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
  1638. {
  1639. const char *codec_name;
  1640. const char *profile = NULL;
  1641. const AVCodec *p;
  1642. char buf1[32];
  1643. int bitrate;
  1644. int new_line = 0;
  1645. AVRational display_aspect_ratio;
  1646. if (enc->codec)
  1647. p = enc->codec;
  1648. else if (encode)
  1649. p = avcodec_find_encoder(enc->codec_id);
  1650. else
  1651. p = avcodec_find_decoder(enc->codec_id);
  1652. if (p) {
  1653. codec_name = p->name;
  1654. profile = av_get_profile_name(p, enc->profile);
  1655. } else if (enc->codec_id == AV_CODEC_ID_MPEG2TS) {
  1656. /* fake mpeg2 transport stream codec (currently not
  1657. * registered) */
  1658. codec_name = "mpeg2ts";
  1659. } else {
  1660. /* output avi tags */
  1661. char tag_buf[32];
  1662. av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
  1663. snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
  1664. codec_name = buf1;
  1665. }
  1666. switch (enc->codec_type) {
  1667. case AVMEDIA_TYPE_VIDEO:
  1668. snprintf(buf, buf_size,
  1669. "Video: %s%s",
  1670. codec_name, enc->mb_decision ? " (hq)" : "");
  1671. if (profile)
  1672. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1673. " (%s)", profile);
  1674. if (enc->codec_tag) {
  1675. char tag_buf[32];
  1676. av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
  1677. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1678. " [%s / 0x%04X]", tag_buf, enc->codec_tag);
  1679. }
  1680. av_strlcat(buf, "\n ", buf_size);
  1681. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1682. "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
  1683. av_get_pix_fmt_name(enc->pix_fmt));
  1684. if (enc->color_range != AVCOL_RANGE_UNSPECIFIED)
  1685. snprintf(buf + strlen(buf), buf_size - strlen(buf), ", %s",
  1686. av_color_range_name(enc->color_range));
  1687. if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
  1688. enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
  1689. enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
  1690. new_line = 1;
  1691. snprintf(buf + strlen(buf), buf_size - strlen(buf), ", %s/%s/%s",
  1692. av_color_space_name(enc->colorspace),
  1693. av_color_primaries_name(enc->color_primaries),
  1694. av_color_transfer_name(enc->color_trc));
  1695. }
  1696. if (av_log_get_level() >= AV_LOG_DEBUG &&
  1697. enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
  1698. snprintf(buf + strlen(buf), buf_size - strlen(buf), ", %s",
  1699. av_chroma_location_name(enc->chroma_sample_location));
  1700. if (enc->width) {
  1701. av_strlcat(buf, new_line ? "\n " : ", ", buf_size);
  1702. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1703. "%dx%d",
  1704. enc->width, enc->height);
  1705. if (av_log_get_level() >= AV_LOG_VERBOSE &&
  1706. (enc->width != enc->coded_width ||
  1707. enc->height != enc->coded_height))
  1708. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1709. " (%dx%d)", enc->coded_width, enc->coded_height);
  1710. if (enc->sample_aspect_ratio.num) {
  1711. av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
  1712. enc->width * enc->sample_aspect_ratio.num,
  1713. enc->height * enc->sample_aspect_ratio.den,
  1714. 1024 * 1024);
  1715. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1716. " [PAR %d:%d DAR %d:%d]",
  1717. enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
  1718. display_aspect_ratio.num, display_aspect_ratio.den);
  1719. }
  1720. if (av_log_get_level() >= AV_LOG_DEBUG) {
  1721. int g = av_gcd(enc->time_base.num, enc->time_base.den);
  1722. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1723. ", %d/%d",
  1724. enc->time_base.num / g, enc->time_base.den / g);
  1725. }
  1726. }
  1727. if (encode) {
  1728. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1729. ", q=%d-%d", enc->qmin, enc->qmax);
  1730. }
  1731. break;
  1732. case AVMEDIA_TYPE_AUDIO:
  1733. snprintf(buf, buf_size,
  1734. "Audio: %s",
  1735. codec_name);
  1736. if (profile)
  1737. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1738. " (%s)", profile);
  1739. if (enc->codec_tag) {
  1740. char tag_buf[32];
  1741. av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
  1742. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1743. " [%s / 0x%04X]", tag_buf, enc->codec_tag);
  1744. }
  1745. av_strlcat(buf, "\n ", buf_size);
  1746. if (enc->sample_rate) {
  1747. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1748. "%d Hz, ", enc->sample_rate);
  1749. }
  1750. av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
  1751. if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
  1752. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1753. ", %s", av_get_sample_fmt_name(enc->sample_fmt));
  1754. }
  1755. break;
  1756. case AVMEDIA_TYPE_DATA:
  1757. snprintf(buf, buf_size, "Data: %s", codec_name);
  1758. break;
  1759. case AVMEDIA_TYPE_SUBTITLE:
  1760. snprintf(buf, buf_size, "Subtitle: %s", codec_name);
  1761. break;
  1762. case AVMEDIA_TYPE_ATTACHMENT:
  1763. snprintf(buf, buf_size, "Attachment: %s", codec_name);
  1764. break;
  1765. default:
  1766. snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
  1767. return;
  1768. }
  1769. if (encode) {
  1770. if (enc->flags & CODEC_FLAG_PASS1)
  1771. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1772. ", pass 1");
  1773. if (enc->flags & CODEC_FLAG_PASS2)
  1774. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1775. ", pass 2");
  1776. }
  1777. bitrate = get_bit_rate(enc);
  1778. if (bitrate != 0) {
  1779. snprintf(buf + strlen(buf), buf_size - strlen(buf),
  1780. ", %d kb/s", bitrate / 1000);
  1781. }
  1782. }
  1783. const char *av_get_profile_name(const AVCodec *codec, int profile)
  1784. {
  1785. const AVProfile *p;
  1786. if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
  1787. return NULL;
  1788. for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
  1789. if (p->profile == profile)
  1790. return p->name;
  1791. return NULL;
  1792. }
  1793. unsigned avcodec_version(void)
  1794. {
  1795. return LIBAVCODEC_VERSION_INT;
  1796. }
  1797. const char *avcodec_configuration(void)
  1798. {
  1799. return LIBAV_CONFIGURATION;
  1800. }
  1801. const char *avcodec_license(void)
  1802. {
  1803. #define LICENSE_PREFIX "libavcodec license: "
  1804. return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  1805. }
  1806. void avcodec_flush_buffers(AVCodecContext *avctx)
  1807. {
  1808. if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
  1809. ff_thread_flush(avctx);
  1810. else if (avctx->codec->flush)
  1811. avctx->codec->flush(avctx);
  1812. if (!avctx->refcounted_frames)
  1813. av_frame_unref(avctx->internal->to_free);
  1814. }
  1815. int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
  1816. {
  1817. switch (codec_id) {
  1818. case AV_CODEC_ID_ADPCM_CT:
  1819. case AV_CODEC_ID_ADPCM_IMA_APC:
  1820. case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
  1821. case AV_CODEC_ID_ADPCM_IMA_WS:
  1822. case AV_CODEC_ID_ADPCM_G722:
  1823. case AV_CODEC_ID_ADPCM_YAMAHA:
  1824. return 4;
  1825. case AV_CODEC_ID_PCM_ALAW:
  1826. case AV_CODEC_ID_PCM_MULAW:
  1827. case AV_CODEC_ID_PCM_S8:
  1828. case AV_CODEC_ID_PCM_U8:
  1829. case AV_CODEC_ID_PCM_ZORK:
  1830. return 8;
  1831. case AV_CODEC_ID_PCM_S16BE:
  1832. case AV_CODEC_ID_PCM_S16LE:
  1833. case AV_CODEC_ID_PCM_S16LE_PLANAR:
  1834. case AV_CODEC_ID_PCM_U16BE:
  1835. case AV_CODEC_ID_PCM_U16LE:
  1836. return 16;
  1837. case AV_CODEC_ID_PCM_S24DAUD:
  1838. case AV_CODEC_ID_PCM_S24BE:
  1839. case AV_CODEC_ID_PCM_S24LE:
  1840. case AV_CODEC_ID_PCM_S24LE_PLANAR:
  1841. case AV_CODEC_ID_PCM_U24BE:
  1842. case AV_CODEC_ID_PCM_U24LE:
  1843. return 24;
  1844. case AV_CODEC_ID_PCM_S32BE:
  1845. case AV_CODEC_ID_PCM_S32LE:
  1846. case AV_CODEC_ID_PCM_S32LE_PLANAR:
  1847. case AV_CODEC_ID_PCM_U32BE:
  1848. case AV_CODEC_ID_PCM_U32LE:
  1849. case AV_CODEC_ID_PCM_F32BE:
  1850. case AV_CODEC_ID_PCM_F32LE:
  1851. return 32;
  1852. case AV_CODEC_ID_PCM_F64BE:
  1853. case AV_CODEC_ID_PCM_F64LE:
  1854. return 64;
  1855. default:
  1856. return 0;
  1857. }
  1858. }
  1859. int av_get_bits_per_sample(enum AVCodecID codec_id)
  1860. {
  1861. switch (codec_id) {
  1862. case AV_CODEC_ID_ADPCM_SBPRO_2:
  1863. return 2;
  1864. case AV_CODEC_ID_ADPCM_SBPRO_3:
  1865. return 3;
  1866. case AV_CODEC_ID_ADPCM_SBPRO_4:
  1867. case AV_CODEC_ID_ADPCM_IMA_WAV:
  1868. case AV_CODEC_ID_ADPCM_IMA_QT:
  1869. case AV_CODEC_ID_ADPCM_SWF:
  1870. case AV_CODEC_ID_ADPCM_MS:
  1871. return 4;
  1872. default:
  1873. return av_get_exact_bits_per_sample(codec_id);
  1874. }
  1875. }
  1876. int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
  1877. {
  1878. int id, sr, ch, ba, tag, bps;
  1879. id = avctx->codec_id;
  1880. sr = avctx->sample_rate;
  1881. ch = avctx->channels;
  1882. ba = avctx->block_align;
  1883. tag = avctx->codec_tag;
  1884. bps = av_get_exact_bits_per_sample(avctx->codec_id);
  1885. /* codecs with an exact constant bits per sample */
  1886. if (bps > 0 && ch > 0 && frame_bytes > 0)
  1887. return (frame_bytes * 8) / (bps * ch);
  1888. bps = avctx->bits_per_coded_sample;
  1889. /* codecs with a fixed packet duration */
  1890. switch (id) {
  1891. case AV_CODEC_ID_ADPCM_ADX: return 32;
  1892. case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
  1893. case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
  1894. case AV_CODEC_ID_AMR_NB:
  1895. case AV_CODEC_ID_GSM:
  1896. case AV_CODEC_ID_QCELP:
  1897. case AV_CODEC_ID_RA_144:
  1898. case AV_CODEC_ID_RA_288: return 160;
  1899. case AV_CODEC_ID_IMC: return 256;
  1900. case AV_CODEC_ID_AMR_WB:
  1901. case AV_CODEC_ID_GSM_MS: return 320;
  1902. case AV_CODEC_ID_MP1: return 384;
  1903. case AV_CODEC_ID_ATRAC1: return 512;
  1904. case AV_CODEC_ID_ATRAC3: return 1024;
  1905. case AV_CODEC_ID_MP2:
  1906. case AV_CODEC_ID_MUSEPACK7: return 1152;
  1907. case AV_CODEC_ID_AC3: return 1536;
  1908. }
  1909. if (sr > 0) {
  1910. /* calc from sample rate */
  1911. if (id == AV_CODEC_ID_TTA)
  1912. return 256 * sr / 245;
  1913. if (ch > 0) {
  1914. /* calc from sample rate and channels */
  1915. if (id == AV_CODEC_ID_BINKAUDIO_DCT)
  1916. return (480 << (sr / 22050)) / ch;
  1917. }
  1918. }
  1919. if (ba > 0) {
  1920. /* calc from block_align */
  1921. if (id == AV_CODEC_ID_SIPR) {
  1922. switch (ba) {
  1923. case 20: return 160;
  1924. case 19: return 144;
  1925. case 29: return 288;
  1926. case 37: return 480;
  1927. }
  1928. } else if (id == AV_CODEC_ID_ILBC) {
  1929. switch (ba) {
  1930. case 38: return 160;
  1931. case 50: return 240;
  1932. }
  1933. }
  1934. }
  1935. if (frame_bytes > 0) {
  1936. /* calc from frame_bytes only */
  1937. if (id == AV_CODEC_ID_TRUESPEECH)
  1938. return 240 * (frame_bytes / 32);
  1939. if (id == AV_CODEC_ID_NELLYMOSER)
  1940. return 256 * (frame_bytes / 64);
  1941. if (bps > 0) {
  1942. /* calc from frame_bytes and bits_per_coded_sample */
  1943. if (id == AV_CODEC_ID_ADPCM_G726)
  1944. return frame_bytes * 8 / bps;
  1945. }
  1946. if (ch > 0) {
  1947. /* calc from frame_bytes and channels */
  1948. switch (id) {
  1949. case AV_CODEC_ID_ADPCM_4XM:
  1950. case AV_CODEC_ID_ADPCM_IMA_ISS:
  1951. return (frame_bytes - 4 * ch) * 2 / ch;
  1952. case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
  1953. return (frame_bytes - 4) * 2 / ch;
  1954. case AV_CODEC_ID_ADPCM_IMA_AMV:
  1955. return (frame_bytes - 8) * 2 / ch;
  1956. case AV_CODEC_ID_ADPCM_XA:
  1957. return (frame_bytes / 128) * 224 / ch;
  1958. case AV_CODEC_ID_INTERPLAY_DPCM:
  1959. return (frame_bytes - 6 - ch) / ch;
  1960. case AV_CODEC_ID_ROQ_DPCM:
  1961. return (frame_bytes - 8) / ch;
  1962. case AV_CODEC_ID_XAN_DPCM:
  1963. return (frame_bytes - 2 * ch) / ch;
  1964. case AV_CODEC_ID_MACE3:
  1965. return 3 * frame_bytes / ch;
  1966. case AV_CODEC_ID_MACE6:
  1967. return 6 * frame_bytes / ch;
  1968. case AV_CODEC_ID_PCM_LXF:
  1969. return 2 * (frame_bytes / (5 * ch));
  1970. }
  1971. if (tag) {
  1972. /* calc from frame_bytes, channels, and codec_tag */
  1973. if (id == AV_CODEC_ID_SOL_DPCM) {
  1974. if (tag == 3)
  1975. return frame_bytes / ch;
  1976. else
  1977. return frame_bytes * 2 / ch;
  1978. }
  1979. }
  1980. if (ba > 0) {
  1981. /* calc from frame_bytes, channels, and block_align */
  1982. int blocks = frame_bytes / ba;
  1983. switch (avctx->codec_id) {
  1984. case AV_CODEC_ID_ADPCM_IMA_WAV:
  1985. return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
  1986. case AV_CODEC_ID_ADPCM_IMA_DK3:
  1987. return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
  1988. case AV_CODEC_ID_ADPCM_IMA_DK4:
  1989. return blocks * (1 + (ba - 4 * ch) * 2 / ch);
  1990. case AV_CODEC_ID_ADPCM_MS:
  1991. return blocks * (2 + (ba - 7 * ch) * 2 / ch);
  1992. }
  1993. }
  1994. if (bps > 0) {
  1995. /* calc from frame_bytes, channels, and bits_per_coded_sample */
  1996. switch (avctx->codec_id) {
  1997. case AV_CODEC_ID_PCM_DVD:
  1998. return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
  1999. case AV_CODEC_ID_PCM_BLURAY:
  2000. return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
  2001. case AV_CODEC_ID_S302M:
  2002. return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
  2003. }
  2004. }
  2005. }
  2006. }
  2007. return 0;
  2008. }
  2009. #if !HAVE_THREADS
  2010. int ff_thread_init(AVCodecContext *s)
  2011. {
  2012. return -1;
  2013. }
  2014. #endif
  2015. unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
  2016. {
  2017. unsigned int n = 0;
  2018. while (v >= 0xff) {
  2019. *s++ = 0xff;
  2020. v -= 0xff;
  2021. n++;
  2022. }
  2023. *s = v;
  2024. n++;
  2025. return n;
  2026. }
  2027. int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
  2028. {
  2029. int i;
  2030. for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
  2031. return i;
  2032. }
  2033. #if FF_API_MISSING_SAMPLE
  2034. FF_DISABLE_DEPRECATION_WARNINGS
  2035. void av_log_missing_feature(void *avc, const char *feature, int want_sample)
  2036. {
  2037. av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your Libav "
  2038. "version to the newest one from Git. If the problem still "
  2039. "occurs, it means that your file has a feature which has not "
  2040. "been implemented.\n", feature);
  2041. if(want_sample)
  2042. av_log_ask_for_sample(avc, NULL);
  2043. }
  2044. void av_log_ask_for_sample(void *avc, const char *msg, ...)
  2045. {
  2046. va_list argument_list;
  2047. va_start(argument_list, msg);
  2048. if (msg)
  2049. av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
  2050. av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
  2051. "of this file to ftp://upload.libav.org/incoming/ "
  2052. "and contact the libav-devel mailing list.\n");
  2053. va_end(argument_list);
  2054. }
  2055. FF_ENABLE_DEPRECATION_WARNINGS
  2056. #endif /* FF_API_MISSING_SAMPLE */
  2057. static AVHWAccel *first_hwaccel = NULL;
  2058. void av_register_hwaccel(AVHWAccel *hwaccel)
  2059. {
  2060. AVHWAccel **p = &first_hwaccel;
  2061. while (*p)
  2062. p = &(*p)->next;
  2063. *p = hwaccel;
  2064. hwaccel->next = NULL;
  2065. }
  2066. AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel)
  2067. {
  2068. return hwaccel ? hwaccel->next : first_hwaccel;
  2069. }
  2070. int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
  2071. {
  2072. if (lockmgr_cb) {
  2073. // There is no good way to rollback a failure to destroy the
  2074. // mutex, so we ignore failures.
  2075. lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY);
  2076. lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY);
  2077. lockmgr_cb = NULL;
  2078. codec_mutex = NULL;
  2079. avformat_mutex = NULL;
  2080. }
  2081. if (cb) {
  2082. void *new_codec_mutex = NULL;
  2083. void *new_avformat_mutex = NULL;
  2084. int err;
  2085. if (err = cb(&new_codec_mutex, AV_LOCK_CREATE)) {
  2086. return err > 0 ? AVERROR_UNKNOWN : err;
  2087. }
  2088. if (err = cb(&new_avformat_mutex, AV_LOCK_CREATE)) {
  2089. // Ignore failures to destroy the newly created mutex.
  2090. cb(&new_codec_mutex, AV_LOCK_DESTROY);
  2091. return err > 0 ? AVERROR_UNKNOWN : err;
  2092. }
  2093. lockmgr_cb = cb;
  2094. codec_mutex = new_codec_mutex;
  2095. avformat_mutex = new_avformat_mutex;
  2096. }
  2097. return 0;
  2098. }
  2099. int avpriv_lock_avformat(void)
  2100. {
  2101. if (lockmgr_cb) {
  2102. if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
  2103. return -1;
  2104. }
  2105. return 0;
  2106. }
  2107. int avpriv_unlock_avformat(void)
  2108. {
  2109. if (lockmgr_cb) {
  2110. if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
  2111. return -1;
  2112. }
  2113. return 0;
  2114. }
  2115. unsigned int avpriv_toupper4(unsigned int x)
  2116. {
  2117. return av_toupper(x & 0xFF) +
  2118. (av_toupper((x >> 8) & 0xFF) << 8) +
  2119. (av_toupper((x >> 16) & 0xFF) << 16) +
  2120. (av_toupper((x >> 24) & 0xFF) << 24);
  2121. }
  2122. int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
  2123. {
  2124. int ret;
  2125. dst->owner = src->owner;
  2126. ret = av_frame_ref(dst->f, src->f);
  2127. if (ret < 0)
  2128. return ret;
  2129. if (src->progress &&
  2130. !(dst->progress = av_buffer_ref(src->progress))) {
  2131. ff_thread_release_buffer(dst->owner, dst);
  2132. return AVERROR(ENOMEM);
  2133. }
  2134. return 0;
  2135. }
  2136. #if !HAVE_THREADS
  2137. int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
  2138. {
  2139. f->owner = avctx;
  2140. return ff_get_buffer(avctx, f->f, flags);
  2141. }
  2142. void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
  2143. {
  2144. if (f->f)
  2145. av_frame_unref(f->f);
  2146. }
  2147. void ff_thread_finish_setup(AVCodecContext *avctx)
  2148. {
  2149. }
  2150. void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
  2151. {
  2152. }
  2153. void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
  2154. {
  2155. }
  2156. #endif
  2157. enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
  2158. {
  2159. if (codec_id <= AV_CODEC_ID_NONE)
  2160. return AVMEDIA_TYPE_UNKNOWN;
  2161. else if (codec_id < AV_CODEC_ID_FIRST_AUDIO)
  2162. return AVMEDIA_TYPE_VIDEO;
  2163. else if (codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
  2164. return AVMEDIA_TYPE_AUDIO;
  2165. else if (codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
  2166. return AVMEDIA_TYPE_SUBTITLE;
  2167. return AVMEDIA_TYPE_UNKNOWN;
  2168. }
  2169. int avcodec_is_open(AVCodecContext *s)
  2170. {
  2171. return !!s->internal;
  2172. }
  2173. const uint8_t *avpriv_find_start_code(const uint8_t *restrict p,
  2174. const uint8_t *end,
  2175. uint32_t * restrict state)
  2176. {
  2177. int i;
  2178. assert(p <= end);
  2179. if (p >= end)
  2180. return end;
  2181. for (i = 0; i < 3; i++) {
  2182. uint32_t tmp = *state << 8;
  2183. *state = tmp + *(p++);
  2184. if (tmp == 0x100 || p == end)
  2185. return p;
  2186. }
  2187. while (p < end) {
  2188. if (p[-1] > 1 ) p += 3;
  2189. else if (p[-2] ) p += 2;
  2190. else if (p[-3]|(p[-1]-1)) p++;
  2191. else {
  2192. p++;
  2193. break;
  2194. }
  2195. }
  2196. p = FFMIN(p, end) - 4;
  2197. *state = AV_RB32(p);
  2198. return p + 4;
  2199. }