1 /* 2 * copyright (c) 2001 Fabrice Bellard 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 #ifndef AVFORMAT_INTERNAL_H 22 #define AVFORMAT_INTERNAL_H 23 24 #include <stdint.h> 25 26 #include "libavutil/bprint.h" 27 #include "avformat.h" 28 #include "os_support.h" 29 30 #define MAX_URL_SIZE 4096 31 32 /** size of probe buffer, for guessing file type from file contents */ 33 #define PROBE_BUF_MIN 2048 34 #define PROBE_BUF_MAX (1 << 20) 35 36 #ifdef DEBUG 37 # define hex_dump_debug(class, buf, size) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size) 38 #else 39 # define hex_dump_debug(class, buf, size) do { if (0) av_hex_dump_log(class, AV_LOG_DEBUG, buf, size); } while(0) 40 #endif 41 42 typedef struct AVCodecTag { 43 enum AVCodecID id; 44 unsigned int tag; 45 } AVCodecTag; 46 47 typedef struct CodecMime{ 48 char str[32]; 49 enum AVCodecID id; 50 } CodecMime; 51 52 /*************************************************/ 53 /* fractional numbers for exact pts handling */ 54 55 /** 56 * The exact value of the fractional number is: 'val + num / den'. 57 * num is assumed to be 0 <= num < den. 58 */ 59 typedef struct FFFrac { 60 int64_t val, num, den; 61 } FFFrac; 62 63 64 struct AVFormatInternal { 65 /** 66 * Number of streams relevant for interleaving. 67 * Muxing only. 68 */ 69 int nb_interleaved_streams; 70 71 /** 72 * This buffer is only needed when packets were already buffered but 73 * not decoded, for example to get the codec parameters in MPEG 74 * streams. 75 */ 76 struct PacketList *packet_buffer; 77 struct PacketList *packet_buffer_end; 78 79 /* av_seek_frame() support */ 80 int64_t data_offset; /**< offset of the first packet */ 81 82 /** 83 * Raw packets from the demuxer, prior to parsing and decoding. 84 * This buffer is used for buffering packets until the codec can 85 * be identified, as parsing cannot be done without knowing the 86 * codec. 87 */ 88 struct PacketList *raw_packet_buffer; 89 struct PacketList *raw_packet_buffer_end; 90 /** 91 * Packets split by the parser get queued here. 92 */ 93 AVPacket *parse_pkt; 94 struct PacketList *parse_queue; 95 struct PacketList *parse_queue_end; 96 97 /** 98 * Used to hold temporary packets. 99 */ 100 AVPacket *pkt; 101 /** 102 * Remaining size available for raw_packet_buffer, in bytes. 103 */ 104 #define RAW_PACKET_BUFFER_SIZE 2500000 105 int raw_packet_buffer_remaining_size; 106 107 /** 108 * Offset to remap timestamps to be non-negative. 109 * Expressed in timebase units. 110 * @see AVStream.mux_ts_offset 111 */ 112 int64_t offset; 113 114 /** 115 * Timebase for the timestamp offset. 116 */ 117 AVRational offset_timebase; 118 119 #if FF_API_COMPUTE_PKT_FIELDS2 120 int missing_ts_warning; 121 #endif 122 123 int inject_global_side_data; 124 125 int avoid_negative_ts_use_pts; 126 127 /** 128 * Timestamp of the end of the shortest stream. 129 */ 130 int64_t shortest_end; 131 132 /** 133 * Whether or not avformat_init_output has already been called 134 */ 135 int initialized; 136 137 /** 138 * Whether or not avformat_init_output fully initialized streams 139 */ 140 int streams_initialized; 141 142 /** 143 * ID3v2 tag useful for MP3 demuxing 144 */ 145 AVDictionary *id3v2_meta; 146 147 /* 148 * Prefer the codec framerate for avg_frame_rate computation. 149 */ 150 int prefer_codec_framerate; 151 152 /** 153 * Set if chapter ids are strictly monotonic. 154 */ 155 int chapter_ids_monotonic; 156 }; 157 158 struct AVStreamInternal { 159 /** 160 * Set to 1 if the codec allows reordering, so pts can be different 161 * from dts. 162 */ 163 int reorder; 164 165 /** 166 * bitstream filter to run on stream 167 * - encoding: Set by muxer using ff_stream_add_bitstream_filter 168 * - decoding: unused 169 */ 170 AVBSFContext *bsfc; 171 172 /** 173 * Whether or not check_bitstream should still be run on each packet 174 */ 175 int bitstream_checked; 176 177 /** 178 * The codec context used by avformat_find_stream_info, the parser, etc. 179 */ 180 AVCodecContext *avctx; 181 /** 182 * 1 if avctx has been initialized with the values from the codec parameters 183 */ 184 int avctx_inited; 185 186 enum AVCodecID orig_codec_id; 187 188 /* the context for extracting extradata in find_stream_info() 189 * inited=1/bsf=NULL signals that extracting is not possible (codec not 190 * supported) */ 191 struct { 192 AVBSFContext *bsf; 193 AVPacket *pkt; 194 int inited; 195 } extract_extradata; 196 197 /** 198 * Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar) 199 */ 200 int need_context_update; 201 202 int is_intra_only; 203 204 FFFrac *priv_pts; 205 206 #define MAX_STD_TIMEBASES (30*12+30+3+6) 207 /** 208 * Stream information used internally by avformat_find_stream_info() 209 */ 210 struct { 211 int64_t last_dts; 212 int64_t duration_gcd; 213 int duration_count; 214 int64_t rfps_duration_sum; 215 double (*duration_error)[2][MAX_STD_TIMEBASES]; 216 int64_t codec_info_duration; 217 int64_t codec_info_duration_fields; 218 int frame_delay_evidence; 219 220 /** 221 * 0 -> decoder has not been searched for yet. 222 * >0 -> decoder found 223 * <0 -> decoder with codec_id == -found_decoder has not been found 224 */ 225 int found_decoder; 226 227 int64_t last_duration; 228 229 /** 230 * Those are used for average framerate estimation. 231 */ 232 int64_t fps_first_dts; 233 int fps_first_dts_idx; 234 int64_t fps_last_dts; 235 int fps_last_dts_idx; 236 237 } *info; 238 239 int64_t interleaver_chunk_size; 240 int64_t interleaver_chunk_duration; 241 242 /** 243 * stream probing state 244 * -1 -> probing finished 245 * 0 -> no probing requested 246 * rest -> perform probing with request_probe being the minimum score to accept. 247 */ 248 int request_probe; 249 /** 250 * Indicates that everything up to the next keyframe 251 * should be discarded. 252 */ 253 int skip_to_keyframe; 254 255 /** 256 * Number of samples to skip at the start of the frame decoded from the next packet. 257 */ 258 int skip_samples; 259 260 /** 261 * If not 0, the number of samples that should be skipped from the start of 262 * the stream (the samples are removed from packets with pts==0, which also 263 * assumes negative timestamps do not happen). 264 * Intended for use with formats such as mp3 with ad-hoc gapless audio 265 * support. 266 */ 267 int64_t start_skip_samples; 268 269 /** 270 * If not 0, the first audio sample that should be discarded from the stream. 271 * This is broken by design (needs global sample count), but can't be 272 * avoided for broken by design formats such as mp3 with ad-hoc gapless 273 * audio support. 274 */ 275 int64_t first_discard_sample; 276 277 /** 278 * The sample after last sample that is intended to be discarded after 279 * first_discard_sample. Works on frame boundaries only. Used to prevent 280 * early EOF if the gapless info is broken (considered concatenated mp3s). 281 */ 282 int64_t last_discard_sample; 283 284 /** 285 * Number of internally decoded frames, used internally in libavformat, do not access 286 * its lifetime differs from info which is why it is not in that structure. 287 */ 288 int nb_decoded_frames; 289 290 /** 291 * Timestamp offset added to timestamps before muxing 292 */ 293 int64_t mux_ts_offset; 294 295 /** 296 * Internal data to check for wrapping of the time stamp 297 */ 298 int64_t pts_wrap_reference; 299 300 /** 301 * Options for behavior, when a wrap is detected. 302 * 303 * Defined by AV_PTS_WRAP_ values. 304 * 305 * If correction is enabled, there are two possibilities: 306 * If the first time stamp is near the wrap point, the wrap offset 307 * will be subtracted, which will create negative time stamps. 308 * Otherwise the offset will be added. 309 */ 310 int pts_wrap_behavior; 311 312 /** 313 * Internal data to prevent doing update_initial_durations() twice 314 */ 315 int update_initial_durations_done; 316 317 #define MAX_REORDER_DELAY 16 318 319 /** 320 * Internal data to generate dts from pts 321 */ 322 int64_t pts_reorder_error[MAX_REORDER_DELAY+1]; 323 uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1]; 324 325 int64_t pts_buffer[MAX_REORDER_DELAY+1]; 326 327 /** 328 * Internal data to analyze DTS and detect faulty mpeg streams 329 */ 330 int64_t last_dts_for_order_check; 331 uint8_t dts_ordered; 332 uint8_t dts_misordered; 333 334 /** 335 * Internal data to inject global side data 336 */ 337 int inject_global_side_data; 338 339 /** 340 * display aspect ratio (0 if unknown) 341 * - encoding: unused 342 * - decoding: Set by libavformat to calculate sample_aspect_ratio internally 343 */ 344 AVRational display_aspect_ratio; 345 346 AVProbeData probe_data; 347 348 /** 349 * last packet in packet_buffer for this stream when muxing. 350 */ 351 struct PacketList *last_in_packet_buffer; 352 }; 353 354 #ifdef __GNUC__ 355 #define dynarray_add(tab, nb_ptr, elem)\ 356 do {\ 357 __typeof__(tab) _tab = (tab);\ 358 __typeof__(elem) _elem = (elem);\ 359 (void)sizeof(**_tab == _elem); /* check that types are compatible */\ 360 av_dynarray_add(_tab, nb_ptr, _elem);\ 361 } while(0) 362 #else 363 #define dynarray_add(tab, nb_ptr, elem)\ 364 do {\ 365 av_dynarray_add((tab), nb_ptr, (elem));\ 366 } while(0) 367 #endif 368 369 /** 370 * Automatically create sub-directories 371 * 372 * @param path will create sub-directories by path 373 * @return 0, or < 0 on error 374 */ 375 int ff_mkdir_p(const char *path); 376 377 char *ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase); 378 379 /** 380 * Parse a string of hexadecimal strings. Any space between the hexadecimal 381 * digits is ignored. 382 * 383 * @param data if non-null, the parsed data is written to this pointer 384 * @param p the string to parse 385 * @return the number of bytes written (or to be written, if data is null) 386 */ 387 int ff_hex_to_data(uint8_t *data, const char *p); 388 389 /** 390 * Add packet to an AVFormatContext's packet_buffer list, determining its 391 * interleaved position using compare() function argument. 392 * @return 0 on success, < 0 on error. pkt will always be blank on return. 393 */ 394 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, 395 int (*compare)(AVFormatContext *, const AVPacket *, const AVPacket *)); 396 397 void ff_read_frame_flush(AVFormatContext *s); 398 399 #define NTP_OFFSET 2208988800ULL 400 #define NTP_OFFSET_US (NTP_OFFSET * 1000000ULL) 401 402 /** Get the current time since NTP epoch in microseconds. */ 403 uint64_t ff_ntp_time(void); 404 405 /** 406 * Get the NTP time stamp formatted as per the RFC-5905. 407 * 408 * @param ntp_time NTP time in micro seconds (since NTP epoch) 409 * @return the formatted NTP time stamp 410 */ 411 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us); 412 413 /** 414 * Append the media-specific SDP fragment for the media stream c 415 * to the buffer buff. 416 * 417 * Note, the buffer needs to be initialized, since it is appended to 418 * existing content. 419 * 420 * @param buff the buffer to append the SDP fragment to 421 * @param size the size of the buff buffer 422 * @param st the AVStream of the media to describe 423 * @param idx the global stream index 424 * @param dest_addr the destination address of the media stream, may be NULL 425 * @param dest_type the destination address type, may be NULL 426 * @param port the destination port of the media stream, 0 if unknown 427 * @param ttl the time to live of the stream, 0 if not multicast 428 * @param fmt the AVFormatContext, which might contain options modifying 429 * the generated SDP 430 */ 431 void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx, 432 const char *dest_addr, const char *dest_type, 433 int port, int ttl, AVFormatContext *fmt); 434 435 /** 436 * Write a packet to another muxer than the one the user originally 437 * intended. Useful when chaining muxers, where one muxer internally 438 * writes a received packet to another muxer. 439 * 440 * @param dst the muxer to write the packet to 441 * @param dst_stream the stream index within dst to write the packet to 442 * @param pkt the packet to be written 443 * @param src the muxer the packet originally was intended for 444 * @param interleave 0->use av_write_frame, 1->av_interleaved_write_frame 445 * @return the value av_write_frame returned 446 */ 447 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, 448 AVFormatContext *src, int interleave); 449 450 /** 451 * Read a whole line of text from AVIOContext. Stop reading after reaching 452 * either a \\n, a \\0 or EOF. The returned string is always \\0-terminated, 453 * and may be truncated if the buffer is too small. 454 * 455 * @param s the read-only AVIOContext 456 * @param buf buffer to store the read line 457 * @param maxlen size of the buffer 458 * @return the length of the string written in the buffer, not including the 459 * final \\0 460 */ 461 int ff_get_line(AVIOContext *s, char *buf, int maxlen); 462 463 /** 464 * Same as ff_get_line but strip the white-space characters in the text tail 465 * 466 * @param s the read-only AVIOContext 467 * @param buf buffer to store the read line 468 * @param maxlen size of the buffer 469 * @return the length of the string written in the buffer 470 */ 471 int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen); 472 473 /** 474 * Read a whole line of text from AVIOContext to an AVBPrint buffer. Stop 475 * reading after reaching a \\r, a \\n, a \\r\\n, a \\0 or EOF. The line 476 * ending characters are NOT included in the buffer, but they are skipped on 477 * the input. 478 * 479 * @param s the read-only AVIOContext 480 * @param bp the AVBPrint buffer 481 * @return the length of the read line, not including the line endings, 482 * negative on error. 483 */ 484 int64_t ff_read_line_to_bprint(AVIOContext *s, AVBPrint *bp); 485 486 /** 487 * Read a whole line of text from AVIOContext to an AVBPrint buffer overwriting 488 * its contents. Stop reading after reaching a \\r, a \\n, a \\r\\n, a \\0 or 489 * EOF. The line ending characters are NOT included in the buffer, but they 490 * are skipped on the input. 491 * 492 * @param s the read-only AVIOContext 493 * @param bp the AVBPrint buffer 494 * @return the length of the read line not including the line endings, 495 * negative on error, or if the buffer becomes truncated. 496 */ 497 int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, AVBPrint *bp); 498 499 #define SPACE_CHARS " \t\r\n" 500 501 /** 502 * Callback function type for ff_parse_key_value. 503 * 504 * @param key a pointer to the key 505 * @param key_len the number of bytes that belong to the key, including the '=' 506 * char 507 * @param dest return the destination pointer for the value in *dest, may 508 * be null to ignore the value 509 * @param dest_len the length of the *dest buffer 510 */ 511 typedef void (*ff_parse_key_val_cb)(void *context, const char *key, 512 int key_len, char **dest, int *dest_len); 513 /** 514 * Parse a string with comma-separated key=value pairs. The value strings 515 * may be quoted and may contain escaped characters within quoted strings. 516 * 517 * @param str the string to parse 518 * @param callback_get_buf function that returns where to store the 519 * unescaped value string. 520 * @param context the opaque context pointer to pass to callback_get_buf 521 */ 522 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, 523 void *context); 524 525 /** 526 * Find stream index based on format-specific stream ID 527 * @return stream index, or < 0 on error 528 */ 529 int ff_find_stream_index(AVFormatContext *s, int id); 530 531 /** 532 * Internal version of av_index_search_timestamp 533 */ 534 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, 535 int64_t wanted_timestamp, int flags); 536 537 /** 538 * Internal version of av_add_index_entry 539 */ 540 int ff_add_index_entry(AVIndexEntry **index_entries, 541 int *nb_index_entries, 542 unsigned int *index_entries_allocated_size, 543 int64_t pos, int64_t timestamp, int size, int distance, int flags); 544 545 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance); 546 547 /** 548 * Add a new chapter. 549 * 550 * @param s media file handle 551 * @param id unique ID for this chapter 552 * @param start chapter start time in time_base units 553 * @param end chapter end time in time_base units 554 * @param title chapter title 555 * 556 * @return AVChapter or NULL on error 557 */ 558 #if FF_API_CHAPTER_ID_INT 559 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, 560 #else 561 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, 562 #endif 563 int64_t start, int64_t end, const char *title); 564 565 /** 566 * Ensure the index uses less memory than the maximum specified in 567 * AVFormatContext.max_index_size by discarding entries if it grows 568 * too large. 569 */ 570 void ff_reduce_index(AVFormatContext *s, int stream_index); 571 572 enum AVCodecID ff_guess_image2_codec(const char *filename); 573 574 /** 575 * Perform a binary search using av_index_search_timestamp() and 576 * AVInputFormat.read_timestamp(). 577 * 578 * @param target_ts target timestamp in the time base of the given stream 579 * @param stream_index stream number 580 */ 581 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, 582 int64_t target_ts, int flags); 583 584 /** 585 * Update cur_dts of all streams based on the given timestamp and AVStream. 586 * 587 * Stream ref_st unchanged, others set cur_dts in their native time base. 588 * Only needed for timestamp wrapping or if (dts not set and pts!=dts). 589 * @param timestamp new dts expressed in time_base of param ref_st 590 * @param ref_st reference stream giving time_base of param timestamp 591 */ 592 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp); 593 594 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos, 595 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )); 596 597 /** 598 * Perform a binary search using read_timestamp(). 599 * 600 * @param target_ts target timestamp in the time base of the given stream 601 * @param stream_index stream number 602 */ 603 int64_t ff_gen_search(AVFormatContext *s, int stream_index, 604 int64_t target_ts, int64_t pos_min, 605 int64_t pos_max, int64_t pos_limit, 606 int64_t ts_min, int64_t ts_max, 607 int flags, int64_t *ts_ret, 608 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )); 609 610 /** 611 * Set the time base and wrapping info for a given stream. This will be used 612 * to interpret the stream's timestamps. If the new time base is invalid 613 * (numerator or denominator are non-positive), it leaves the stream 614 * unchanged. 615 * 616 * @param s stream 617 * @param pts_wrap_bits number of bits effectively used by the pts 618 * (used for wrap control) 619 * @param pts_num time base numerator 620 * @param pts_den time base denominator 621 */ 622 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, 623 unsigned int pts_num, unsigned int pts_den); 624 625 /** 626 * Add side data to a packet for changing parameters to the given values. 627 * Parameters set to 0 aren't included in the change. 628 */ 629 int ff_add_param_change(AVPacket *pkt, int32_t channels, 630 uint64_t channel_layout, int32_t sample_rate, 631 int32_t width, int32_t height); 632 633 /** 634 * Set the timebase for each stream from the corresponding codec timebase and 635 * print it. 636 */ 637 int ff_framehash_write_header(AVFormatContext *s); 638 639 /** 640 * Read a transport packet from a media file. 641 * 642 * @param s media file handle 643 * @param pkt is filled 644 * @return 0 if OK, AVERROR_xxx on error 645 */ 646 int ff_read_packet(AVFormatContext *s, AVPacket *pkt); 647 648 /** 649 * Interleave an AVPacket per dts so it can be muxed. 650 * 651 * @param s an AVFormatContext for output. pkt resp. out will be added to 652 * resp. taken from its packet buffer. 653 * @param out the interleaved packet will be output here 654 * @param pkt the input packet; will be blank on return if not NULL 655 * @param flush 1 if no further packets are available as input and all 656 * remaining packets should be output 657 * @return 1 if a packet was output, 0 if no packet could be output 658 * (in which case out may be uninitialized), < 0 if an error occurred 659 */ 660 int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, 661 AVPacket *pkt, int flush); 662 663 void ff_free_stream(AVFormatContext *s, AVStream *st); 664 665 /** 666 * Return the frame duration in seconds. Return 0 if not available. 667 */ 668 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st, 669 AVCodecParserContext *pc, AVPacket *pkt); 670 671 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id); 672 673 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag); 674 675 int ff_is_intra_only(enum AVCodecID id); 676 677 /** 678 * Select a PCM codec based on the given parameters. 679 * 680 * @param bps bits-per-sample 681 * @param flt floating-point 682 * @param be big-endian 683 * @param sflags signed flags. each bit corresponds to one byte of bit depth. 684 * e.g. the 1st bit indicates if 8-bit should be signed or 685 * unsigned, the 2nd bit indicates if 16-bit should be signed or 686 * unsigned, etc... This is useful for formats such as WAVE where 687 * only 8-bit is unsigned and all other bit depths are signed. 688 * @return a PCM codec id or AV_CODEC_ID_NONE 689 */ 690 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags); 691 692 /** 693 * Chooses a timebase for muxing the specified stream. 694 * 695 * The chosen timebase allows sample accurate timestamps based 696 * on the framerate or sample rate for audio streams. It also is 697 * at least as precise as 1/min_precision would be. 698 */ 699 AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precision); 700 701 /** 702 * Chooses a timebase for muxing the specified stream. 703 */ 704 enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st); 705 706 /** 707 * Generate standard extradata for AVC-Intra based on width/height and field 708 * order. 709 */ 710 int ff_generate_avci_extradata(AVStream *st); 711 712 /** 713 * Add a bitstream filter to a stream. 714 * 715 * @param st output stream to add a filter to 716 * @param name the name of the filter to add 717 * @param args filter-specific argument string 718 * @return >0 on success; 719 * AVERROR code on failure 720 */ 721 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args); 722 723 /** 724 * Copy encoding parameters from source to destination stream 725 * 726 * @param dst pointer to destination AVStream 727 * @param src pointer to source AVStream 728 * @return >=0 on success, AVERROR code on error 729 */ 730 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src); 731 732 /** 733 * Wrap avpriv_io_move and log if error happens. 734 * 735 * @param url_src source path 736 * @param url_dst destination path 737 * @return 0 or AVERROR on failure 738 */ 739 int ff_rename(const char *url_src, const char *url_dst, void *logctx); 740 741 /** 742 * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end 743 * which is always set to 0. 744 * 745 * Previously allocated extradata in par will be freed. 746 * 747 * @param size size of extradata 748 * @return 0 if OK, AVERROR_xxx on error 749 */ 750 int ff_alloc_extradata(AVCodecParameters *par, int size); 751 752 /** 753 * Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end 754 * which is always set to 0 and fill it from pb. 755 * 756 * @param size size of extradata 757 * @return >= 0 if OK, AVERROR_xxx on error 758 */ 759 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size); 760 761 /** 762 * add frame for rfps calculation. 763 * 764 * @param dts timestamp of the i-th frame 765 * @return 0 if OK, AVERROR_xxx on error 766 */ 767 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t dts); 768 769 void ff_rfps_calculate(AVFormatContext *ic); 770 771 /** 772 * Flags for AVFormatContext.write_uncoded_frame() 773 */ 774 enum AVWriteUncodedFrameFlags { 775 776 /** 777 * Query whether the feature is possible on this stream. 778 * The frame argument is ignored. 779 */ 780 AV_WRITE_UNCODED_FRAME_QUERY = 0x0001, 781 782 }; 783 784 /** 785 * Copies the whilelists from one context to the other 786 */ 787 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src); 788 789 /** 790 * Returned by demuxers to indicate that data was consumed but discarded 791 * (ignored streams or junk data). The framework will re-call the demuxer. 792 */ 793 #define FFERROR_REDO FFERRTAG('R','E','D','O') 794 795 /** 796 * Utility function to open IO stream of output format. 797 * 798 * @param s AVFormatContext 799 * @param url URL or file name to open for writing 800 * @options optional options which will be passed to io_open callback 801 * @return >=0 on success, negative AVERROR in case of failure 802 */ 803 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options); 804 805 /* 806 * A wrapper around AVFormatContext.io_close that should be used 807 * instead of calling the pointer directly. 808 */ 809 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb); 810 811 /** 812 * Utility function to check if the file uses http or https protocol 813 * 814 * @param s AVFormatContext 815 * @param filename URL or file name to open for writing 816 */ 817 int ff_is_http_proto(char *filename); 818 819 /** 820 * Parse creation_time in AVFormatContext metadata if exists and warn if the 821 * parsing fails. 822 * 823 * @param s AVFormatContext 824 * @param timestamp parsed timestamp in microseconds, only set on successful parsing 825 * @param return_seconds set this to get the number of seconds in timestamp instead of microseconds 826 * @return 1 if OK, 0 if the metadata was not present, AVERROR(EINVAL) on parse error 827 */ 828 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds); 829 830 /** 831 * Standardize creation_time metadata in AVFormatContext to an ISO-8601 832 * timestamp string. 833 * 834 * @param s AVFormatContext 835 * @return <0 on error 836 */ 837 int ff_standardize_creation_time(AVFormatContext *s); 838 839 #define CONTAINS_PAL 2 840 /** 841 * Reshuffles the lines to use the user specified stride. 842 * 843 * @param ppkt input and output packet 844 * @return negative error code or 845 * 0 if no new packet was allocated 846 * non-zero if a new packet was allocated and ppkt has to be freed 847 * CONTAINS_PAL if in addition to a new packet the old contained a palette 848 */ 849 int ff_reshuffle_raw_rgb(AVFormatContext *s, AVPacket **ppkt, AVCodecParameters *par, int expected_stride); 850 851 /** 852 * Retrieves the palette from a packet, either from side data, or 853 * appended to the video data in the packet itself (raw video only). 854 * It is commonly used after a call to ff_reshuffle_raw_rgb(). 855 * 856 * Use 0 for the ret parameter to check for side data only. 857 * 858 * @param pkt pointer to packet before calling ff_reshuffle_raw_rgb() 859 * @param ret return value from ff_reshuffle_raw_rgb(), or 0 860 * @param palette pointer to palette buffer 861 * @return negative error code or 862 * 1 if the packet has a palette, else 0 863 */ 864 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette); 865 866 /** 867 * Finalize buf into extradata and set its size appropriately. 868 */ 869 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf); 870 871 /** 872 * Find the next packet in the interleaving queue for the given stream. 873 * 874 * @return a pointer to a packet if one was found, NULL otherwise. 875 */ 876 const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream); 877 878 int ff_get_muxer_ts_offset(AVFormatContext *s, int stream_index, int64_t *offset); 879 880 int ff_lock_avformat(void); 881 int ff_unlock_avformat(void); 882 883 /** 884 * Set AVFormatContext url field to the provided pointer. The pointer must 885 * point to a valid string. The existing url field is freed if necessary. Also 886 * set the legacy filename field to the same string which was provided in url. 887 */ 888 void ff_format_set_url(AVFormatContext *s, char *url); 889 890 void avpriv_register_devices(const AVOutputFormat * const o[], const AVInputFormat * const i[]); 891 892 #endif /* AVFORMAT_INTERNAL_H */ 893