Почему av_write_frame в FFmpeg такой медленный???

There are a few possible reasons why av_write_frame can be slow in this code:

1. Buffering - By default, avformat uses buffering for writes which can delay actual writes to disk. You can disable buffering by passing AVIO_FLAG_DIRECT to avio_open. This will write packets directly without buffering.

2. Flush latency - Even with buffering disabled, it takes time for data to make it from the application to the disk. Calling av_write_frame does not necessarily mean the data has been written to disk yet. You may need to call av_write_trailer to flush all buffered data.

3. Disk speed - The disk where the file is being written may simply be slow, which limits the write speed. Using a faster disk can improve performance.

4. Format overhead - Some formats require additional processing that can slow down writes. For example, formats that require seeking (like MP4) may be slower than simpler formats (like FLV).

5. Threading - av_write_frame is not thread-safe. If you are calling it from multiple threads, the threads can interfere with each other and reduce performance.

Some things you can try to improve write speed:

1. Disable buffering by passing AVIO_FLAG_DIRECT to avio_open.

2. Call av_write_trailer periodically to flush buffered data.

3. Use a faster disk or SSD. 

4. Choose a simpler format like FLV over MP4.

5. Ensure av_write_frame is only called from a single thread.

I hope this helps explain some possible reasons for the slow writes and gives you some ideas to try and improve the performance. Let me know if you have any other questions!

There are a few possible reasons for slow upload speed in this code:

1. Fragmentation - The code splits input JPEG frames into multiple packets, creating overhead from packet headers. This can slow down the upload.

2. Timestamp accuracy - The code uses millisecond timestamps (converted to AVPacket timestamps), which have limited accuracy. This can cause AVFormatContext to pad packets to achieve better accuracy, reducing effective payload size.

3. CPU load - The code is doing a lot of JPEG parsing, buffer copying and other operations on the CPU. This can overload the CPU and slow down the actual network upload.

4. Network buffering - The network stack may be buffering the outgoing packets, causing bursts of fast upload followed by longer pauses. This can average out to slower overall speed.

5. Inefficient I/O - The code is reading from a file on disk. File I/O has more overhead than in-memory I/O, which can impact performance.

Some potential fixes could be:

• Reduce fragmentation by encoding JPEG frames into fewer, larger packets. 
• Use a larger timebase for timestamps (e.g. milliseconds instead of micro seconds) to reduce padding. 
• Offload some CPU-intensive work to other cores or optimize the JPEG parsing. 
• Flush the network buffer periodically to send packets more consistently. 
• Read from memory instead of a file, if possible. 

Without seeing more details on the specific implementation and environment, it's hard to determine the exact cause and solution. But the above points should give some ideas to try improving the upload speed.