开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
video.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：28k
源码类别：

多媒体

开发平台：

MultiPlatform

video.c：源码内容
  1. /*****************************************************************************
  2.  * video.c: video decoder using the ffmpeg library
  3.  *****************************************************************************
  4.  * Copyright (C) 1999-2001 VideoLAN
  5.  * $Id: video.c 9156 2004-11-05 14:57:53Z gbazin $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *          Gildas Bazin <gbazin@videolan.org>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #include <vlc/vlc.h>
  29. #include <vlc/decoder.h>
  31. /* ffmpeg header */
  32. #ifdef HAVE_FFMPEG_AVCODEC_H
  33. #   include <ffmpeg/avcodec.h>
  34. #else
  35. #   include <avcodec.h>
  36. #endif
  38. #include "ffmpeg.h"
  40. /*****************************************************************************
  41.  * decoder_sys_t : decoder descriptor
  42.  *****************************************************************************/
  43. struct decoder_sys_t
  44. {
  45.     /* Common part between video and audio decoder */
  46.     int i_cat;
  47.     int i_codec_id;
  48.     char *psz_namecodec;
  50.     AVCodecContext      *p_context;
  51.     AVCodec             *p_codec;
  53.     /* Video decoder specific part */
  54.     mtime_t input_pts;
  55.     mtime_t input_dts;
  56.     mtime_t i_pts;
  58.     AVFrame          *p_ff_pic;
  59.     BITMAPINFOHEADER *p_format;
  61.     /* for frame skipping algo */
  62.     int b_hurry_up;
  63.     int i_frame_skip;
  65.     /* how many decoded frames are late */
  66.     int     i_late_frames;
  67.     mtime_t i_late_frames_start;
  69.     /* for direct rendering */
  70.     int b_direct_rendering;
  72.     vlc_bool_t b_has_b_frames;
  74.     /* Hack to force display of still pictures */
  75.     vlc_bool_t b_first_frame;
  77.     int i_buffer_orig, i_buffer;
  78.     char *p_buffer_orig, *p_buffer;
  80.     /* Postprocessing handle */
  81.     void *p_pp;
  82.     vlc_bool_t b_pp;
  83.     vlc_bool_t b_pp_async;
  84.     vlc_bool_t b_pp_init;
  85. };
  87. /* FIXME (dummy palette for now) */
  88. static AVPaletteControl palette_control;
  90. /*****************************************************************************
  91.  * Local prototypes
  92.  *****************************************************************************/
  93. static void ffmpeg_CopyPicture    ( decoder_t *, picture_t *, AVFrame * );
  94. static int  ffmpeg_GetFrameBuf    ( struct AVCodecContext *, AVFrame * );
  95. static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *, AVFrame * );
  97. static uint32_t ffmpeg_CodecTag( vlc_fourcc_t fcc )
  98. {
  99.     uint8_t *p = (uint8_t*)&fcc;
  100.     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
  101. }
  103. /*****************************************************************************
  104.  * Local Functions
  105.  *****************************************************************************/
  106. static uint32_t ffmpeg_PixFmtToChroma( int i_ff_chroma )
  107. {
  108.     switch( i_ff_chroma )
  109.     {
  110.     case PIX_FMT_YUV420P:
  111.         return VLC_FOURCC('I','4','2','0');
  112.     case PIX_FMT_YUV422P:
  113.         return VLC_FOURCC('I','4','2','2');
  114.     case PIX_FMT_YUV444P:
  115.         return VLC_FOURCC('I','4','4','4');
  117.     case PIX_FMT_YUV422:
  118.         return VLC_FOURCC('Y','U','Y','2');
  120.     case PIX_FMT_RGB555:
  121.         return VLC_FOURCC('R','V','1','5');
  122.     case PIX_FMT_RGB565:
  123.         return VLC_FOURCC('R','V','1','6');
  124.     case PIX_FMT_RGB24:
  125.         return VLC_FOURCC('R','V','2','4');
  126.     case PIX_FMT_RGBA32:
  127.         return VLC_FOURCC('R','V','3','2');
  128.     case PIX_FMT_GRAY8:
  129.         return VLC_FOURCC('G','R','E','Y');
  131.     case PIX_FMT_YUV410P:
  132.     case PIX_FMT_YUV411P:
  133.     case PIX_FMT_BGR24:
  134.     default:
  135.         return 0;
  136.     }
  137. }
  139. /* Returns a new picture buffer */
  140. static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec,
  141.                                             AVCodecContext *p_context )
  142. {
  143.     decoder_sys_t *p_sys = p_dec->p_sys;
  144.     picture_t *p_pic;
  146.     p_dec->fmt_out.video.i_width = p_context->width;
  147.     p_dec->fmt_out.video.i_height = p_context->height;
  148.     p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
  150.     if( !p_context->width || !p_context->height )
  151.     {
  152.         return NULL; /* invalid display size */
  153.     }
  155.     if( !p_dec->fmt_out.i_codec )
  156.     {
  157.         /* we make conversion if possible*/
  158.         p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0');
  159.     }
  161.     /* If an aspect-ratio was specified in the input format then force it */
  162.     if( p_dec->fmt_in.video.i_aspect )
  163.     {
  164.         p_dec->fmt_out.video.i_aspect = p_dec->fmt_in.video.i_aspect;
  165.     }
  166.     else
  167.     {
  168. #if LIBAVCODEC_BUILD >= 4687
  169.         p_dec->fmt_out.video.i_aspect =
  170.             VOUT_ASPECT_FACTOR * ( av_q2d(p_context->sample_aspect_ratio) *
  171.                 p_context->width / p_context->height );
  172. #else
  173.         p_dec->fmt_out.video.i_aspect =
  174.             VOUT_ASPECT_FACTOR * p_context->aspect_ratio;
  175. #endif
  176.         if( p_dec->fmt_out.video.i_aspect == 0 )
  177.         {
  178.             p_dec->fmt_out.video.i_aspect =
  179.                 VOUT_ASPECT_FACTOR * p_context->width / p_context->height;
  180.         }
  181.     }
  183.     if( p_context->frame_rate > 0 && p_context->frame_rate_base > 0 )
  184.     {
  185.         p_dec->fmt_out.video.i_frame_rate = p_context->frame_rate;
  186.         p_dec->fmt_out.video.i_frame_rate_base = p_context->frame_rate_base;
  187.     }
  189.     p_pic = p_dec->pf_vout_buffer_new( p_dec );
  191. #ifdef LIBAVCODEC_PP
  192.     if( p_sys->p_pp && p_sys->b_pp && !p_sys->b_pp_init )
  193.     {
  194.         E_(InitPostproc)( p_dec, p_sys->p_pp, p_context->width,
  195.                           p_context->height, p_context->pix_fmt );
  196.         p_sys->b_pp_init = VLC_TRUE;
  197.     }
  198. #endif
  200.     return p_pic;
  201. }
  203. /*****************************************************************************
  204.  * InitVideo: initialize the video decoder
  205.  *****************************************************************************
  206.  * the ffmpeg codec will be opened, some memory allocated. The vout is not yet
  207.  * opened (done after the first decoded frame).
  208.  *****************************************************************************/
  209. int E_(InitVideoDec)( decoder_t *p_dec, AVCodecContext *p_context,
  210.                       AVCodec *p_codec, int i_codec_id, char *psz_namecodec )
  211. {
  212.     decoder_sys_t *p_sys;
  213.     vlc_value_t lockval;
  214.     vlc_value_t val;
  216.     var_Get( p_dec->p_libvlc, "avcodec", &lockval );
  218.     /* Allocate the memory needed to store the decoder's structure */
  219.     if( ( p_dec->p_sys = p_sys =
  220.           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
  221.     {
  222.         msg_Err( p_dec, "out of memory" );
  223.         return VLC_EGENERIC;
  224.     }
  226.     p_dec->p_sys->p_context = p_context;
  227.     p_dec->p_sys->p_codec = p_codec;
  228.     p_dec->p_sys->i_codec_id = i_codec_id;
  229.     p_dec->p_sys->psz_namecodec = psz_namecodec;
  230.     p_sys->p_ff_pic = avcodec_alloc_frame();
  232.     /* ***** Fill p_context with init values ***** */
  233.     /* FIXME: remove when ffmpeg deals properly with avc1 */
  234.     if( p_dec->fmt_in.i_codec != VLC_FOURCC('a','v','c','1') )
  235.     /* End FIXME */
  236.     p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_codec );
  237.     p_sys->p_context->width  = p_dec->fmt_in.video.i_width;
  238.     p_sys->p_context->height = p_dec->fmt_in.video.i_height;
  239.     p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel;
  241.     /*  ***** Get configuration of ffmpeg plugin ***** */
  242.     p_sys->p_context->workaround_bugs =
  243.         config_GetInt( p_dec, "ffmpeg-workaround-bugs" );
  244.     p_sys->p_context->error_resilience =
  245.         config_GetInt( p_dec, "ffmpeg-error-resilience" );
  247.     var_Create( p_dec, "grayscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  248.     var_Get( p_dec, "grayscale", &val );
  249.     if( val.b_bool ) p_sys->p_context->flags |= CODEC_FLAG_GRAY;
  251.     var_Create( p_dec, "ffmpeg-vismv", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  252.     var_Get( p_dec, "ffmpeg-vismv", &val );
  253. #if LIBAVCODEC_BUILD >= 4698
  254.     if( val.i_int ) p_sys->p_context->debug_mv = val.i_int;
  255. #endif
  257.     var_Create( p_dec, "ffmpeg-lowres", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  258.     var_Get( p_dec, "ffmpeg-lowres", &val );
  259. #if LIBAVCODEC_BUILD >= 4723
  260.     if( val.i_int > 0 && val.i_int <= 2 ) p_sys->p_context->lowres = val.i_int;
  261. #endif
  263.     /* ***** ffmpeg frame skipping ***** */
  264.     var_Create( p_dec, "ffmpeg-hurry-up", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  265.     var_Get( p_dec, "ffmpeg-hurry-up", &val );
  266.     p_sys->b_hurry_up = val.b_bool;
  268.     /* ***** ffmpeg direct rendering ***** */
  269.     p_sys->b_direct_rendering = 0;
  270.     var_Create( p_dec, "ffmpeg-dr", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  271.     var_Get( p_dec, "ffmpeg-dr", &val );
  272.     if( val.b_bool && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) &&
  273.         ffmpeg_PixFmtToChroma( p_sys->p_context->pix_fmt ) &&
  274.         /* Apparently direct rendering doesn't work with YUV422P */
  275.         p_sys->p_context->pix_fmt != PIX_FMT_YUV422P &&
  276.         /* H264 uses too many reference frames */
  277.         p_sys->i_codec_id != CODEC_ID_H264 &&
  278.         !(p_sys->p_context->width % 16) && !(p_sys->p_context->height % 16) &&
  279. #if LIBAVCODEC_BUILD >= 4698
  280.         !p_sys->p_context->debug_mv )
  281. #else
  282.         1 )
  283. #endif
  284.     {
  285.         /* Some codecs set pix_fmt only after the 1st frame has been decoded,
  286.          * so we need to do another check in ffmpeg_GetFrameBuf() */
  287.         p_sys->b_direct_rendering = 1;
  288.     }
  290. #ifdef LIBAVCODEC_PP
  291.     p_sys->p_pp = NULL;
  292.     p_sys->b_pp = p_sys->b_pp_async = p_sys->b_pp_init = VLC_FALSE;
  293.     p_sys->p_pp = E_(OpenPostproc)( p_dec, &p_sys->b_pp_async );
  294. #endif
  296.     /* ffmpeg doesn't properly release old pictures when frames are skipped */
  297.     //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = 0;
  298.     if( p_sys->b_direct_rendering )
  299.     {
  300.         msg_Dbg( p_dec, "using direct rendering" );
  301.         p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE;
  302.     }
  304.     /* Always use our get_buffer wrapper so we can calculate the
  305.      * PTS correctly */
  306.     p_sys->p_context->get_buffer = ffmpeg_GetFrameBuf;
  307.     p_sys->p_context->release_buffer = ffmpeg_ReleaseFrameBuf;
  308.     p_sys->p_context->opaque = p_dec;
  310.     /* ***** init this codec with special data ***** */
  311.     if( p_dec->fmt_in.i_extra )
  312.     {
  313.         int i_size = p_dec->fmt_in.i_extra;
  315.         if( p_sys->i_codec_id == CODEC_ID_SVQ3 )
  316.         {
  317.             uint8_t *p;
  319.             p_sys->p_context->extradata_size = i_size + 12;
  320.             p = p_sys->p_context->extradata  =
  321.                 malloc( p_sys->p_context->extradata_size );
  323.             memcpy( &p[0],  "SVQ3", 4 );
  324.             memset( &p[4], 0, 8 );
  325.             memcpy( &p[12], p_dec->fmt_in.p_extra, i_size );
  327.             /* Now remove all atoms before the SMI one */
  328.             if( p_sys->p_context->extradata_size > 0x5a &&
  329.                 strncmp( &p[0x56], "SMI ", 4 ) )
  330.             {
  331.                 uint8_t *psz = &p[0x52];
  333.                 while( psz < &p[p_sys->p_context->extradata_size - 8] )
  334.                 {
  335.                     int i_size = GetDWBE( psz );
  336.                     if( i_size <= 1 )
  337.                     {
  338.                         /* FIXME handle 1 as long size */
  339.                         break;
  340.                     }
  341.                     if( !strncmp( &psz[4], "SMI ", 4 ) )
  342.                     {
  343.                         memmove( &p[0x52], psz,
  344.                                  &p[p_sys->p_context->extradata_size] - psz );
  345.                         break;
  346.                     }
  348.                     psz += i_size;
  349.                 }
  350.             }
  351.         }
  352.         else if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '0' ) ||
  353.                  p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '1', '3' ) ||
  354.                  p_dec->fmt_in.i_codec == VLC_FOURCC( 'R', 'V', '2', '0' ) )
  355.         {
  356.             if( p_dec->fmt_in.i_extra == 8 )
  357.             {
  358.                 p_sys->p_context->extradata_size = 8;
  359.                 p_sys->p_context->extradata = malloc( 8 );
  361.                 memcpy( p_sys->p_context->extradata,
  362.                         p_dec->fmt_in.p_extra,
  363.                         p_dec->fmt_in.i_extra );
  364.                 p_sys->p_context->sub_id= ((uint32_t*)p_dec->fmt_in.p_extra)[1];
  366.                 msg_Warn( p_dec, "using extra data for RV codec sub_id=%08x",
  367.                           p_sys->p_context->sub_id );
  368.             }
  369.         }
  370.         /* FIXME: remove when ffmpeg deals properly with avc1 */
  371.         else if( p_dec->fmt_in.i_codec == VLC_FOURCC('a','v','c','1') )
  372.         {
  373.             ;
  374.         }
  375.         /* End FIXME */
  376.         else
  377.         {
  378.             p_sys->p_context->extradata_size = i_size;
  379.             p_sys->p_context->extradata =
  380.                 malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE );
  381.             memcpy( p_sys->p_context->extradata,
  382.                     p_dec->fmt_in.p_extra, i_size );
  383.             memset( &((uint8_t*)p_sys->p_context->extradata)[i_size],
  384.                     0, FF_INPUT_BUFFER_PADDING_SIZE );
  385.         }
  386.     }
  388.     /* ***** misc init ***** */
  389.     p_sys->input_pts = p_sys->input_dts = 0;
  390.     p_sys->i_pts = 0;
  391.     p_sys->b_has_b_frames = VLC_FALSE;
  392.     p_sys->b_first_frame = VLC_TRUE;
  393.     p_sys->i_late_frames = 0;
  394.     p_sys->i_buffer = 0;
  395.     p_sys->i_buffer_orig = 1;
  396.     p_sys->p_buffer_orig = p_sys->p_buffer = malloc( p_sys->i_buffer_orig );
  398.     /* Set output properties */
  399.     p_dec->fmt_out.i_cat = VIDEO_ES;
  400.     p_dec->fmt_out.i_codec = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
  402.     /* Setup palette */
  403. #if LIBAVCODEC_BUILD >= 4688
  404.     if( p_dec->fmt_in.video.p_palette )
  405.         p_sys->p_context->palctrl =
  406.             (AVPaletteControl *)p_dec->fmt_in.video.p_palette;
  407.     else
  408.         p_sys->p_context->palctrl = &palette_control;
  409. #endif
  411.     /* ***** Open the codec ***** */
  412.     vlc_mutex_lock( lockval.p_address );
  413.     if( avcodec_open( p_sys->p_context, p_sys->p_codec ) < 0 )
  414.     {
  415.         vlc_mutex_unlock( lockval.p_address );
  416.         msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
  417.         free( p_sys );
  418.         return VLC_EGENERIC;
  419.     }
  420.     vlc_mutex_unlock( lockval.p_address );
  421.     msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
  424.     return VLC_SUCCESS;
  425. }
  427. /*****************************************************************************
  428.  * DecodeVideo: Called to decode one or more frames
  429.  *****************************************************************************/
  430. picture_t *E_(DecodeVideo)( decoder_t *p_dec, block_t **pp_block )
  431. {
  432.     decoder_sys_t *p_sys = p_dec->p_sys;
  433.     int b_drawpicture;
  434.     int b_null_size = VLC_FALSE;
  435.     block_t *p_block;
  437.     if( !pp_block || !*pp_block ) return NULL;
  439.     p_block = *pp_block;
  441.     if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY )
  442.     {
  443.         p_sys->i_buffer = 0;
  444.         p_sys->i_pts = 0; /* To make sure we recover properly */
  446.         p_sys->input_pts = p_sys->input_dts = 0;
  447.         p_sys->i_late_frames = 0;
  449.         block_Release( p_block );
  450.         return NULL;
  451.     }
  453.     if( !p_dec->b_pace_control && p_sys->i_late_frames > 0 &&
  454.         mdate() - p_sys->i_late_frames_start > I64C(5000000) )
  455.     {
  456.         if( p_sys->i_pts )
  457.         {
  458.             msg_Err( p_dec, "more than 5 seconds of late video -> "
  459.                      "dropping frame (computer too slow ?)" );
  460.             p_sys->i_pts = 0; /* To make sure we recover properly */
  461.         }
  462.         block_Release( p_block );
  463.         p_sys->i_late_frames--;
  464.         return NULL;
  465.     }
  467.     if( p_block->i_pts > 0 || p_block->i_dts > 0 )
  468.     {
  469.         p_sys->input_pts = p_block->i_pts;
  470.         p_sys->input_dts = p_block->i_dts;
  472.         /* Make sure we don't reuse the same timestamps twice */
  473.         p_block->i_pts = p_block->i_dts = 0;
  474.     }
  476.     /* TODO implement it in a better way */
  477.     /* A good idea could be to decode all I pictures and see for the other */
  478.     if( !p_dec->b_pace_control &&
  479.         p_sys->b_hurry_up && p_sys->i_late_frames > 4 )
  480.     {
  481.         b_drawpicture = 0;
  482.         if( p_sys->i_late_frames < 8 )
  483.         {
  484.             p_sys->p_context->hurry_up = 2;
  485.         }
  486.         else
  487.         {
  488.             /* picture too late, won't decode
  489.              * but break picture until a new I, and for mpeg4 ...*/
  491.             p_sys->i_late_frames--; /* needed else it will never be decrease */
  492.             block_Release( p_block );
  493.             p_sys->i_buffer = 0;
  494.             return NULL;
  495.         }
  496.     }
  497.     else
  498.     {
  499.         b_drawpicture = 1;
  500.         p_sys->p_context->hurry_up = 0;
  501.     }
  504.     if( p_sys->p_context->width <= 0 || p_sys->p_context->height <= 0 )
  505.     {
  506.         p_sys->p_context->hurry_up = 5;
  507.         b_null_size = VLC_TRUE;
  508.     }
  510.     /*
  511.      * Do the actual decoding now
  512.      */
  514.     /* Check if post-processing was enabled */
  515.     p_sys->b_pp = p_sys->b_pp_async;
  517.     /* Don't forget that ffmpeg requires a little more bytes
  518.      * that the real frame size */
  519.     if( p_block->i_buffer > 0 )
  520.     {
  521.         p_sys->i_buffer = p_block->i_buffer;
  522.         if( p_sys->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE >
  523.             p_sys->i_buffer_orig )
  524.         {
  525.             free( p_sys->p_buffer_orig );
  526.             p_sys->i_buffer_orig =
  527.                 p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE;
  528.             p_sys->p_buffer_orig = malloc( p_sys->i_buffer_orig );
  529.         }
  530.         p_sys->p_buffer = p_sys->p_buffer_orig;
  531.         p_sys->i_buffer = p_block->i_buffer;
  532.         p_dec->p_vlc->pf_memcpy( p_sys->p_buffer, p_block->p_buffer,
  533.                                  p_block->i_buffer );
  534.         memset( p_sys->p_buffer + p_block->i_buffer, 0,
  535.                 FF_INPUT_BUFFER_PADDING_SIZE );
  537.         p_block->i_buffer = 0;
  538.     }
  540.     while( p_sys->i_buffer > 0 )
  541.     {
  542.         int i_used, b_gotpicture;
  543.         picture_t *p_pic;
  545.         i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
  546.                                        &b_gotpicture,
  547.                                        p_sys->p_buffer, p_sys->i_buffer );
  548.         if( b_null_size && p_sys->p_context->width > 0 &&
  549.             p_sys->p_context->height > 0 )
  550.         {
  551.             /* Reparse it to not drop the I frame */
  552.             b_null_size = VLC_FALSE;
  553.             p_sys->p_context->hurry_up = 0;
  554.             i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
  555.                                            &b_gotpicture,
  556.                                            p_sys->p_buffer, p_sys->i_buffer );
  557.         }
  559.         if( i_used < 0 )
  560.         {
  561.             msg_Warn( p_dec, "cannot decode one frame (%d bytes)",
  562.                       p_sys->i_buffer );
  563.             block_Release( p_block );
  564.             return NULL;
  565.         }
  566.         else if( i_used > p_sys->i_buffer )
  567.         {
  568.             i_used = p_sys->i_buffer;
  569.         }
  571.         /* Consumed bytes */
  572.         p_sys->i_buffer -= i_used;
  573.         p_sys->p_buffer += i_used;
  575.         /* Nothing to display */
  576.         if( !b_gotpicture )
  577.         {
  578.             if( i_used == 0 ) break;
  579.             continue;
  580.         }
  582.         /* Update frame late count*/
  583.         if( p_sys->i_pts && p_sys->i_pts <= mdate() )
  584.         {
  585.             p_sys->i_late_frames++;
  586.             if( p_sys->i_late_frames == 1 )
  587.                 p_sys->i_late_frames_start = mdate();
  588.         }
  589.         else
  590.         {
  591.             p_sys->i_late_frames = 0;
  592.         }
  594.         if( !b_drawpicture || !p_sys->p_ff_pic->linesize[0] )
  595.         {
  596.             /* Do not display the picture */
  597.             continue;
  598.         }
  600.         if( !p_sys->p_ff_pic->opaque )
  601.         {
  602.             /* Get a new picture */
  603.             p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
  604.             if( !p_pic )
  605.             {
  606.                 block_Release( p_block );
  607.                 return NULL;
  608.             }
  610.             /* Fill p_picture_t from AVVideoFrame and do chroma conversion
  611.              * if needed */
  612.             ffmpeg_CopyPicture( p_dec, p_pic, p_sys->p_ff_pic );
  613.         }
  614.         else
  615.         {
  616.             p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
  617.         }
  619.         /* Set the PTS */
  620.         if( p_sys->p_ff_pic->pts ) p_sys->i_pts = p_sys->p_ff_pic->pts;
  622.         /* Sanity check (seems to be needed for some streams ) */
  623.         if( p_sys->p_ff_pic->pict_type == FF_B_TYPE )
  624.         {
  625.             p_sys->b_has_b_frames = VLC_TRUE;
  626.         }
  628.         /* Send decoded frame to vout */
  629.         if( p_sys->i_pts )
  630.         {
  631.             p_pic->date = p_sys->i_pts;
  633.             /* interpolate the next PTS */
  634.             if( p_sys->p_context->frame_rate > 0 )
  635.             {
  636.                 p_sys->i_pts += I64C(1000000) *
  637.                     (2 + p_sys->p_ff_pic->repeat_pict) *
  638.                     p_sys->p_context->frame_rate_base /
  639.                     (2 * p_sys->p_context->frame_rate);
  640.             }
  642.             if( p_sys->b_first_frame )
  643.             {
  644.                 /* Hack to force display of still pictures */
  645.                 p_sys->b_first_frame = VLC_FALSE;
  646.                 p_pic->b_force = VLC_TRUE;
  647.             }
  649.             p_pic->i_nb_fields = 2 + p_sys->p_ff_pic->repeat_pict;
  650. #if LIBAVCODEC_BUILD >= 4685
  651.             p_pic->b_progressive = !p_sys->p_ff_pic->interlaced_frame;
  652.             p_pic->b_top_field_first = p_sys->p_ff_pic->top_field_first;
  653. #endif
  655.             return p_pic;
  656.         }
  657.         else
  658.         {
  659.             p_dec->pf_vout_buffer_del( p_dec, p_pic );
  660.         }
  661.     }
  663.     block_Release( p_block );
  664.     return NULL;
  665. }
  667. /*****************************************************************************
  668.  * EndVideo: decoder destruction
  669.  *****************************************************************************
  670.  * This function is called when the thread ends after a sucessful
  671.  * initialization.
  672.  *****************************************************************************/
  673. void E_(EndVideoDec)( decoder_t *p_dec )
  674. {
  675.     decoder_sys_t *p_sys = p_dec->p_sys;
  677.     if( p_sys->p_ff_pic ) av_free( p_sys->p_ff_pic );
  679. #ifdef LIBAVCODEC_PP
  680.     E_(ClosePostproc)( p_dec, p_sys->p_pp );
  681. #endif
  683.     free( p_sys->p_buffer_orig );
  684. }
  686. /*****************************************************************************
  687.  * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
  688.  *                     picture_t structure (when not in direct rendering mode).
  689.  *****************************************************************************/
  690. static void ffmpeg_CopyPicture( decoder_t *p_dec,
  691.                                 picture_t *p_pic, AVFrame *p_ff_pic )
  692. {
  693.     decoder_sys_t *p_sys = p_dec->p_sys;
  695.     if( ffmpeg_PixFmtToChroma( p_sys->p_context->pix_fmt ) )
  696.     {
  697.         int i_plane, i_size, i_line;
  698.         uint8_t *p_dst, *p_src;
  699.         int i_src_stride, i_dst_stride;
  701. #ifdef LIBAVCODEC_PP
  702.         if( p_sys->p_pp && p_sys->b_pp )
  703.             E_(PostprocPict)( p_dec, p_sys->p_pp, p_pic, p_ff_pic );
  704.         else
  705. #endif
  706.         for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
  707.         {
  708.             p_src  = p_ff_pic->data[i_plane];
  709.             p_dst = p_pic->p[i_plane].p_pixels;
  710.             i_src_stride = p_ff_pic->linesize[i_plane];
  711.             i_dst_stride = p_pic->p[i_plane].i_pitch;
  713.             i_size = __MIN( i_src_stride, i_dst_stride );
  714.             for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines;
  715.                  i_line++ )
  716.             {
  717.                 p_dec->p_vlc->pf_memcpy( p_dst, p_src, i_size );
  718.                 p_src += i_src_stride;
  719.                 p_dst += i_dst_stride;
  720.             }
  721.         }
  722.     }
  723.     else
  724.     {
  725.         AVPicture dest_pic;
  726.         int i;
  728.         /* we need to convert to I420 */
  729.         switch( p_sys->p_context->pix_fmt )
  730.         {
  731.         case PIX_FMT_YUV410P:
  732.         case PIX_FMT_YUV411P:
  733.         case PIX_FMT_PAL8:
  734.             for( i = 0; i < p_pic->i_planes; i++ )
  735.             {
  736.                 dest_pic.data[i] = p_pic->p[i].p_pixels;
  737.                 dest_pic.linesize[i] = p_pic->p[i].i_pitch;
  738.             }
  739.             img_convert( &dest_pic, PIX_FMT_YUV420P,
  740.                          (AVPicture *)p_ff_pic,
  741.                          p_sys->p_context->pix_fmt,
  742.                          p_sys->p_context->width,
  743.                          p_sys->p_context->height );
  744.             break;
  745.         default:
  746.             msg_Err( p_dec, "don't know how to convert chroma %i",
  747.                      p_sys->p_context->pix_fmt );
  748.             p_dec->b_error = 1;
  749.             break;
  750.         }
  751.     }
  752. }
  754. /*****************************************************************************
  755.  * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
  756.  *****************************************************************************
  757.  * It is used for direct rendering as well as to get the right PTS for each
  758.  * decoded picture (even in indirect rendering mode).
  759.  *****************************************************************************/
  760. static int ffmpeg_GetFrameBuf( struct AVCodecContext *p_context,
  761.                                AVFrame *p_ff_pic )
  762. {
  763.     decoder_t *p_dec = (decoder_t *)p_context->opaque;
  764.     decoder_sys_t *p_sys = p_dec->p_sys;
  765.     picture_t *p_pic;
  767.     /* Set picture PTS */
  768.     if( p_sys->input_pts )
  769.     {
  770.         p_ff_pic->pts = p_sys->input_pts;
  771.     }
  772.     else if( p_sys->input_dts )
  773.     {
  774.         /* Some demuxers only set the dts so let's try to find a useful
  775.          * timestamp from this */
  776.         if( !p_context->has_b_frames || !p_sys->b_has_b_frames ||
  777.             !p_ff_pic->reference || !p_sys->i_pts )
  778.         {
  779.             p_ff_pic->pts = p_sys->input_dts;
  780.         }
  781.         else p_ff_pic->pts = 0;
  782.     }
  783.     else p_ff_pic->pts = 0;
  785.     if( p_sys->i_pts ) /* make sure 1st frame has a pts > 0 */
  786.     {
  787.         p_sys->input_pts = p_sys->input_dts = 0;
  788.     }
  790.     p_ff_pic->opaque = 0;
  792.     /* Not much to do in indirect rendering mode */
  793.     if( !p_sys->b_direct_rendering || p_sys->b_pp )
  794.     {
  795.         return avcodec_default_get_buffer( p_context, p_ff_pic );
  796.     }
  798.     /* Some codecs set pix_fmt only after the 1st frame has been decoded,
  799.      * so this check is necessary. */
  800.     if( !ffmpeg_PixFmtToChroma( p_context->pix_fmt ) ||
  801.         p_sys->p_context->width % 16 || p_sys->p_context->height % 16 )
  802.     {
  803.         msg_Dbg( p_dec, "disabling direct rendering" );
  804.         p_sys->b_direct_rendering = 0;
  805.         return avcodec_default_get_buffer( p_context, p_ff_pic );
  806.     }
  808.     /* Get a new picture */
  809.     //p_sys->p_vout->render.b_allow_modify_pics = 0;
  810.     p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
  811.     if( !p_pic )
  812.     {
  813.         p_sys->b_direct_rendering = 0;
  814.         return avcodec_default_get_buffer( p_context, p_ff_pic );
  815.     }
  816.     p_sys->p_context->draw_horiz_band = NULL;
  818.     p_ff_pic->opaque = (void*)p_pic;
  819.     p_ff_pic->type = FF_BUFFER_TYPE_USER;
  820.     p_ff_pic->data[0] = p_pic->p[0].p_pixels;
  821.     p_ff_pic->data[1] = p_pic->p[1].p_pixels;
  822.     p_ff_pic->data[2] = p_pic->p[2].p_pixels;
  823.     p_ff_pic->data[3] = NULL; /* alpha channel but I'm not sure */
  825.     p_ff_pic->linesize[0] = p_pic->p[0].i_pitch;
  826.     p_ff_pic->linesize[1] = p_pic->p[1].i_pitch;
  827.     p_ff_pic->linesize[2] = p_pic->p[2].i_pitch;
  828.     p_ff_pic->linesize[3] = 0;
  830.     if( p_ff_pic->reference != 0 )
  831.     {
  832.         p_dec->pf_picture_link( p_dec, p_pic );
  833.     }
  835.     /* FIXME what is that, should give good value */
  836.     p_ff_pic->age = 256*256*256*64; // FIXME FIXME from ffmpeg
  838.     return 0;
  839. }
  841. static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *p_context,
  842.                                     AVFrame *p_ff_pic )
  843. {
  844.     decoder_t *p_dec = (decoder_t *)p_context->opaque;
  845.     picture_t *p_pic;
  847.     if( !p_ff_pic->opaque )
  848.     {
  849.         avcodec_default_release_buffer( p_context, p_ff_pic );
  850.         return;
  851.     }
  853.     p_pic = (picture_t*)p_ff_pic->opaque;
  855.     p_ff_pic->data[0] = NULL;
  856.     p_ff_pic->data[1] = NULL;
  857.     p_ff_pic->data[2] = NULL;
  858.     p_ff_pic->data[3] = NULL;
  860.     if( p_ff_pic->reference != 0 )
  861.     {
  862.         p_dec->pf_picture_unlink( p_dec, p_pic );
  863.     }
  864. }