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 FFmpeg. 7 * 8 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23/** 24 * @file 25 * utils. 26 */ 27 28#include "config.h" 29#include "libavutil/avassert.h" 30#include "libavutil/channel_layout.h" 31#include "libavutil/intreadwrite.h" 32#include "libavutil/mem.h" 33#include "libavutil/pixdesc.h" 34#include "libavutil/imgutils.h" 35#include "libavutil/pixfmt.h" 36#include "avcodec.h" 37#include "codec.h" 38#include "codec_internal.h" 39#include "hwconfig.h" 40#include "thread.h" 41#include "threadframe.h" 42#include "internal.h" 43#include "put_bits.h" 44#include "startcode.h" 45#include <stdlib.h> 46#include <limits.h> 47 48void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size) 49{ 50 uint8_t **p = ptr; 51 if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) { 52 av_freep(p); 53 *size = 0; 54 return; 55 } 56 av_fast_mallocz(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE); 57 if (*p) 58 memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE); 59} 60 61void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size) 62{ 63 uint8_t **p = ptr; 64 if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) { 65 av_freep(p); 66 *size = 0; 67 return; 68 } 69 av_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE); 70 if (*p) 71 memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE); 72} 73 74int av_codec_is_encoder(const AVCodec *avcodec) 75{ 76 const FFCodec *const codec = ffcodec(avcodec); 77 return codec && (codec->cb_type == FF_CODEC_CB_TYPE_ENCODE || 78 codec->cb_type == FF_CODEC_CB_TYPE_ENCODE_SUB || 79 codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_PACKET); 80} 81 82int av_codec_is_decoder(const AVCodec *avcodec) 83{ 84 const FFCodec *const codec = ffcodec(avcodec); 85 return codec && (codec->cb_type == FF_CODEC_CB_TYPE_DECODE || 86 codec->cb_type == FF_CODEC_CB_TYPE_DECODE_SUB || 87 codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME); 88} 89 90int ff_set_dimensions(AVCodecContext *s, int width, int height) 91{ 92 int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s); 93 94 if (ret < 0) 95 width = height = 0; 96 97 s->coded_width = width; 98 s->coded_height = height; 99 s->width = AV_CEIL_RSHIFT(width, s->lowres); 100 s->height = AV_CEIL_RSHIFT(height, s->lowres); 101 102 return ret; 103} 104 105int ff_set_sar(AVCodecContext *avctx, AVRational sar) 106{ 107 int ret = av_image_check_sar(avctx->width, avctx->height, sar); 108 109 if (ret < 0) { 110 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n", 111 sar.num, sar.den); 112 avctx->sample_aspect_ratio = (AVRational){ 0, 1 }; 113 return ret; 114 } else { 115 avctx->sample_aspect_ratio = sar; 116 } 117 return 0; 118} 119 120int ff_side_data_update_matrix_encoding(AVFrame *frame, 121 enum AVMatrixEncoding matrix_encoding) 122{ 123 AVFrameSideData *side_data; 124 enum AVMatrixEncoding *data; 125 126 side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING); 127 if (!side_data) 128 side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING, 129 sizeof(enum AVMatrixEncoding)); 130 131 if (!side_data) 132 return AVERROR(ENOMEM); 133 134 data = (enum AVMatrixEncoding*)side_data->data; 135 *data = matrix_encoding; 136 137 return 0; 138} 139 140void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, 141 int linesize_align[AV_NUM_DATA_POINTERS]) 142{ 143 int i; 144 int w_align = 1; 145 int h_align = 1; 146 AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt); 147 148 if (desc) { 149 w_align = 1 << desc->log2_chroma_w; 150 h_align = 1 << desc->log2_chroma_h; 151 } 152 153 switch (s->pix_fmt) { 154 case AV_PIX_FMT_YUV420P: 155 case AV_PIX_FMT_YUYV422: 156 case AV_PIX_FMT_YVYU422: 157 case AV_PIX_FMT_UYVY422: 158 case AV_PIX_FMT_YUV422P: 159 case AV_PIX_FMT_YUV440P: 160 case AV_PIX_FMT_YUV444P: 161 case AV_PIX_FMT_GBRP: 162 case AV_PIX_FMT_GBRAP: 163 case AV_PIX_FMT_GRAY8: 164 case AV_PIX_FMT_GRAY16BE: 165 case AV_PIX_FMT_GRAY16LE: 166 case AV_PIX_FMT_YUVJ420P: 167 case AV_PIX_FMT_YUVJ422P: 168 case AV_PIX_FMT_YUVJ440P: 169 case AV_PIX_FMT_YUVJ444P: 170 case AV_PIX_FMT_YUVA420P: 171 case AV_PIX_FMT_YUVA422P: 172 case AV_PIX_FMT_YUVA444P: 173 case AV_PIX_FMT_YUV420P9LE: 174 case AV_PIX_FMT_YUV420P9BE: 175 case AV_PIX_FMT_YUV420P10LE: 176 case AV_PIX_FMT_YUV420P10BE: 177 case AV_PIX_FMT_YUV420P12LE: 178 case AV_PIX_FMT_YUV420P12BE: 179 case AV_PIX_FMT_YUV420P14LE: 180 case AV_PIX_FMT_YUV420P14BE: 181 case AV_PIX_FMT_YUV420P16LE: 182 case AV_PIX_FMT_YUV420P16BE: 183 case AV_PIX_FMT_YUVA420P9LE: 184 case AV_PIX_FMT_YUVA420P9BE: 185 case AV_PIX_FMT_YUVA420P10LE: 186 case AV_PIX_FMT_YUVA420P10BE: 187 case AV_PIX_FMT_YUVA420P16LE: 188 case AV_PIX_FMT_YUVA420P16BE: 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_YUV422P12LE: 194 case AV_PIX_FMT_YUV422P12BE: 195 case AV_PIX_FMT_YUV422P14LE: 196 case AV_PIX_FMT_YUV422P14BE: 197 case AV_PIX_FMT_YUV422P16LE: 198 case AV_PIX_FMT_YUV422P16BE: 199 case AV_PIX_FMT_YUVA422P9LE: 200 case AV_PIX_FMT_YUVA422P9BE: 201 case AV_PIX_FMT_YUVA422P10LE: 202 case AV_PIX_FMT_YUVA422P10BE: 203 case AV_PIX_FMT_YUVA422P12LE: 204 case AV_PIX_FMT_YUVA422P12BE: 205 case AV_PIX_FMT_YUVA422P16LE: 206 case AV_PIX_FMT_YUVA422P16BE: 207 case AV_PIX_FMT_YUV440P10LE: 208 case AV_PIX_FMT_YUV440P10BE: 209 case AV_PIX_FMT_YUV440P12LE: 210 case AV_PIX_FMT_YUV440P12BE: 211 case AV_PIX_FMT_YUV444P9LE: 212 case AV_PIX_FMT_YUV444P9BE: 213 case AV_PIX_FMT_YUV444P10LE: 214 case AV_PIX_FMT_YUV444P10BE: 215 case AV_PIX_FMT_YUV444P12LE: 216 case AV_PIX_FMT_YUV444P12BE: 217 case AV_PIX_FMT_YUV444P14LE: 218 case AV_PIX_FMT_YUV444P14BE: 219 case AV_PIX_FMT_YUV444P16LE: 220 case AV_PIX_FMT_YUV444P16BE: 221 case AV_PIX_FMT_YUVA444P9LE: 222 case AV_PIX_FMT_YUVA444P9BE: 223 case AV_PIX_FMT_YUVA444P10LE: 224 case AV_PIX_FMT_YUVA444P10BE: 225 case AV_PIX_FMT_YUVA444P12LE: 226 case AV_PIX_FMT_YUVA444P12BE: 227 case AV_PIX_FMT_YUVA444P16LE: 228 case AV_PIX_FMT_YUVA444P16BE: 229 case AV_PIX_FMT_GBRP9LE: 230 case AV_PIX_FMT_GBRP9BE: 231 case AV_PIX_FMT_GBRP10LE: 232 case AV_PIX_FMT_GBRP10BE: 233 case AV_PIX_FMT_GBRP12LE: 234 case AV_PIX_FMT_GBRP12BE: 235 case AV_PIX_FMT_GBRP14LE: 236 case AV_PIX_FMT_GBRP14BE: 237 case AV_PIX_FMT_GBRP16LE: 238 case AV_PIX_FMT_GBRP16BE: 239 case AV_PIX_FMT_GBRAP12LE: 240 case AV_PIX_FMT_GBRAP12BE: 241 case AV_PIX_FMT_GBRAP16LE: 242 case AV_PIX_FMT_GBRAP16BE: 243 w_align = 16; //FIXME assume 16 pixel per macroblock 244 h_align = 16 * 2; // interlaced needs 2 macroblocks height 245 if (s->codec_id == AV_CODEC_ID_BINKVIDEO) 246 w_align = 16*2; 247 break; 248 case AV_PIX_FMT_YUV411P: 249 case AV_PIX_FMT_YUVJ411P: 250 case AV_PIX_FMT_UYYVYY411: 251 w_align = 32; 252 h_align = 16 * 2; 253 break; 254 case AV_PIX_FMT_YUV410P: 255 if (s->codec_id == AV_CODEC_ID_SVQ1) { 256 w_align = 64; 257 h_align = 64; 258 } else if (s->codec_id == AV_CODEC_ID_SNOW) { 259 w_align = 16; 260 h_align = 16; 261 } 262 break; 263 case AV_PIX_FMT_RGB555: 264 if (s->codec_id == AV_CODEC_ID_RPZA) { 265 w_align = 4; 266 h_align = 4; 267 } 268 if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) { 269 w_align = 8; 270 h_align = 8; 271 } 272 break; 273 case AV_PIX_FMT_PAL8: 274 case AV_PIX_FMT_BGR8: 275 case AV_PIX_FMT_RGB8: 276 if (s->codec_id == AV_CODEC_ID_SMC || 277 s->codec_id == AV_CODEC_ID_CINEPAK) { 278 w_align = 4; 279 h_align = 4; 280 } 281 if (s->codec_id == AV_CODEC_ID_JV || 282 s->codec_id == AV_CODEC_ID_ARGO || 283 s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) { 284 w_align = 8; 285 h_align = 8; 286 } 287 if (s->codec_id == AV_CODEC_ID_MJPEG || 288 s->codec_id == AV_CODEC_ID_MJPEGB || 289 s->codec_id == AV_CODEC_ID_LJPEG || 290 s->codec_id == AV_CODEC_ID_SMVJPEG || 291 s->codec_id == AV_CODEC_ID_AMV || 292 s->codec_id == AV_CODEC_ID_SP5X || 293 s->codec_id == AV_CODEC_ID_JPEGLS) { 294 w_align = 8; 295 h_align = 2*8; 296 } 297 break; 298 case AV_PIX_FMT_BGR24: 299 if ((s->codec_id == AV_CODEC_ID_MSZH) || 300 (s->codec_id == AV_CODEC_ID_ZLIB)) { 301 w_align = 4; 302 h_align = 4; 303 } 304 break; 305 case AV_PIX_FMT_RGB24: 306 if (s->codec_id == AV_CODEC_ID_CINEPAK) { 307 w_align = 4; 308 h_align = 4; 309 } 310 break; 311 case AV_PIX_FMT_BGR0: 312 if (s->codec_id == AV_CODEC_ID_ARGO) { 313 w_align = 8; 314 h_align = 8; 315 } 316 break; 317 default: 318 break; 319 } 320 321 if (s->codec_id == AV_CODEC_ID_IFF_ILBM) { 322 w_align = FFMAX(w_align, 16); 323 } 324 325 *width = FFALIGN(*width, w_align); 326 *height = FFALIGN(*height, h_align); 327 if (s->codec_id == AV_CODEC_ID_H264 || s->lowres || 328 s->codec_id == AV_CODEC_ID_VC1 || s->codec_id == AV_CODEC_ID_WMV3 || 329 s->codec_id == AV_CODEC_ID_VP5 || s->codec_id == AV_CODEC_ID_VP6 || 330 s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A 331 ) { 332 // some of the optimized chroma MC reads one line too much 333 // which is also done in mpeg decoders with lowres > 0 334 *height += 2; 335 336 // H.264 uses edge emulation for out of frame motion vectors, for this 337 // it requires a temporary area large enough to hold a 21x21 block, 338 // increasing witdth ensure that the temporary area is large enough, 339 // the next rounded up width is 32 340 *width = FFMAX(*width, 32); 341 } 342 if (s->codec_id == AV_CODEC_ID_SVQ3) { 343 *width = FFMAX(*width, 32); 344 } 345 346 for (i = 0; i < 4; i++) 347 linesize_align[i] = STRIDE_ALIGN; 348} 349 350void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height) 351{ 352 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt); 353 int chroma_shift = desc->log2_chroma_w; 354 int linesize_align[AV_NUM_DATA_POINTERS]; 355 int align; 356 357 avcodec_align_dimensions2(s, width, height, linesize_align); 358 align = FFMAX(linesize_align[0], linesize_align[3]); 359 linesize_align[1] <<= chroma_shift; 360 linesize_align[2] <<= chroma_shift; 361 align = FFMAX3(align, linesize_align[1], linesize_align[2]); 362 *width = FFALIGN(*width, align); 363} 364 365int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos) 366{ 367 if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB) 368 return AVERROR(EINVAL); 369 pos--; 370 371 *xpos = (pos&1) * 128; 372 *ypos = ((pos>>1)^(pos<4)) * 128; 373 374 return 0; 375} 376 377enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos) 378{ 379 int pos, xout, yout; 380 381 for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) { 382 if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos) 383 return pos; 384 } 385 return AVCHROMA_LOC_UNSPECIFIED; 386} 387 388int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, 389 enum AVSampleFormat sample_fmt, const uint8_t *buf, 390 int buf_size, int align) 391{ 392 int ch, planar, needed_size, ret = 0; 393 394 needed_size = av_samples_get_buffer_size(NULL, nb_channels, 395 frame->nb_samples, sample_fmt, 396 align); 397 if (buf_size < needed_size) 398 return AVERROR(EINVAL); 399 400 planar = av_sample_fmt_is_planar(sample_fmt); 401 if (planar && nb_channels > AV_NUM_DATA_POINTERS) { 402 if (!FF_ALLOCZ_TYPED_ARRAY(frame->extended_data, nb_channels)) 403 return AVERROR(ENOMEM); 404 } else { 405 frame->extended_data = frame->data; 406 } 407 408 if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0], 409 (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples, 410 sample_fmt, align)) < 0) { 411 if (frame->extended_data != frame->data) 412 av_freep(&frame->extended_data); 413 return ret; 414 } 415 if (frame->extended_data != frame->data) { 416 for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++) 417 frame->data[ch] = frame->extended_data[ch]; 418 } 419 420 return ret; 421} 422 423void ff_color_frame(AVFrame *frame, const int c[4]) 424{ 425 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); 426 int p, y; 427 428 av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR); 429 430 for (p = 0; p<desc->nb_components; p++) { 431 uint8_t *dst = frame->data[p]; 432 int is_chroma = p == 1 || p == 2; 433 int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width; 434 int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height; 435 if (desc->comp[0].depth >= 9) { 436 ((uint16_t*)dst)[0] = c[p]; 437 av_memcpy_backptr(dst + 2, 2, bytes - 2); 438 dst += frame->linesize[p]; 439 for (y = 1; y < height; y++) { 440 memcpy(dst, frame->data[p], 2*bytes); 441 dst += frame->linesize[p]; 442 } 443 } else { 444 for (y = 0; y < height; y++) { 445 memset(dst, c[p], bytes); 446 dst += frame->linesize[p]; 447 } 448 } 449 } 450} 451 452int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec){ 453 return !!(ffcodec(codec)->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM); 454} 455 456const char *avcodec_get_name(enum AVCodecID id) 457{ 458 const AVCodecDescriptor *cd; 459 const AVCodec *codec; 460 461 if (id == AV_CODEC_ID_NONE) 462 return "none"; 463 cd = avcodec_descriptor_get(id); 464 if (cd) 465 return cd->name; 466 av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id); 467 codec = avcodec_find_decoder(id); 468 if (codec) 469 return codec->name; 470 codec = avcodec_find_encoder(id); 471 if (codec) 472 return codec->name; 473 return "unknown_codec"; 474} 475 476const char *av_get_profile_name(const AVCodec *codec, int profile) 477{ 478 const AVProfile *p; 479 if (profile == FF_PROFILE_UNKNOWN || !codec->profiles) 480 return NULL; 481 482 for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++) 483 if (p->profile == profile) 484 return p->name; 485 486 return NULL; 487} 488 489const char *avcodec_profile_name(enum AVCodecID codec_id, int profile) 490{ 491 const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id); 492 const AVProfile *p; 493 494 if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles) 495 return NULL; 496 497 for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++) 498 if (p->profile == profile) 499 return p->name; 500 501 return NULL; 502} 503 504int av_get_exact_bits_per_sample(enum AVCodecID codec_id) 505{ 506 switch (codec_id) { 507 case AV_CODEC_ID_DFPWM: 508 return 1; 509 case AV_CODEC_ID_8SVX_EXP: 510 case AV_CODEC_ID_8SVX_FIB: 511 case AV_CODEC_ID_ADPCM_ARGO: 512 case AV_CODEC_ID_ADPCM_CT: 513 case AV_CODEC_ID_ADPCM_IMA_ALP: 514 case AV_CODEC_ID_ADPCM_IMA_AMV: 515 case AV_CODEC_ID_ADPCM_IMA_APC: 516 case AV_CODEC_ID_ADPCM_IMA_APM: 517 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD: 518 case AV_CODEC_ID_ADPCM_IMA_OKI: 519 case AV_CODEC_ID_ADPCM_IMA_WS: 520 case AV_CODEC_ID_ADPCM_IMA_SSI: 521 case AV_CODEC_ID_ADPCM_G722: 522 case AV_CODEC_ID_ADPCM_YAMAHA: 523 case AV_CODEC_ID_ADPCM_AICA: 524 return 4; 525 case AV_CODEC_ID_DSD_LSBF: 526 case AV_CODEC_ID_DSD_MSBF: 527 case AV_CODEC_ID_DSD_LSBF_PLANAR: 528 case AV_CODEC_ID_DSD_MSBF_PLANAR: 529 case AV_CODEC_ID_PCM_ALAW: 530 case AV_CODEC_ID_PCM_MULAW: 531 case AV_CODEC_ID_PCM_VIDC: 532 case AV_CODEC_ID_PCM_S8: 533 case AV_CODEC_ID_PCM_S8_PLANAR: 534 case AV_CODEC_ID_PCM_SGA: 535 case AV_CODEC_ID_PCM_U8: 536 case AV_CODEC_ID_SDX2_DPCM: 537 case AV_CODEC_ID_DERF_DPCM: 538 return 8; 539 case AV_CODEC_ID_PCM_S16BE: 540 case AV_CODEC_ID_PCM_S16BE_PLANAR: 541 case AV_CODEC_ID_PCM_S16LE: 542 case AV_CODEC_ID_PCM_S16LE_PLANAR: 543 case AV_CODEC_ID_PCM_U16BE: 544 case AV_CODEC_ID_PCM_U16LE: 545 return 16; 546 case AV_CODEC_ID_PCM_S24DAUD: 547 case AV_CODEC_ID_PCM_S24BE: 548 case AV_CODEC_ID_PCM_S24LE: 549 case AV_CODEC_ID_PCM_S24LE_PLANAR: 550 case AV_CODEC_ID_PCM_U24BE: 551 case AV_CODEC_ID_PCM_U24LE: 552 return 24; 553 case AV_CODEC_ID_PCM_S32BE: 554 case AV_CODEC_ID_PCM_S32LE: 555 case AV_CODEC_ID_PCM_S32LE_PLANAR: 556 case AV_CODEC_ID_PCM_U32BE: 557 case AV_CODEC_ID_PCM_U32LE: 558 case AV_CODEC_ID_PCM_F32BE: 559 case AV_CODEC_ID_PCM_F32LE: 560 case AV_CODEC_ID_PCM_F24LE: 561 case AV_CODEC_ID_PCM_F16LE: 562 return 32; 563 case AV_CODEC_ID_PCM_F64BE: 564 case AV_CODEC_ID_PCM_F64LE: 565 case AV_CODEC_ID_PCM_S64BE: 566 case AV_CODEC_ID_PCM_S64LE: 567 return 64; 568 default: 569 return 0; 570 } 571} 572 573enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be) 574{ 575 static const enum AVCodecID map[][2] = { 576 [AV_SAMPLE_FMT_U8 ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 }, 577 [AV_SAMPLE_FMT_S16 ] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE }, 578 [AV_SAMPLE_FMT_S32 ] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE }, 579 [AV_SAMPLE_FMT_FLT ] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE }, 580 [AV_SAMPLE_FMT_DBL ] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE }, 581 [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 }, 582 [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE }, 583 [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE }, 584 [AV_SAMPLE_FMT_S64P] = { AV_CODEC_ID_PCM_S64LE, AV_CODEC_ID_PCM_S64BE }, 585 [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE }, 586 [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE }, 587 }; 588 if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map)) 589 return AV_CODEC_ID_NONE; 590 if (be < 0 || be > 1) 591 be = AV_NE(1, 0); 592 return map[fmt][be]; 593} 594 595int av_get_bits_per_sample(enum AVCodecID codec_id) 596{ 597 switch (codec_id) { 598 case AV_CODEC_ID_DFPWM: 599 return 1; 600 case AV_CODEC_ID_ADPCM_SBPRO_2: 601 return 2; 602 case AV_CODEC_ID_ADPCM_SBPRO_3: 603 return 3; 604 case AV_CODEC_ID_ADPCM_SBPRO_4: 605 case AV_CODEC_ID_ADPCM_IMA_WAV: 606 case AV_CODEC_ID_ADPCM_IMA_QT: 607 case AV_CODEC_ID_ADPCM_SWF: 608 case AV_CODEC_ID_ADPCM_MS: 609 return 4; 610 default: 611 return av_get_exact_bits_per_sample(codec_id); 612 } 613} 614 615static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba, 616 uint32_t tag, int bits_per_coded_sample, int64_t bitrate, 617 uint8_t * extradata, int frame_size, int frame_bytes) 618{ 619 int bps = av_get_exact_bits_per_sample(id); 620 int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1; 621 622 /* codecs with an exact constant bits per sample */ 623 if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768) 624 return (frame_bytes * 8LL) / (bps * ch); 625 bps = bits_per_coded_sample; 626 627 /* codecs with a fixed packet duration */ 628 switch (id) { 629 case AV_CODEC_ID_ADPCM_ADX: return 32; 630 case AV_CODEC_ID_ADPCM_IMA_QT: return 64; 631 case AV_CODEC_ID_ADPCM_EA_XAS: return 128; 632 case AV_CODEC_ID_AMR_NB: 633 case AV_CODEC_ID_EVRC: 634 case AV_CODEC_ID_GSM: 635 case AV_CODEC_ID_QCELP: 636 case AV_CODEC_ID_RA_288: return 160; 637 case AV_CODEC_ID_AMR_WB: 638 case AV_CODEC_ID_GSM_MS: return 320; 639 case AV_CODEC_ID_MP1: return 384; 640 case AV_CODEC_ID_ATRAC1: return 512; 641 case AV_CODEC_ID_ATRAC9: 642 case AV_CODEC_ID_ATRAC3: 643 if (framecount > INT_MAX/1024) 644 return 0; 645 return 1024 * framecount; 646 case AV_CODEC_ID_ATRAC3P: return 2048; 647 case AV_CODEC_ID_MP2: 648 case AV_CODEC_ID_MUSEPACK7: return 1152; 649 case AV_CODEC_ID_AC3: return 1536; 650 case AV_CODEC_ID_AVS3DA: return 1024; // avs3p3/audio vivid fixed frame size 651 } 652 653 if (sr > 0) { 654 /* calc from sample rate */ 655 if (id == AV_CODEC_ID_TTA) 656 return 256ll * sr / 245; 657 else if (id == AV_CODEC_ID_DST) 658 return 588ll * sr / 44100; 659 else if (id == AV_CODEC_ID_BINKAUDIO_DCT) { 660 if (sr / 22050 > 22) 661 return 0; 662 return (480 << (sr / 22050)); 663 } 664 665 if (id == AV_CODEC_ID_MP3) 666 return sr <= 24000 ? 576 : 1152; 667 } 668 669 if (ba > 0) { 670 /* calc from block_align */ 671 if (id == AV_CODEC_ID_SIPR) { 672 switch (ba) { 673 case 20: return 160; 674 case 19: return 144; 675 case 29: return 288; 676 case 37: return 480; 677 } 678 } else if (id == AV_CODEC_ID_ILBC) { 679 switch (ba) { 680 case 38: return 160; 681 case 50: return 240; 682 } 683 } 684 } 685 686 if (frame_bytes > 0) { 687 /* calc from frame_bytes only */ 688 if (id == AV_CODEC_ID_TRUESPEECH) 689 return 240 * (frame_bytes / 32); 690 if (id == AV_CODEC_ID_NELLYMOSER) 691 return 256 * (frame_bytes / 64); 692 if (id == AV_CODEC_ID_RA_144) 693 return 160 * (frame_bytes / 20); 694 695 if (bps > 0) { 696 /* calc from frame_bytes and bits_per_coded_sample */ 697 if (id == AV_CODEC_ID_ADPCM_G726 || id == AV_CODEC_ID_ADPCM_G726LE) 698 return frame_bytes * 8 / bps; 699 } 700 701 if (ch > 0 && ch < INT_MAX/16) { 702 /* calc from frame_bytes and channels */ 703 switch (id) { 704 case AV_CODEC_ID_FASTAUDIO: 705 return frame_bytes / (40 * ch) * 256; 706 case AV_CODEC_ID_ADPCM_IMA_MOFLEX: 707 return (frame_bytes - 4 * ch) / (128 * ch) * 256; 708 case AV_CODEC_ID_ADPCM_AFC: 709 return frame_bytes / (9 * ch) * 16; 710 case AV_CODEC_ID_ADPCM_PSX: 711 case AV_CODEC_ID_ADPCM_DTK: 712 frame_bytes /= 16 * ch; 713 if (frame_bytes > INT_MAX / 28) 714 return 0; 715 return frame_bytes * 28; 716 case AV_CODEC_ID_ADPCM_4XM: 717 case AV_CODEC_ID_ADPCM_IMA_ACORN: 718 case AV_CODEC_ID_ADPCM_IMA_DAT4: 719 case AV_CODEC_ID_ADPCM_IMA_ISS: 720 return (frame_bytes - 4 * ch) * 2 / ch; 721 case AV_CODEC_ID_ADPCM_IMA_SMJPEG: 722 return (frame_bytes - 4) * 2 / ch; 723 case AV_CODEC_ID_ADPCM_IMA_AMV: 724 return (frame_bytes - 8) * 2; 725 case AV_CODEC_ID_ADPCM_THP: 726 case AV_CODEC_ID_ADPCM_THP_LE: 727 if (extradata) 728 return frame_bytes * 14LL / (8 * ch); 729 break; 730 case AV_CODEC_ID_ADPCM_XA: 731 return (frame_bytes / 128) * 224 / ch; 732 case AV_CODEC_ID_INTERPLAY_DPCM: 733 return (frame_bytes - 6 - ch) / ch; 734 case AV_CODEC_ID_ROQ_DPCM: 735 return (frame_bytes - 8) / ch; 736 case AV_CODEC_ID_XAN_DPCM: 737 return (frame_bytes - 2 * ch) / ch; 738 case AV_CODEC_ID_MACE3: 739 return 3 * frame_bytes / ch; 740 case AV_CODEC_ID_MACE6: 741 return 6 * frame_bytes / ch; 742 case AV_CODEC_ID_PCM_LXF: 743 return 2 * (frame_bytes / (5 * ch)); 744 case AV_CODEC_ID_IAC: 745 case AV_CODEC_ID_IMC: 746 return 4 * frame_bytes / ch; 747 } 748 749 if (tag) { 750 /* calc from frame_bytes, channels, and codec_tag */ 751 if (id == AV_CODEC_ID_SOL_DPCM) { 752 if (tag == 3) 753 return frame_bytes / ch; 754 else 755 return frame_bytes * 2 / ch; 756 } 757 } 758 759 if (ba > 0) { 760 /* calc from frame_bytes, channels, and block_align */ 761 int blocks = frame_bytes / ba; 762 int64_t tmp = 0; 763 switch (id) { 764 case AV_CODEC_ID_ADPCM_IMA_WAV: 765 if (bps < 2 || bps > 5) 766 return 0; 767 tmp = blocks * (1LL + (ba - 4 * ch) / (bps * ch) * 8); 768 break; 769 case AV_CODEC_ID_ADPCM_IMA_DK3: 770 tmp = blocks * (((ba - 16LL) * 2 / 3 * 4) / ch); 771 break; 772 case AV_CODEC_ID_ADPCM_IMA_DK4: 773 tmp = blocks * (1 + (ba - 4LL * ch) * 2 / ch); 774 break; 775 case AV_CODEC_ID_ADPCM_IMA_RAD: 776 tmp = blocks * ((ba - 4LL * ch) * 2 / ch); 777 break; 778 case AV_CODEC_ID_ADPCM_MS: 779 tmp = blocks * (2 + (ba - 7LL * ch) * 2LL / ch); 780 break; 781 case AV_CODEC_ID_ADPCM_MTAF: 782 tmp = blocks * (ba - 16LL) * 2 / ch; 783 break; 784 } 785 if (tmp) { 786 if (tmp != (int)tmp) 787 return 0; 788 return tmp; 789 } 790 } 791 792 if (bps > 0) { 793 /* calc from frame_bytes, channels, and bits_per_coded_sample */ 794 switch (id) { 795 case AV_CODEC_ID_PCM_DVD: 796 if(bps<4 || frame_bytes<3) 797 return 0; 798 return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch)); 799 case AV_CODEC_ID_PCM_BLURAY: 800 if(bps<4 || frame_bytes<4) 801 return 0; 802 return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8); 803 case AV_CODEC_ID_S302M: 804 return 2 * (frame_bytes / ((bps + 4) / 4)) / ch; 805 } 806 } 807 } 808 } 809 810 /* Fall back on using frame_size */ 811 if (frame_size > 1 && frame_bytes) 812 return frame_size; 813 814 //For WMA we currently have no other means to calculate duration thus we 815 //do it here by assuming CBR, which is true for all known cases. 816 if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) { 817 if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2) 818 return (frame_bytes * 8LL * sr) / bitrate; 819 } 820 821 return 0; 822} 823 824int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes) 825{ 826 int channels = avctx->ch_layout.nb_channels; 827 int duration; 828#if FF_API_OLD_CHANNEL_LAYOUT 829FF_DISABLE_DEPRECATION_WARNINGS 830 if (!channels) 831 channels = avctx->channels; 832FF_ENABLE_DEPRECATION_WARNINGS 833#endif 834 duration = get_audio_frame_duration(avctx->codec_id, avctx->sample_rate, 835 channels, avctx->block_align, 836 avctx->codec_tag, avctx->bits_per_coded_sample, 837 avctx->bit_rate, avctx->extradata, avctx->frame_size, 838 frame_bytes); 839 return FFMAX(0, duration); 840} 841 842int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes) 843{ 844 int channels = par->ch_layout.nb_channels; 845 int duration; 846#if FF_API_OLD_CHANNEL_LAYOUT 847FF_DISABLE_DEPRECATION_WARNINGS 848 if (!channels) 849 channels = par->channels; 850FF_ENABLE_DEPRECATION_WARNINGS 851#endif 852 duration = get_audio_frame_duration(par->codec_id, par->sample_rate, 853 channels, par->block_align, 854 par->codec_tag, par->bits_per_coded_sample, 855 par->bit_rate, par->extradata, par->frame_size, 856 frame_bytes); 857 return FFMAX(0, duration); 858} 859 860#if !HAVE_THREADS 861int ff_thread_init(AVCodecContext *s) 862{ 863 return -1; 864} 865 866#endif 867 868unsigned int av_xiphlacing(unsigned char *s, unsigned int v) 869{ 870 unsigned int n = 0; 871 872 while (v >= 0xff) { 873 *s++ = 0xff; 874 v -= 0xff; 875 n++; 876 } 877 *s = v; 878 n++; 879 return n; 880} 881 882int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b) 883{ 884 int i; 885 for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ; 886 return i; 887} 888 889const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *avcodec, int index) 890{ 891 const FFCodec *const codec = ffcodec(avcodec); 892 int i; 893 if (!codec->hw_configs || index < 0) 894 return NULL; 895 for (i = 0; i <= index; i++) 896 if (!codec->hw_configs[i]) 897 return NULL; 898 return &codec->hw_configs[index]->public; 899} 900 901int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src) 902{ 903 int ret; 904 905 dst->owner[0] = src->owner[0]; 906 dst->owner[1] = src->owner[1]; 907 908 ret = av_frame_ref(dst->f, src->f); 909 if (ret < 0) 910 return ret; 911 912 av_assert0(!dst->progress); 913 914 if (src->progress && 915 !(dst->progress = av_buffer_ref(src->progress))) { 916 ff_thread_release_ext_buffer(dst->owner[0], dst); 917 return AVERROR(ENOMEM); 918 } 919 920 return 0; 921} 922 923#if !HAVE_THREADS 924 925enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt) 926{ 927 return ff_get_format(avctx, fmt); 928} 929 930int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags) 931{ 932 return ff_get_buffer(avctx, f, flags); 933} 934 935int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags) 936{ 937 f->owner[0] = f->owner[1] = avctx; 938 return ff_get_buffer(avctx, f->f, flags); 939} 940 941void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f) 942{ 943 if (f) 944 av_frame_unref(f); 945} 946 947void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f) 948{ 949 f->owner[0] = f->owner[1] = NULL; 950 if (f->f) 951 av_frame_unref(f->f); 952} 953 954void ff_thread_finish_setup(AVCodecContext *avctx) 955{ 956} 957 958void ff_thread_report_progress(ThreadFrame *f, int progress, int field) 959{ 960} 961 962void ff_thread_await_progress(ThreadFrame *f, int progress, int field) 963{ 964} 965 966int ff_thread_can_start_frame(AVCodecContext *avctx) 967{ 968 return 1; 969} 970 971int ff_slice_thread_init_progress(AVCodecContext *avctx) 972{ 973 return 0; 974} 975 976int ff_alloc_entries(AVCodecContext *avctx, int count) 977{ 978 return 0; 979} 980 981void ff_reset_entries(AVCodecContext *avctx) 982{ 983} 984 985void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift) 986{ 987} 988 989void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n) 990{ 991} 992 993#endif 994 995const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p, 996 const uint8_t *end, 997 uint32_t *av_restrict state) 998{ 999 int i; 1000 1001 av_assert0(p <= end); 1002 if (p >= end) 1003 return end; 1004 1005 for (i = 0; i < 3; i++) { 1006 uint32_t tmp = *state << 8; 1007 *state = tmp + *(p++); 1008 if (tmp == 0x100 || p == end) 1009 return p; 1010 } 1011 1012 while (p < end) { 1013 if (p[-1] > 1 ) p += 3; 1014 else if (p[-2] ) p += 2; 1015 else if (p[-3]|(p[-1]-1)) p++; 1016 else { 1017 p++; 1018 break; 1019 } 1020 } 1021 1022 p = FFMIN(p, end) - 4; 1023 *state = AV_RB32(p); 1024 1025 return p + 4; 1026} 1027 1028AVCPBProperties *av_cpb_properties_alloc(size_t *size) 1029{ 1030 AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties)); 1031 if (!props) 1032 return NULL; 1033 1034 if (size) 1035 *size = sizeof(*props); 1036 1037 props->vbv_delay = UINT64_MAX; 1038 1039 return props; 1040} 1041 1042AVCPBProperties *ff_add_cpb_side_data(AVCodecContext *avctx) 1043{ 1044 AVPacketSideData *tmp; 1045 AVCPBProperties *props; 1046 size_t size; 1047 int i; 1048 1049 for (i = 0; i < avctx->nb_coded_side_data; i++) 1050 if (avctx->coded_side_data[i].type == AV_PKT_DATA_CPB_PROPERTIES) 1051 return (AVCPBProperties *)avctx->coded_side_data[i].data; 1052 1053 props = av_cpb_properties_alloc(&size); 1054 if (!props) 1055 return NULL; 1056 1057 tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp)); 1058 if (!tmp) { 1059 av_freep(&props); 1060 return NULL; 1061 } 1062 1063 avctx->coded_side_data = tmp; 1064 avctx->nb_coded_side_data++; 1065 1066 avctx->coded_side_data[avctx->nb_coded_side_data - 1].type = AV_PKT_DATA_CPB_PROPERTIES; 1067 avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props; 1068 avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size; 1069 1070 return props; 1071} 1072 1073static unsigned bcd2uint(uint8_t bcd) 1074{ 1075 unsigned low = bcd & 0xf; 1076 unsigned high = bcd >> 4; 1077 if (low > 9 || high > 9) 1078 return 0; 1079 return low + 10*high; 1080} 1081 1082int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len, 1083 void **data, size_t *sei_size) 1084{ 1085 AVFrameSideData *sd = NULL; 1086 uint8_t *sei_data; 1087 PutBitContext pb; 1088 uint32_t *tc; 1089 int m; 1090 1091 if (frame) 1092 sd = av_frame_get_side_data(frame, AV_FRAME_DATA_S12M_TIMECODE); 1093 1094 if (!sd) { 1095 *data = NULL; 1096 return 0; 1097 } 1098 tc = (uint32_t*)sd->data; 1099 m = tc[0] & 3; 1100 1101 *sei_size = sizeof(uint32_t) * 4; 1102 *data = av_mallocz(*sei_size + prefix_len); 1103 if (!*data) 1104 return AVERROR(ENOMEM); 1105 sei_data = (uint8_t*)*data + prefix_len; 1106 1107 init_put_bits(&pb, sei_data, *sei_size); 1108 put_bits(&pb, 2, m); // num_clock_ts 1109 1110 for (int j = 1; j <= m; j++) { 1111 uint32_t tcsmpte = tc[j]; 1112 unsigned hh = bcd2uint(tcsmpte & 0x3f); // 6-bit hours 1113 unsigned mm = bcd2uint(tcsmpte>>8 & 0x7f); // 7-bit minutes 1114 unsigned ss = bcd2uint(tcsmpte>>16 & 0x7f); // 7-bit seconds 1115 unsigned ff = bcd2uint(tcsmpte>>24 & 0x3f); // 6-bit frames 1116 unsigned drop = tcsmpte & 1<<30 && !0; // 1-bit drop if not arbitrary bit 1117 1118 /* Calculate frame number of HEVC by SMPTE ST 12-1:2014 Sec 12.2 if rate > 30FPS */ 1119 if (av_cmp_q(rate, (AVRational) {30, 1}) == 1) { 1120 unsigned pc; 1121 ff *= 2; 1122 if (av_cmp_q(rate, (AVRational) {50, 1}) == 0) 1123 pc = !!(tcsmpte & 1 << 7); 1124 else 1125 pc = !!(tcsmpte & 1 << 23); 1126 ff = (ff + pc) & 0x7f; 1127 } 1128 1129 put_bits(&pb, 1, 1); // clock_timestamp_flag 1130 put_bits(&pb, 1, 1); // units_field_based_flag 1131 put_bits(&pb, 5, 0); // counting_type 1132 put_bits(&pb, 1, 1); // full_timestamp_flag 1133 put_bits(&pb, 1, 0); // discontinuity_flag 1134 put_bits(&pb, 1, drop); 1135 put_bits(&pb, 9, ff); 1136 put_bits(&pb, 6, ss); 1137 put_bits(&pb, 6, mm); 1138 put_bits(&pb, 5, hh); 1139 put_bits(&pb, 5, 0); 1140 } 1141 flush_put_bits(&pb); 1142 1143 return 0; 1144} 1145 1146int64_t ff_guess_coded_bitrate(AVCodecContext *avctx) 1147{ 1148 AVRational framerate = avctx->framerate; 1149 int bits_per_coded_sample = avctx->bits_per_coded_sample; 1150 int64_t bitrate; 1151 1152 if (!(framerate.num && framerate.den)) 1153 framerate = av_inv_q(avctx->time_base); 1154 if (!(framerate.num && framerate.den)) 1155 return 0; 1156 1157 if (!bits_per_coded_sample) { 1158 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); 1159 bits_per_coded_sample = av_get_bits_per_pixel(desc); 1160 } 1161 bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height * 1162 framerate.num / framerate.den; 1163 1164 return bitrate; 1165} 1166 1167int ff_int_from_list_or_default(void *ctx, const char * val_name, int val, 1168 const int * array_valid_values, int default_value) 1169{ 1170 int i = 0, ref_val; 1171 1172 while (1) { 1173 ref_val = array_valid_values[i]; 1174 if (ref_val == INT_MAX) 1175 break; 1176 if (val == ref_val) 1177 return val; 1178 i++; 1179 } 1180 /* val is not a valid value */ 1181 av_log(ctx, AV_LOG_DEBUG, 1182 "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value); 1183 return default_value; 1184} 1185