root/OpenSceneGraph/trunk/src/osgPlugins/ffmpeg/FFmpegDecoderVideo.cpp @ 9854

Revision 9854, 8.6 kB (checked in by robert, 5 years ago)

Added support for using libswscale

RevLine 
[9816]1#include "FFmpegDecoderVideo.hpp"
2
3#include <osg/Notify>
4
5#include <stdexcept>
6#include <string.h>
7
[9854]8#if 0
[9837]9extern "C" 
10{
11    int img_convert(AVPicture *dst, int dst_pix_fmt, const AVPicture *src,
12                int src_pix_fmt, int src_width, int src_height);
[9816]13
[9837]14};
[9854]15#endif
[9816]16
17namespace osgFFmpeg {
18
19
20
21FFmpegDecoderVideo::FFmpegDecoderVideo(PacketQueue & packets, FFmpegClocks & clocks) :
22    m_packets(packets),
23    m_clocks(clocks),
24    m_stream(0),
25    m_context(0),
26    m_codec(0),
27    m_packet_data(0),
28    m_bytes_remaining(0),
29    m_packet_pts(AV_NOPTS_VALUE),
30    m_user_data(0),
31    m_publish_func(0),
[9854]32    m_exit(false),
33    m_swscale_ctx(0)
[9816]34{
35
36}
37
38
39
40FFmpegDecoderVideo::~FFmpegDecoderVideo()
41{
42    if (isRunning())
43    {
44        m_exit = true;
45        join();
46    }
[9854]47   
48    if (m_swscale_ctx)
49    {
50        sws_freeContext(m_swscale_ctx);
51        m_swscale_ctx = 0;
52    }
[9816]53}
54
55
56
57void FFmpegDecoderVideo::open(AVStream * const stream)
58{
59    m_stream = stream;
60    m_context = stream->codec;
61
62    // Trust the video size given at this point
63    // (avcodec_open seems to sometimes return a 0x0 size)
64    m_width = m_context->width;
65    m_height = m_context->height;
66    findAspectRatio();
67
68    // Find out whether we support Alpha channel
69    m_alpha_channel = (m_context->pix_fmt == PIX_FMT_YUVA420P);
70
71    // Find out the framerate
72    m_frame_rate = av_q2d(stream->r_frame_rate);
73
74    // Find the decoder for the video stream
75    m_codec = avcodec_find_decoder(m_context->codec_id);
76
77    if (m_codec == 0)
78        throw std::runtime_error("avcodec_find_decoder() failed");
79
80    // Inform the codec that we can handle truncated bitstreams
81    //if (p_codec->capabilities & CODEC_CAP_TRUNCATED)
82    //    m_context->flags |= CODEC_FLAG_TRUNCATED;
83
84    // Open codec
85    if (avcodec_open(m_context, m_codec) < 0)
86        throw std::runtime_error("avcodec_open() failed");
87
88    // Allocate video frame
[9826]89    m_frame.reset(avcodec_alloc_frame());
[9816]90
91    // Allocate converted RGB frame
[9826]92    m_frame_rgba.reset(avcodec_alloc_frame());
[9816]93    m_buffer_rgba.resize(avpicture_get_size(PIX_FMT_RGB32, width(), height()));
94    m_buffer_rgba_public.resize(m_buffer_rgba.size());
95
96    // Assign appropriate parts of the buffer to image planes in m_frame_rgba
97    avpicture_fill((AVPicture *) m_frame_rgba.get(), &m_buffer_rgba[0], PIX_FMT_RGB32, width(), height());
98
99    // Override get_buffer()/release_buffer() from codec context in order to retrieve the PTS of each frame.
100    m_context->opaque = this;
101    m_context->get_buffer = getBuffer;
102    m_context->release_buffer = releaseBuffer;
103}
104
105
106
107void FFmpegDecoderVideo::run()
108{
109    try
110    {
111        decodeLoop();
112    }
113
114    catch (const std::exception & error)
115    {
116        osg::notify(osg::WARN) << "FFmpegDecoderVideo::run : " << error.what() << std::endl;
117    }
118
119    catch (...)
120    {
121        osg::notify(osg::WARN) << "FFmpegDecoderVideo::run : unhandled exception" << std::endl;
122    }
123}
124
125
126
127void FFmpegDecoderVideo::decodeLoop()
128{
129    FFmpegPacket packet;
130    double pts;
131
132    while (! m_exit)
133    {
134        // Work on the current packet until we have decoded all of it
135
136        while (m_bytes_remaining > 0)
137        {
138            // Save global PTS to be stored in m_frame via getBuffer()
139
140            m_packet_pts = packet.packet.pts;
141
142            // Decode video frame
143
144            int frame_finished = 0;
145
146            const int bytes_decoded = avcodec_decode_video(m_context, m_frame.get(), &frame_finished, m_packet_data, m_bytes_remaining);
147
148            if (bytes_decoded < 0)
149                throw std::runtime_error("avcodec_decode_video failed()");
150
151            m_bytes_remaining -= bytes_decoded;
152            m_packet_data += bytes_decoded;
153
154            // Find out the frame pts
155
156            if (packet.packet.dts == AV_NOPTS_VALUE && m_frame->opaque != 0 && *reinterpret_cast<const int64_t*>(m_frame->opaque) != AV_NOPTS_VALUE)
157            {
158                pts = *reinterpret_cast<const int64_t*>(m_frame->opaque);
159            }
160            else if (packet.packet.dts != AV_NOPTS_VALUE)
161            {
162                pts = packet.packet.dts;
163            }
164            else
165            {
166                pts = 0;
167            }
168
169            pts *= av_q2d(m_stream->time_base);
170
171            // Publish the frame if we have decoded a complete frame
172            if (frame_finished)
173            {
174                const double synched_pts = m_clocks.videoSynchClock(m_frame.get(), av_q2d(m_stream->time_base), pts);
175                const double frame_delay = m_clocks.videoRefreshSchedule(synched_pts);
176
177                publishFrame(frame_delay);
178            }
179        }
180
181        // Get the next packet
182
183        pts = 0;
184
185        if (packet.valid())
186            packet.clear();
187
188        bool is_empty = true;
189        packet = m_packets.timedPop(is_empty, 10);
190
191        if (! is_empty)
192        {
193            if (packet.type == FFmpegPacket::PACKET_DATA)
194            {
195                m_bytes_remaining = packet.packet.size;
196                m_packet_data = packet.packet.data;
197            }
198            else if (packet.type == FFmpegPacket::PACKET_FLUSH)
199            {
200                avcodec_flush_buffers(m_context);
201                m_clocks.rewindVideo();
202            }
203        }
204    }
205}
206
207
208
209void FFmpegDecoderVideo::findAspectRatio()
210{
211    double ratio = 0.0;
212
213    if (m_context->sample_aspect_ratio.num != 0)
214        ratio = (av_q2d(m_context->sample_aspect_ratio) * m_width) / m_height;
215
216    if (ratio <= 0.0)
217        ratio = double(m_width) / double(m_height);
218
219    m_aspect_ratio = ratio;
220}
221
[9854]222int FFmpegDecoderVideo::convert(AVPicture *dst, int dst_pix_fmt, const AVPicture *src,
223            int src_pix_fmt, int src_width, int src_height)
224{
225#ifdef USE_SWSCALE
226    if (m_swscale_ctx==0)
227    {
228        m_swscale_ctx = sws_getContext(src_width, src_height, src_pix_fmt,
229                                      src_width, src_height, dst_pix_fmt,                                   
230                                      SWS_BILINEAR, NULL, NULL, NULL);
231    }
232   
233    return sws_scale(m_swscale_ctx,
234           src->data, src->linesize, 0, src_height,
235           dst->data, dst->linesize);
236#else
237    return convert(dst, dst_pix_fmt, src,
238                   src_pix_fmt, src_width, src_height)
239#endif
240}
[9816]241
242
243void FFmpegDecoderVideo::publishFrame(const double delay)
244{
245    // If no publishing function, just ignore the frame
246    if (m_publish_func == 0)
247        return;
248
249    // If the display delay is too small, we better skip the frame.
250    if (delay < -0.010)
251        return;
252
253    const AVPicture * const src = (const AVPicture *) m_frame.get();
254    AVPicture * const dst = (AVPicture *) m_frame_rgba.get();
255
256    // Convert YUVA420p (i.e. YUV420p plus alpha channel) using our own routine
257
258    if (m_context->pix_fmt == PIX_FMT_YUVA420P)
259        yuva420pToRgba(dst, src, width(), height());
260    else
[9854]261        convert(dst, PIX_FMT_RGB32, src, m_context->pix_fmt, width(), height());
[9816]262
263    // Flip and swap buffer
264    swapBuffers();
265
266    // Wait 'delay' seconds before publishing the picture.
267    int i_delay = static_cast<int>(delay * 1000000 + 0.5);
268
269    while (i_delay > 1000)
270    {
271        // Avoid infinite/very long loops
272        if (m_exit)
273            return;
274
275        const int micro_delay = (std::min)(1000000, i_delay);
276
277        OpenThreads::Thread::microSleep(micro_delay);
278
279        i_delay -= micro_delay;
280    }
281
282    m_publish_func(* this, m_user_data);
283}
284
285
286
287void FFmpegDecoderVideo::swapBuffers()
288{
289    for (int h = 0; h < height(); ++h)
290        memcpy(&m_buffer_rgba_public[(height() - h - 1) * width() * 4], &m_buffer_rgba[h * width() * 4], width() * 4);
291}
292
293
294
295void FFmpegDecoderVideo::yuva420pToRgba(AVPicture * const dst, const AVPicture * const src, int width, int height)
296{
[9854]297    convert(dst, PIX_FMT_RGB32, src, m_context->pix_fmt, width, height);
[9816]298
299    const size_t bpp = 4;
300
301    uint8_t * a_dst = dst->data[0] + 3;
302
303    for (int h = 0; h < height; ++h) {
304
305        const uint8_t * a_src = src->data[3] + h * src->linesize[3];
306
307        for (int w = 0; w < width; ++w) {
308            *a_dst = *a_src;
309            a_dst += bpp;
310            a_src += 1;
311        }
312    }
313}
314
315
316
317int FFmpegDecoderVideo::getBuffer(AVCodecContext * const context, AVFrame * const picture)
318{
319    const FFmpegDecoderVideo * const this_ = reinterpret_cast<const FFmpegDecoderVideo*>(context->opaque);
320
321    const int result = avcodec_default_get_buffer(context, picture);
322    int64_t * p_pts = reinterpret_cast<int64_t*>( av_malloc(sizeof(int64_t)) );
323
324    *p_pts = this_->m_packet_pts;
325    picture->opaque = p_pts;
326
327    return result;
328}
329
330
331
332void FFmpegDecoderVideo::releaseBuffer(AVCodecContext * const context, AVFrame * const picture)
333{
334    if (picture != 0)
335        av_freep(&picture->opaque);
336
337    avcodec_default_release_buffer(context, picture);
338}
339
340
341
342} // namespace osgFFmpeg
Note: See TracBrowser for help on using the browser.