求教，ffmpeg怎么自定义输出流

lhd666

以前没搞过视频相关的东西，现在需要使用ffmpeg在ceph对象存储上进行转码。ffmpeg自带示例avio_reading.c演示了怎么自定义输入流，我参照它成功从ceph对象存储中读取到数据并解码，但是又该怎么自定义输出流呢？
ffmpeg示例中，也有不使用AVFormatContext，用fwrite()写入AVPacket的示例，那么我只需要把fwrite()替换成rados的写入操作即可，但是不知道avformat_write_header()和av_write_trailer()这两个api写入的数据该怎么使用fwrite()写入，归根结底还是对ffmpeg不熟，网上资料又少。
下面是自定义输入流的代码：

1. struct ceph_handler {
   
2.         rados_t cluster;
   
3.         rados_ioctx_t io;
   
4.         uint64_t off;
   
5.         char *objname;
   
6. };
   
7. 
   
8. struct ceph_handler *ceph_handler_create(const char * const clustername,
   
9.                                const char * const username,
   
10.                                uint64_t flags,
    
11.                                const char * const conf,
    
12.                                const char * const poolname,
    
13.                                const char * const objname)
    
14. {
    
15.         struct ceph_handler *handler;
    
16.         int err;
    
17. 
    
18.         handler = malloc(sizeof(*handler));
    
19.         if (!handler)
    
20.                 return NULL;
    
21. 
    
22.         err = rados_create2(&handler->cluster, clustername, username, flags);
    
23.         if (err < 0) {
    
24.                 free(handler);
    
25.                 return NULL;
    
26.         }
    
27. 
    
28.         err = rados_conf_read_file(handler->cluster, conf);
    
29.         if (err < 0) {
    
30.                 rados_shutdown(handler->cluster);
    
31.                 free(handler);
    
32.                 return NULL;
    
33.         }
    
34. 
    
35.         err = rados_connect(handler->cluster);
    
36.         if (err < 0) {
    
37.                 rados_shutdown(handler->cluster);
    
38.                 free(handler);
    
39.                 return NULL;
    
40.         }
    
41. 
    
42.         err = rados_ioctx_create(handler->cluster, poolname, &handler->io);
    
43.         if (err < 0) {
    
44.                 rados_shutdown(handler->cluster);
    
45.                 free(handler);
    
46.                 return NULL;
    
47.         }
    
48. 
    
49.         handler->objname = strdup(objname);
    
50.         if (!handler->objname) {
    
51.                 rados_ioctx_destroy(handler->io);
    
52.                 rados_shutdown(handler->cluster);
    
53.                 free(handler);
    
54.                 return NULL;
    
55.         }
    
56. 
    
57.         handler->off = 0;
    
58. 
    
59.         return handler;
    
60. }
    
61. 
    
62. void ceph_handler_destroy(struct ceph_handler *handler)
    
63. {
    
64.         rados_ioctx_destroy(handler->io);
    
65.         rados_shutdown(handler->cluster);
    
66.         free(handler->objname);
    
67.         free(handler);
    
68. }
    
69. 
    
70. static int read_packet(void *opaque, uint8_t *buf, int buf_size)
    
71. {
    
72.         struct ceph_handler *handler = opaque;
    
73.         int nr;
    
74. 
    
75.         nr = rados_read(handler->io, handler->objname, (char *)buf, buf_size, handler->off);
    
76.         if (nr < 0)
    
77.                 errno = -nr;
    
78.         else
    
79.                 handler->off += nr;
    
80. 
    
81.         return nr;
    
82. }
    
83. 
    
84. static int write_packet(void *opaque, uint8_t *buf, int buf_size)
    
85. {
    
86.         struct ceph_handler *handler = opaque;
    
87.         int err;
    
88. 
    
89.         /* 成功时返回0，而非写入字节数 */
    
90.         err = rados_write(handler->io, handler->objname, (char *)buf, buf_size, handler->off);
    
91.         if (err)
    
92.                 errno = - err;
    
93.         else
    
94.                 handler->off += buf_size;
    
95. 
    
96.         return err ? err : buf_size;
    
97. }
    
98. 
    
99. static int64_t seek(void *opaque, int64_t offset, int whence)
    
