avio: make url_open_dyn_packet_buf internal.

It doesn't look fit to be a part of the public API. Adding a temporary hack to ffserver to be able to use it, should be cleaned up when somebody is up for it.

Anton Khirnov committed 15 years ago

Commit 403ee831 parent 6dc7d808 files · +31 −22Browse files

Unified · Split

8 files

ffserver.c +4 −2
libavformat/avio.h +3 −14
libavformat/avio_internal.h +11 −0
libavformat/aviobuf.c +5 −1
libavformat/movenchint.c +2 −1
libavformat/rtpdec.c +1 −1
libavformat/rtpenc_chain.c +2 −1
libavformat/rtspenc.c +3 −2

ffserver.c+4−2

 #include "libavformat/os_support.h"
 #include "libavformat/rtpdec.h"
 #include "libavformat/rtsp.h"
+// XXX for ffio_open_dyn_packet_buffer, to be removed
+#include "libavformat/avio_internal.h"
 #include "libavutil/avstring.h"
 #include "libavutil/lfg.h"
 #include "libavutil/random_seed.h"
                             max_packet_size = RTSP_TCP_MAX_PACKET_SIZE;
                         else
                             max_packet_size = url_get_max_packet_size(c->rtp_handles[c->packet_stream_index]);
-                        ret = url_open_dyn_packet_buf(&ctx->pb, max_packet_size);
+                        ret = ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size);
                     } else {
                         ret = avio_open_dyn_buf(&ctx->pb);
                     }
              c->stream->filename, stream_index, c->protocol);
     /* normally, no packets should be output here, but the packet size may be checked */
-    if (url_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
+    if (ffio_open_dyn_packet_buf(&ctx->pb, max_packet_size) < 0) {
         /* XXX: close stream */
         goto fail;
     }

libavformat/avio.h+3−14

 #endif
 attribute_deprecated void put_flush_packet(AVIOContext *s);
 attribute_deprecated int url_open_dyn_buf(AVIOContext **s);
+attribute_deprecated int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
 attribute_deprecated int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
 /**
  * @}
  */
 int avio_open_dyn_buf(AVIOContext **s);
-/**
- * Open a write only packetized memory stream with a maximum packet
- * size of 'max_packet_size'.  The stream is stored in a memory buffer
- * with a big endian 4 byte header giving the packet size in bytes.
- *
- * @param s new IO context
- * @param max_packet_size maximum packet size (must be > 0)
- * @return zero if no error.
- */
-int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
 /**
  * Return the written size and a pointer to the buffer. The buffer
- * must be freed with av_free(). If the buffer is opened with
+ * must be freed with av_free().
- * avio_open_dyn_buf, then padding of FF_INPUT_BUFFER_PADDING_SIZE is
+ * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
- * added; if opened with url_open_dyn_packet_buf, no padding is added.
  *
  * @param s IO context
  * @param pbuffer pointer to a byte buffer

libavformat/avio_internal.h+11−0

@@ -81,4 +81,15 @@ unsigned long ffio_get_checksum(AVIOContext *s); · 80 unmodified lines
81	unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,	81	unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
82	unsigned int len);	82	unsigned int len);
83		83
		84	/**
		85	* Open a write only packetized memory stream with a maximum packet
		86	* size of 'max_packet_size'. The stream is stored in a memory buffer
		87	* with a big endian 4 byte header giving the packet size in bytes.
		88	*
		89	* @param s new IO context
		90	* @param max_packet_size maximum packet size (must be > 0)
		91	* @return zero if no error.
		92	*/
		93	int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size);
		94
84	#endif // AVFORMAT_AVIO_INTERNAL_H	95	#endif // AVFORMAT_AVIO_INTERNAL_H

libavformat/aviobuf.c+5−1

 {
     return avio_open_dyn_buf(s);
 }
+int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
+{
+    return ffio_open_dyn_packet_buf(s, max_packet_size);
+}
 int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
 {
     return avio_close_dyn_buf(s, pbuffer);
     return url_open_dyn_buf_internal(s, 0);
 }
-int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
+int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
 {
     if (max_packet_size <= 0)
         return -1;

libavformat/movenchint.c+2−1

 #include "libavutil/intreadwrite.h"
 #include "internal.h"
 #include "rtpenc_chain.h"
+#include "avio_internal.h"
 int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
 {
     /* Fetch the output from the RTP muxer, open a new output buffer
      * for next time. */
     size = avio_close_dyn_buf(rtp_ctx->pb, &buf);
-    if ((ret = url_open_dyn_packet_buf(&rtp_ctx->pb,
+    if ((ret = ffio_open_dyn_packet_buf(&rtp_ctx->pb,
                                        RTP_MAX_PACKET_SIZE)) < 0)
         goto done;

libavformat/rtpdec.c+1−1

@@ -41,7 +41,7 @@ · 40 unmodified lines
41	buffer to 'rtp_write_packet' contains all the packets for ONE	41	buffer to 'rtp_write_packet' contains all the packets for ONE
42	frame. Each packet should have a four byte header containing	42	frame. Each packet should have a four byte header containing
43	the length in big endian format (same trick as	43	the length in big endian format (same trick as
44	'url_open_dyn_packet_buf')	44	'ffio_open_dyn_packet_buf')
45	*/	45	*/
46		46
47	static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {	47	static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {

libavformat/rtpenc_chain.c+2−1

 #include "avformat.h"
 #include "rtpenc_chain.h"
+#include "avio_internal.h"
 AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
                                        URLContext *handle, int packet_size)
     if (handle) {
         url_fdopen(&rtpctx->pb, handle);
     } else
-        url_open_dyn_packet_buf(&rtpctx->pb, packet_size);
+        ffio_open_dyn_packet_buf(&rtpctx->pb, packet_size);
     ret = av_write_header(rtpctx);
     if (ret) {

libavformat/rtspenc.c+3−2

 #include "os_support.h"
 #include "rtsp.h"
 #include "internal.h"
+#include "avio_internal.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/avstring.h"
         int id;
         /* The interleaving header is exactly 4 bytes, which happens to be
          * the same size as the packet length header from
-         * url_open_dyn_packet_buf. So by writing the interleaving header
+         * ffio_open_dyn_packet_buf. So by writing the interleaving header
          * over these bytes, we get a consecutive interleaved packet
          * that can be written in one call. */
         interleaved_packet = interleave_header = ptr;
         size -= packet_len;
     }
     av_free(buf);
-    url_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
+    ffio_open_dyn_packet_buf(&rtpctx->pb, RTSP_TCP_MAX_PACKET_SIZE);
     return 0;
 }

avio: make url_open_dyn_packet_buf internal.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code