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

Revision 9856, 8.4 kB (checked in by robert, 6 years ago)

Fixed img_convert usage

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