100. {
     
101.         struct ceph_handler *handler = opaque;
     
102.         uint64_t size;
     
103.         time_t mtime;
     
104.         int err;
     
105. 
     
106.         switch (whence) {
     
107.         case SEEK_SET:
     
108.                 handler->off = offset;
     
109.                 break;
     
110. 
     
111.         case SEEK_CUR:
     
112.                 handler->off += offset;
     
113.                 break;
     
114. 
     
115.         case SEEK_END:
     
116.                 err = rados_stat(handler->io, handler->objname, &size, &mtime);
     
117.                 if (err < 0) {
     
118.                         errno = - err;
     
119.                         return -1;
     
120.                 }
     
121.                 if (size < offset)
     
122.                         handler->off = 0;
     
123.                 else
     
124.                         handler->off = size - offset;
     
125.         }
     
126. 
     
127.         return handler->off;
     
128. }
     
129. 
     
130. static int open_input_file(const char *filename)
     
131. {
     
132.         AVIOContext *avio_ctx = NULL;
     
133.         uint8_t *avio_ctx_buffer = NULL;
     
134.         size_t avio_ctx_buffer_size = 1 << 2;
     
135.         struct ceph_handler *handler = NULL;
     
136.         unsigned int i;
     
137.         int ret;
     
138. 
     
139.         ifmt_ctx = NULL;
     
140.         
     
141.         handler = ceph_handler_create("ceph", "client.admin", 0,
     
142.                                       "ceph.conf", "mypool", filename);
     
143.         if (!handler)
     
144.                 return -1;
     
145. 
     
146.         ifmt_ctx = avformat_alloc_context();
     
147.         if (!ifmt_ctx)
     
148.                 goto err;
     
149. 
     
150.         avio_ctx_buffer = av_malloc(avio_ctx_buffer_size);
     
151.         if (!avio_ctx_buffer)
     
152.                 goto err;
     
153. 
     
154.         avio_ctx = avio_alloc_context(avio_ctx_buffer, avio_ctx_buffer_size,
     
155.                                       0, handler, read_packet, write_packet,
     
156.                                       seek);
     
157.         if (!avio_ctx)
     
158.                 goto err;
     
159.         ifmt_ctx->pb = avio_ctx;
     
160. 
     
161.         ret = avformat_open_input(&ifmt_ctx, NULL, NULL, NULL);
     
162.         if (ret < 0)
     
163.                 goto err;
     
164. 
     
165.         ret = avformat_find_stream_info(ifmt_ctx, NULL);
     
166.         if (ret < 0)
     
167.                 goto err;
     
168. 
     
169.         for (i = 0; i < ifmt_ctx->nb_streams; i++) {
     
170.                 AVStream *stream;
     
171.                 AVCodecContext *codec_ctx;
     
172.                 stream = ifmt_ctx->streams[i];
     
173.                 codec_ctx = stream->codec;
     
174.                 /* Reencode video & audio and remux subtitles etc. */
     
175.                 if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
     
176.                     codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
     
177.                         /* Open decoder */
     
178.                         ret = avcodec_open2(codec_ctx,
     
179.                                             avcodec_find_decoder(codec_ctx->codec_id), NULL);
     
180.                         if (ret < 0)
     
181.                                 goto err;
     
182.                 }
     
183.         }
     
184. 
     
185.         
     
186.         av_dump_format(ifmt_ctx, 0, filename, 0);
     
187.         return 0;
     
188. 
     
189. err:
     
190.         if (ifmt_ctx)
     
191.                 avformat_close_input(&ifmt_ctx);
     
192.         ifmt_ctx = NULL;
     
193.         if (handler)
     
194.                 ceph_handler_destroy(handler);
     
195.         if (avio_ctx) {
     
196.                 av_freep(&avio_ctx->buffer);
     
197.                 av_freep(&avio_ctx);
     
198.         }
     
199. 
     
200.         return -1;
     
201. }

复制代码

lhd666

找方法了，在学习雷大的教程的时候，看到了相关介绍：http://blog.csdn.net/leixiaohua1020/article/details/39759623
和读的方法很相似，但是注意必须提供seek和write，否则有的视频编码会失败。看来ffmpeg没举输出流的例子，是觉得没有必要，归根结底还是自身水平太低，需要不断学习、练习和归纳总结