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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
video.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：35k
源码类别：

midi

开发平台：

Unix_Linux

video.c：源码内容
  1. /*****************************************************************************
  2.  * video.c: video decoder using the ffmpeg library
  3.  *****************************************************************************
  4.  * Copyright (C) 1999-2001 the VideoLAN team
  5.  * $Id: b606cffb6e7487484308c827a5e5b888e621eedc $
  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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <vlc_common.h>
  33. #include <vlc_codec.h>
  34. #include <vlc_vout.h>
  35. #include <vlc_codecs.h>                               /* BITMAPINFOHEADER */
  36. #include <vlc_avcodec.h>
  38. /* ffmpeg header */
  39. #ifdef HAVE_LIBAVCODEC_AVCODEC_H
  40. #   include <libavcodec/avcodec.h>
  41. #elif defined(HAVE_FFMPEG_AVCODEC_H)
  42. #   include <ffmpeg/avcodec.h>
  43. #else
  44. #   include <avcodec.h>
  45. #endif
  47. #include "avcodec.h"
  49. /*****************************************************************************
  50.  * decoder_sys_t : decoder descriptor
  51.  *****************************************************************************/
  52. struct decoder_sys_t
  53. {
  54.     FFMPEG_COMMON_MEMBERS
  56.     /* Video decoder specific part */
  57.     mtime_t input_pts;
  58.     mtime_t input_dts;
  59.     mtime_t i_pts;
  61.     AVFrame          *p_ff_pic;
  63.     /* for frame skipping algo */
  64.     bool b_hurry_up;
  65.     enum AVDiscard i_skip_frame;
  66.     enum AVDiscard i_skip_idct;
  68.     /* how many decoded frames are late */
  69.     int     i_late_frames;
  70.     mtime_t i_late_frames_start;
  72.     /* for direct rendering */
  73.     bool b_direct_rendering;
  75.     bool b_has_b_frames;
  77.     /* Hack to force display of still pictures */
  78.     bool b_first_frame;
  80.     int i_buffer_orig, i_buffer;
  81.     char *p_buffer_orig, *p_buffer;
  83.     /* */
  84.     AVPaletteControl palette;
  86.     /* */
  87.     bool b_flush;
  88. };
  90. /* FIXME (dummy palette for now) */
  91. static const AVPaletteControl palette_control;
  93. /*****************************************************************************
  94.  * Local prototypes
  95.  *****************************************************************************/
  96. static void ffmpeg_InitCodec      ( decoder_t * );
  97. static int  ffmpeg_OpenCodec      ( decoder_t * );
  98. static void ffmpeg_CopyPicture    ( decoder_t *, picture_t *, AVFrame * );
  99. static int  ffmpeg_GetFrameBuf    ( struct AVCodecContext *, AVFrame * );
  100. static int  ffmpeg_ReGetFrameBuf( struct AVCodecContext *, AVFrame * );
  101. static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *, AVFrame * );
  102. static void ffmpeg_NextPts( decoder_t * );
  104. static uint32_t ffmpeg_CodecTag( vlc_fourcc_t fcc )
  105. {
  106.     uint8_t *p = (uint8_t*)&fcc;
  107.     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
  108. }
  110. /*****************************************************************************
  111.  * Local Functions
  112.  *****************************************************************************/
  114. /* Returns a new picture buffer */
  115. static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec,
  116.                                             AVCodecContext *p_context )
  117. {
  118.     picture_t *p_pic;
  120.     p_dec->fmt_out.video.i_width = p_context->width;
  121.     p_dec->fmt_out.video.i_height = p_context->height;
  123.     if( !p_context->width || !p_context->height )
  124.     {
  125.         return NULL; /* invalid display size */
  126.     }
  128.     if( GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) != VLC_SUCCESS )
  129.     {
  130.         /* we are doomed, but not really, because most codecs set their pix_fmt much later */
  131.         p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0');
  132.     }
  133.     p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma;
  135.     /* If an aspect-ratio was specified in the input format then force it */
  136.     if( p_dec->fmt_in.video.i_aspect )
  137.     {
  138.         p_dec->fmt_out.video.i_aspect = p_dec->fmt_in.video.i_aspect;
  139.     }
  140.     else
  141.     {
  142.         p_dec->fmt_out.video.i_aspect =
  143.             VOUT_ASPECT_FACTOR * ( av_q2d(p_context->sample_aspect_ratio) *
  144.                 p_context->width / p_context->height );
  145.         p_dec->fmt_out.video.i_sar_num = p_context->sample_aspect_ratio.num;
  146.         p_dec->fmt_out.video.i_sar_den = p_context->sample_aspect_ratio.den;
  148.         if( p_dec->fmt_out.video.i_aspect == 0 )
  149.         {
  150.             p_dec->fmt_out.video.i_aspect =
  151.                 VOUT_ASPECT_FACTOR * p_context->width / p_context->height;
  152.         }
  153.     }
  155.     if( p_dec->fmt_in.video.i_frame_rate > 0 &&
  156.         p_dec->fmt_in.video.i_frame_rate_base > 0 )
  157.     {
  158.         p_dec->fmt_out.video.i_frame_rate =
  159.             p_dec->fmt_in.video.i_frame_rate;
  160.         p_dec->fmt_out.video.i_frame_rate_base =
  161.             p_dec->fmt_in.video.i_frame_rate_base;
  162.     }
  163.     else if( p_context->time_base.num > 0 && p_context->time_base.den > 0 )
  164.     {
  165.         p_dec->fmt_out.video.i_frame_rate = p_context->time_base.den;
  166.         p_dec->fmt_out.video.i_frame_rate_base = p_context->time_base.num;
  167.     }
  169.     p_pic = decoder_NewPicture( p_dec );
  171.     return p_pic;
  172. }
  174. /*****************************************************************************
  175.  * InitVideo: initialize the video decoder
  176.  *****************************************************************************
  177.  * the ffmpeg codec will be opened, some memory allocated. The vout is not yet
  178.  * opened (done after the first decoded frame).
  179.  *****************************************************************************/
  180. int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
  181.                       AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
  182. {
  183.     decoder_sys_t *p_sys;
  184.     vlc_value_t val;
  186.     /* Allocate the memory needed to store the decoder's structure */
  187.     if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(decoder_sys_t) ) ) == NULL )
  188.         return VLC_ENOMEM;
  190.     p_sys->p_context = p_context;
  191.     p_sys->p_codec = p_codec;
  192.     p_sys->i_codec_id = i_codec_id;
  193.     p_sys->psz_namecodec = psz_namecodec;
  194.     p_sys->p_ff_pic = avcodec_alloc_frame();
  195.     p_sys->b_delayed_open = true;
  197.     /* ***** Fill p_context with init values ***** */
  198.     p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_codec );
  200.     /*  ***** Get configuration of ffmpeg plugin ***** */
  201.     p_sys->p_context->workaround_bugs =
  202.         config_GetInt( p_dec, "ffmpeg-workaround-bugs" );
  203. #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
  204.     p_sys->p_context->error_resilience =
  205.         config_GetInt( p_dec, "ffmpeg-error-resilience" );
  206. #else
  207.     p_sys->p_context->error_recognition =
  208.         config_GetInt( p_dec, "ffmpeg-error-resilience" );
  209. #endif
  211.     var_Create( p_dec, "grayscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  212.     var_Get( p_dec, "grayscale", &val );
  213.     if( val.b_bool ) p_sys->p_context->flags |= CODEC_FLAG_GRAY;
  215.     var_Create( p_dec, "ffmpeg-vismv", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  216.     var_Get( p_dec, "ffmpeg-vismv", &val );
  217.     if( val.i_int ) p_sys->p_context->debug_mv = val.i_int;
  219.     var_Create( p_dec, "ffmpeg-lowres", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  220.     var_Get( p_dec, "ffmpeg-lowres", &val );
  221.     if( val.i_int > 0 && val.i_int <= 2 ) p_sys->p_context->lowres = val.i_int;
  223.     var_Create( p_dec, "ffmpeg-skiploopfilter",
  224.                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  225.     var_Get( p_dec, "ffmpeg-skiploopfilter", &val );
  226.     if( val.i_int > 0 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF;
  227.     if( val.i_int > 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR;
  228.     if( val.i_int > 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY;
  229.     if( val.i_int > 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL;
  231.     bool b_fast = var_CreateGetBool( p_dec, "ffmpeg-fast" );
  232.     if( b_fast ) p_sys->p_context->flags2 |= CODEC_FLAG2_FAST;
  234.     /* ***** ffmpeg frame skipping ***** */
  235.     var_Create( p_dec, "ffmpeg-hurry-up", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  236.     var_Get( p_dec, "ffmpeg-hurry-up", &val );
  237.     p_sys->b_hurry_up = val.b_bool;
  239.     var_Create( p_dec, "ffmpeg-skip-frame", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  240.     var_Get( p_dec, "ffmpeg-skip-frame", &val );
  241.     switch( val.i_int )
  242.     {
  243.         case -1:
  244.             p_sys->p_context->skip_frame = AVDISCARD_NONE;
  245.             break;
  246.         case 0:
  247.             p_sys->p_context->skip_frame = AVDISCARD_DEFAULT;
  248.             break;
  249.         case 1:
  250.             p_sys->p_context->skip_frame = AVDISCARD_BIDIR;
  251.             break;
  252.         case 2:
  253.             p_sys->p_context->skip_frame = AVDISCARD_NONKEY;
  254.             break;
  255.         case 3:
  256.             p_sys->p_context->skip_frame = AVDISCARD_ALL;
  257.             break;
  258.         default:
  259.             p_sys->p_context->skip_frame = AVDISCARD_NONE;
  260.             break;
  261.     }
  262.     p_sys->i_skip_frame = p_sys->p_context->skip_frame;
  264.     var_Create( p_dec, "ffmpeg-skip-idct",  VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  265.     var_Get( p_dec, "ffmpeg-skip-idct", &val );
  266.     switch( val.i_int )
  267.     {
  268.         case -1:
  269.             p_sys->p_context->skip_idct = AVDISCARD_NONE;
  270.             break;
  271.         case 0:
  272.             p_sys->p_context->skip_idct = AVDISCARD_DEFAULT;
  273.             break;
  274.         case 1:
  275.             p_sys->p_context->skip_idct = AVDISCARD_BIDIR;
  276.             break;
  277.         case 2:
  278.             p_sys->p_context->skip_idct = AVDISCARD_NONKEY;
  279.             break;
  280.         case 3:
  281.             p_sys->p_context->skip_idct = AVDISCARD_ALL;
  282.             break;
  283.         default:
  284.             p_sys->p_context->skip_idct = AVDISCARD_NONE;
  285.             break;
  286.     }
  287.     p_sys->i_skip_idct = p_sys->p_context->skip_idct;
  289.     /* ***** ffmpeg direct rendering ***** */
  290.     p_sys->b_direct_rendering = false;
  291.     var_Create( p_dec, "ffmpeg-dr", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  292.     var_Get( p_dec, "ffmpeg-dr", &val );
  293.     if( val.b_bool && (p_sys->p_codec->capabilities & CODEC_CAP_DR1) &&
  294.         /* Apparently direct rendering doesn't work with YUV422P */
  295.         p_sys->p_context->pix_fmt != PIX_FMT_YUV422P &&
  296.         /* H264 uses too many reference frames */
  297.         p_sys->i_codec_id != CODEC_ID_H264 &&
  298.         /* No idea why ... but this fixes flickering on some TSCC streams */
  299.         p_sys->i_codec_id != CODEC_ID_TSCC &&
  300.         !p_sys->p_context->debug_mv )
  301.     {
  302.         /* Some codecs set pix_fmt only after the 1st frame has been decoded,
  303.          * so we need to do another check in ffmpeg_GetFrameBuf() */
  304.         p_sys->b_direct_rendering = true;
  305.     }
  307.     /* ffmpeg doesn't properly release old pictures when frames are skipped */
  308.     //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = false;
  309.     if( p_sys->b_direct_rendering )
  310.     {
  311.         msg_Dbg( p_dec, "using direct rendering" );
  312.         p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE;
  313.     }
  315.     /* Always use our get_buffer wrapper so we can calculate the
  316.      * PTS correctly */
  317.     p_sys->p_context->get_buffer = ffmpeg_GetFrameBuf;
  318.     p_sys->p_context->reget_buffer = ffmpeg_ReGetFrameBuf;
  319.     p_sys->p_context->release_buffer = ffmpeg_ReleaseFrameBuf;
  320.     p_sys->p_context->opaque = p_dec;
  322.     /* ***** misc init ***** */
  323.     p_sys->input_pts = p_sys->input_dts = 0;
  324.     p_sys->i_pts = 0;
  325.     p_sys->b_has_b_frames = false;
  326.     p_sys->b_first_frame = true;
  327.     p_sys->b_flush = false;
  328.     p_sys->i_late_frames = 0;
  329.     p_sys->i_buffer = 0;
  330.     p_sys->i_buffer_orig = 1;
  331.     p_sys->p_buffer_orig = p_sys->p_buffer = malloc( p_sys->i_buffer_orig );
  332.     if( !p_sys->p_buffer_orig )
  333.     {
  334.         av_free( p_sys->p_ff_pic );
  335.         free( p_sys );
  336.         return VLC_ENOMEM;
  337.     }
  339.     /* Set output properties */
  340.     p_dec->fmt_out.i_cat = VIDEO_ES;
  341.     if( GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) != VLC_SUCCESS )
  342.     {
  343.         /* we are doomed. but not really, because most codecs set their pix_fmt later on */
  344.         p_dec->fmt_out.i_codec = VLC_FOURCC('I','4','2','0');
  345.     }
  346.     p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma;
  348.     /* Setup palette */
  349.     memset( &p_sys->palette, 0, sizeof(p_sys->palette) );
  350.     if( p_dec->fmt_in.video.p_palette )
  351.     {
  352.         p_sys->palette.palette_changed = 1;
  354.         for( int i = 0; i < __MIN( AVPALETTE_COUNT, p_dec->fmt_in.video.p_palette->i_entries ); i++ )
  355.         {
  356.             union {
  357.                 uint32_t u;
  358.                 uint8_t a[4];
  359.             } c;
  360.             c.a[0] = p_dec->fmt_in.video.p_palette->palette[i][0];
  361.             c.a[1] = p_dec->fmt_in.video.p_palette->palette[i][1];
  362.             c.a[2] = p_dec->fmt_in.video.p_palette->palette[i][2];
  363.             c.a[3] = p_dec->fmt_in.video.p_palette->palette[i][3];
  365.             p_sys->palette.palette[i] = c.u;
  366.         }
  367.         p_sys->p_context->palctrl = &p_sys->palette;
  369.         p_dec->fmt_out.video.p_palette = malloc( sizeof(video_palette_t) );
  370.         if( p_dec->fmt_out.video.p_palette )
  371.             *p_dec->fmt_out.video.p_palette = *p_dec->fmt_in.video.p_palette;
  372.     }
  373.     else if( p_sys->i_codec_id != CODEC_ID_MSVIDEO1 && p_sys->i_codec_id != CODEC_ID_CINEPAK )
  374.     {
  375.         p_sys->p_context->palctrl = &p_sys->palette;
  376.     }
  378.     /* ***** init this codec with special data ***** */
  379.     ffmpeg_InitCodec( p_dec );
  381.     /* ***** Open the codec ***** */
  382.     if( ffmpeg_OpenCodec( p_dec ) < 0 )
  383.     {
  384.         msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
  385.         av_free( p_sys->p_ff_pic );
  386.         free( p_sys->p_buffer_orig );
  387.         free( p_sys );
  388.         return VLC_EGENERIC;
  389.     }
  391.     return VLC_SUCCESS;
  392. }
  394. /*****************************************************************************
  395.  * DecodeVideo: Called to decode one or more frames
  396.  *****************************************************************************/
  397. picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block )
  398. {
  399.     decoder_sys_t *p_sys = p_dec->p_sys;
  400.     int b_drawpicture;
  401.     int b_null_size = false;
  402.     block_t *p_block;
  404.     if( !pp_block || !*pp_block )
  405.         return NULL;
  407.     if( !p_sys->p_context->extradata_size && p_dec->fmt_in.i_extra )
  408.     {
  409.         ffmpeg_InitCodec( p_dec );
  410.         if( p_sys->b_delayed_open )
  411.         {
  412.             if( ffmpeg_OpenCodec( p_dec ) )
  413.                 msg_Err( p_dec, "cannot open codec (%s)", p_sys->psz_namecodec );
  414.         }
  415.     }
  417.     p_block = *pp_block;
  418.     if( p_sys->b_delayed_open )
  419.     {
  420.         block_Release( p_block );
  421.         return NULL;
  422.     }
  424.     if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
  425.     {
  426.         p_sys->i_buffer = 0;
  427.         p_sys->i_pts = 0; /* To make sure we recover properly */
  429.         p_sys->input_pts = p_sys->input_dts = 0;
  430.         p_sys->i_late_frames = 0;
  432.         block_Release( p_block );
  434.         //if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
  435.             //avcodec_flush_buffers( p_sys->p_context );
  436.         return NULL;
  437.     }
  439.     if( p_block->i_flags & BLOCK_FLAG_PREROLL )
  440.     {
  441.         /* Do not care about late frames when prerolling
  442.          * TODO avoid decoding of non reference frame
  443.          * (ie all B except for H264 where it depends only on nal_ref_idc) */
  444.         p_sys->i_late_frames = 0;
  445.     }
  447.     if( !p_dec->b_pace_control && (p_sys->i_late_frames > 0) &&
  448.         (mdate() - p_sys->i_late_frames_start > INT64_C(5000000)) )
  449.     {
  450.         if( p_sys->i_pts )
  451.         {
  452.             msg_Err( p_dec, "more than 5 seconds of late video -> "
  453.                      "dropping frame (computer too slow ?)" );
  454.             p_sys->i_pts = 0; /* To make sure we recover properly */
  455.         }
  456.         block_Release( p_block );
  457.         p_sys->i_late_frames--;
  458.         return NULL;
  459.     }
  461.     if( p_block->i_pts > 0 || p_block->i_dts > 0 )
  462.     {
  463.         p_sys->input_pts = p_block->i_pts;
  464.         p_sys->input_dts = p_block->i_dts;
  466.         /* Make sure we don't reuse the same timestamps twice */
  467.         p_block->i_pts = p_block->i_dts = 0;
  468.     }
  470.     /* A good idea could be to decode all I pictures and see for the other */
  471.     if( !p_dec->b_pace_control &&
  472.         p_sys->b_hurry_up &&
  473.         (p_sys->i_late_frames > 4) )
  474.     {
  475.         b_drawpicture = 0;
  476.         if( p_sys->i_late_frames < 12 )
  477.         {
  478.             p_sys->p_context->skip_frame =
  479.                     (p_sys->i_skip_frame <= AVDISCARD_BIDIR) ?
  480.                     AVDISCARD_BIDIR : p_sys->i_skip_frame;
  481.         }
  482.         else
  483.         {
  484.             /* picture too late, won't decode
  485.              * but break picture until a new I, and for mpeg4 ...*/
  486.             p_sys->i_late_frames--; /* needed else it will never be decrease */
  487.             block_Release( p_block );
  488.             p_sys->i_buffer = 0;
  489.             return NULL;
  490.         }
  491.     }
  492.     else
  493.     {
  494.         if( p_sys->b_hurry_up )
  495.             p_sys->p_context->skip_frame = p_sys->i_skip_frame;
  496.         if( !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
  497.             b_drawpicture = 1;
  498.         else
  499.             b_drawpicture = 0;
  500.     }
  502.     if( p_sys->p_context->width <= 0 || p_sys->p_context->height <= 0 )
  503.     {
  504.         if( p_sys->b_hurry_up )
  505.             p_sys->p_context->skip_frame = p_sys->i_skip_frame;
  506.         b_null_size = true;
  507.     }
  508.     else if( !b_drawpicture )
  509.     {
  510.         /* It creates broken picture
  511.          * FIXME either our parser or ffmpeg is broken */
  512. #if 0
  513.         if( p_sys->b_hurry_up )
  514.             p_sys->p_context->skip_frame = __MAX( p_sys->p_context->skip_frame,
  515.                                                   AVDISCARD_NONREF );
  516. #endif
  517.     }
  519.     /*
  520.      * Do the actual decoding now
  521.      */
  523.     /* Don't forget that ffmpeg requires a little more bytes
  524.      * that the real frame size */
  525.     if( p_block->i_buffer > 0 )
  526.     {
  527.         p_sys->b_flush = ( p_block->i_flags & BLOCK_FLAG_END_OF_SEQUENCE ) != 0;
  529.         p_sys->i_buffer = p_block->i_buffer;
  530.         if( p_sys->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE >
  531.             p_sys->i_buffer_orig )
  532.         {
  533.             free( p_sys->p_buffer_orig );
  534.             p_sys->i_buffer_orig =
  535.                 p_block->i_buffer + FF_INPUT_BUFFER_PADDING_SIZE;
  536.             p_sys->p_buffer_orig = malloc( p_sys->i_buffer_orig );
  537.         }
  538.         p_sys->p_buffer = p_sys->p_buffer_orig;
  539.         p_sys->i_buffer = p_block->i_buffer;
  540.         if( !p_sys->p_buffer )
  541.         {
  542.             block_Release( p_block );
  543.             return NULL;
  544.         }
  545.         vlc_memcpy( p_sys->p_buffer, p_block->p_buffer, p_block->i_buffer );
  546.         memset( p_sys->p_buffer + p_block->i_buffer, 0,
  547.                 FF_INPUT_BUFFER_PADDING_SIZE );
  549.         p_block->i_buffer = 0;
  550.     }
  552.     while( p_sys->i_buffer > 0 || p_sys->b_flush )
  553.     {
  554.         int i_used, b_gotpicture;
  555.         picture_t *p_pic;
  557.         i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
  558.                                        &b_gotpicture,
  559.                                        p_sys->i_buffer <= 0 && p_sys->b_flush ? NULL : (uint8_t*)p_sys->p_buffer, p_sys->i_buffer );
  561.         if( b_null_size && p_sys->p_context->width > 0 &&
  562.             p_sys->p_context->height > 0 &&
  563.             !p_sys->b_flush )
  564.         {
  565.             /* Reparse it to not drop the I frame */
  566.             b_null_size = false;
  567.             if( p_sys->b_hurry_up )
  568.                 p_sys->p_context->skip_frame = p_sys->i_skip_frame;
  569.             i_used = avcodec_decode_video( p_sys->p_context, p_sys->p_ff_pic,
  570.                                            &b_gotpicture,
  571.                                            (uint8_t*)p_sys->p_buffer, p_sys->i_buffer );
  572.         }
  574.         if( p_sys->b_flush )
  575.             p_sys->b_first_frame = true;
  577.         if( p_sys->i_buffer <= 0 )
  578.             p_sys->b_flush = false;
  580.         if( i_used < 0 )
  581.         {
  582.             if( b_drawpicture )
  583.                 msg_Warn( p_dec, "cannot decode one frame (%d bytes)",
  584.                           p_sys->i_buffer );
  585.             block_Release( p_block );
  586.             return NULL;
  587.         }
  588.         else if( i_used > p_sys->i_buffer )
  589.         {
  590.             i_used = p_sys->i_buffer;
  591.         }
  593.         /* Consumed bytes */
  594.         p_sys->i_buffer -= i_used;
  595.         p_sys->p_buffer += i_used;
  597.         /* Nothing to display */
  598.         if( !b_gotpicture )
  599.         {
  600.             if( i_used == 0 ) break;
  601.             continue;
  602.         }
  604.         /* Set the PTS */
  605.         if( p_sys->p_ff_pic->pts )
  606.             p_sys->i_pts = p_sys->p_ff_pic->pts;
  608.         /* Update frame late count (except when doing preroll) */
  609.         mtime_t i_display_date = 0;
  610.         if( !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
  611.             i_display_date = decoder_GetDisplayDate( p_dec, p_sys->i_pts );
  613.         if( i_display_date > 0 && i_display_date <= mdate() )
  614.         {
  615.             p_sys->i_late_frames++;
  616.             if( p_sys->i_late_frames == 1 )
  617.                 p_sys->i_late_frames_start = mdate();
  618.         }
  619.         else
  620.         {
  621.             p_sys->i_late_frames = 0;
  622.         }
  624.         if( !b_drawpicture || !p_sys->p_ff_pic->linesize[0] )
  625.         {
  626.             /* Do not display the picture */
  627.             p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
  628.             if( !b_drawpicture && p_pic )
  629.                 decoder_DeletePicture( p_dec, p_pic );
  631.             ffmpeg_NextPts( p_dec );
  632.             continue;
  633.         }
  635.         if( !p_sys->p_ff_pic->opaque )
  636.         {
  637.             /* Get a new picture */
  638.             p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
  639.             if( !p_pic )
  640.             {
  641.                 block_Release( p_block );
  642.                 return NULL;
  643.             }
  645.             /* Fill p_picture_t from AVVideoFrame and do chroma conversion
  646.              * if needed */
  647.             ffmpeg_CopyPicture( p_dec, p_pic, p_sys->p_ff_pic );
  648.         }
  649.         else
  650.         {
  651.             p_pic = (picture_t *)p_sys->p_ff_pic->opaque;
  652.         }
  654.         /* Sanity check (seems to be needed for some streams) */
  655.         if( p_sys->p_ff_pic->pict_type == FF_B_TYPE )
  656.         {
  657.             p_sys->b_has_b_frames = true;
  658.         }
  660.         if( !p_dec->fmt_in.video.i_aspect )
  661.         {
  662.             /* Fetch again the aspect ratio in case it changed */
  663.             p_dec->fmt_out.video.i_aspect =
  664.                 VOUT_ASPECT_FACTOR
  665.                     * ( av_q2d(p_sys->p_context->sample_aspect_ratio)
  666.                     * p_sys->p_context->width / p_sys->p_context->height );
  667.             p_dec->fmt_out.video.i_sar_num
  668.                 = p_sys->p_context->sample_aspect_ratio.num;
  669.             p_dec->fmt_out.video.i_sar_den
  670.                 = p_sys->p_context->sample_aspect_ratio.den;
  672.             if( p_dec->fmt_out.video.i_aspect == 0 )
  673.             {
  674.                 p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR
  675.                     * p_sys->p_context->width / p_sys->p_context->height;
  676.             }
  677.         }
  679.         /* Send decoded frame to vout */
  680.         if( p_sys->i_pts )
  681.         {
  682.             p_pic->date = p_sys->i_pts;
  684.             ffmpeg_NextPts( p_dec );
  686.             if( p_sys->b_first_frame )
  687.             {
  688.                 /* Hack to force display of still pictures */
  689.                 p_sys->b_first_frame = false;
  690.                 p_pic->b_force = true;
  691.             }
  693.             p_pic->i_nb_fields = 2 + p_sys->p_ff_pic->repeat_pict;
  694.             p_pic->b_progressive = !p_sys->p_ff_pic->interlaced_frame;
  695.             p_pic->b_top_field_first = p_sys->p_ff_pic->top_field_first;
  697.             p_pic->i_qstride = p_sys->p_ff_pic->qstride;
  698.             int i_mb_h = ( p_pic->format.i_height + 15 ) / 16;
  699.             p_pic->p_q = malloc( p_pic->i_qstride * i_mb_h );
  700.             memcpy( p_pic->p_q, p_sys->p_ff_pic->qscale_table,
  701.                     p_pic->i_qstride * i_mb_h );
  702.             switch( p_sys->p_ff_pic->qscale_type )
  703.             {
  704.                 case FF_QSCALE_TYPE_MPEG1:
  705.                     p_pic->i_qtype = QTYPE_MPEG1;
  706.                     break;
  707.                 case FF_QSCALE_TYPE_MPEG2:
  708.                     p_pic->i_qtype = QTYPE_MPEG2;
  709.                     break;
  710.                 case FF_QSCALE_TYPE_H264:
  711.                     p_pic->i_qtype = QTYPE_H264;
  712.                     break;
  713.             }
  715.             return p_pic;
  716.         }
  717.         else
  718.         {
  719.             decoder_DeletePicture( p_dec, p_pic );
  720.         }
  721.     }
  723.     block_Release( p_block );
  724.     return NULL;
  725. }
  727. /*****************************************************************************
  728.  * EndVideo: decoder destruction
  729.  *****************************************************************************
  730.  * This function is called when the thread ends after a successful
  731.  * initialization.
  732.  *****************************************************************************/
  733. void EndVideoDec( decoder_t *p_dec )
  734. {
  735.     decoder_sys_t *p_sys = p_dec->p_sys;
  737.     if( p_sys->p_ff_pic ) av_free( p_sys->p_ff_pic );
  738.     free( p_sys->p_buffer_orig );
  739. }
  741. /*****************************************************************************
  742.  * ffmpeg_InitCodec: setup codec extra initialization data for ffmpeg
  743.  *****************************************************************************/
  744. static void ffmpeg_InitCodec( decoder_t *p_dec )
  745. {
  746.     decoder_sys_t *p_sys = p_dec->p_sys;
  747.     int i_size = p_dec->fmt_in.i_extra;
  749.     if( !i_size ) return;
  751.     if( p_sys->i_codec_id == CODEC_ID_SVQ3 )
  752.     {
  753.         uint8_t *p;
  755.         p_sys->p_context->extradata_size = i_size + 12;
  756.         p = p_sys->p_context->extradata  =
  757.             malloc( p_sys->p_context->extradata_size );
  758.         if( !p )
  759.             return;
  761.         memcpy( &p[0],  "SVQ3", 4 );
  762.         memset( &p[4], 0, 8 );
  763.         memcpy( &p[12], p_dec->fmt_in.p_extra, i_size );
  765.         /* Now remove all atoms before the SMI one */
  766.         if( p_sys->p_context->extradata_size > 0x5a &&
  767.             strncmp( (char*)&p[0x56], "SMI ", 4 ) )
  768.         {
  769.             uint8_t *psz = &p[0x52];
  771.             while( psz < &p[p_sys->p_context->extradata_size - 8] )
  772.             {
  773.                 int i_size = GetDWBE( psz );
  774.                 if( i_size <= 1 )
  775.                 {
  776.                     /* FIXME handle 1 as long size */
  777.                     break;
  778.                 }
  779.                 if( !strncmp( (char*)&psz[4], "SMI ", 4 ) )
  780.                 {
  781.                     memmove( &p[0x52], psz,
  782.                              &p[p_sys->p_context->extradata_size] - psz );
  783.                     break;
  784.                 }
  786.                 psz += i_size;
  787.             }
  788.         }
  789.     }
  790.     else
  791.     {
  792.         p_sys->p_context->extradata_size = i_size;
  793.         p_sys->p_context->extradata =
  794.             malloc( i_size + FF_INPUT_BUFFER_PADDING_SIZE );
  795.         if( p_sys->p_context->extradata )
  796.         {
  797.             memcpy( p_sys->p_context->extradata,
  798.                     p_dec->fmt_in.p_extra, i_size );
  799.             memset( &((uint8_t*)p_sys->p_context->extradata)[i_size],
  800.                     0, FF_INPUT_BUFFER_PADDING_SIZE );
  801.         }
  802.     }
  803. }
  805. /*****************************************************************************
  806.  * ffmpeg_OpenCodec:
  807.  *****************************************************************************/
  808. static int ffmpeg_OpenCodec( decoder_t *p_dec )
  809. {
  810.     decoder_sys_t *p_sys = p_dec->p_sys;
  812.     if( p_sys->p_context->extradata_size <= 0 )
  813.     {
  814.         if( p_sys->i_codec_id == CODEC_ID_VC1 ||
  815.             p_sys->i_codec_id == CODEC_ID_VORBIS ||
  816.             p_sys->i_codec_id == CODEC_ID_THEORA )
  817.         {
  818.             msg_Warn( p_dec, "waiting for extra data for codec %s",
  819.                       p_sys->psz_namecodec );
  820.             return 1;
  821.         }
  822.     }
  823.     p_sys->p_context->width  = p_dec->fmt_in.video.i_width;
  824.     p_sys->p_context->height = p_dec->fmt_in.video.i_height;
  825. #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
  826.     p_sys->p_context->bits_per_sample = p_dec->fmt_in.video.i_bits_per_pixel;
  827. #else
  828.     p_sys->p_context->bits_per_coded_sample = p_dec->fmt_in.video.i_bits_per_pixel;
  829. #endif
  831.     int ret;
  832.     vlc_avcodec_lock();
  833.     ret = avcodec_open( p_sys->p_context, p_sys->p_codec );
  834.     vlc_avcodec_unlock();
  835.     if( ret < 0 )
  836.         return VLC_EGENERIC;
  837.     msg_Dbg( p_dec, "ffmpeg codec (%s) started", p_sys->psz_namecodec );
  839.     p_sys->b_delayed_open = false;
  841.     return VLC_SUCCESS;
  842. }
  843. /*****************************************************************************
  844.  * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
  845.  *                     picture_t structure (when not in direct rendering mode).
  846.  *****************************************************************************/
  847. static void ffmpeg_CopyPicture( decoder_t *p_dec,
  848.                                 picture_t *p_pic, AVFrame *p_ff_pic )
  849. {
  850.     decoder_sys_t *p_sys = p_dec->p_sys;
  852.     if( TestFfmpegChroma( p_sys->p_context->pix_fmt, -1 ) == VLC_SUCCESS )
  853.     {
  854.         int i_plane, i_size, i_line;
  855.         uint8_t *p_dst, *p_src;
  856.         int i_src_stride, i_dst_stride;
  858.         for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
  859.         {
  860.             p_src  = p_ff_pic->data[i_plane];
  861.             p_dst = p_pic->p[i_plane].p_pixels;
  862.             i_src_stride = p_ff_pic->linesize[i_plane];
  863.             i_dst_stride = p_pic->p[i_plane].i_pitch;
  865.             i_size = __MIN( i_src_stride, i_dst_stride );
  866.             for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines;
  867.                  i_line++ )
  868.             {
  869.                 vlc_memcpy( p_dst, p_src, i_size );
  870.                 p_src += i_src_stride;
  871.                 p_dst += i_dst_stride;
  872.             }
  873.         }
  874.     }
  875.     else
  876.     {
  877.         msg_Err( p_dec, "don't know how to convert chroma %i",
  878.                  p_sys->p_context->pix_fmt );
  879.         p_dec->b_error = 1;
  880.     }
  881. }
  883. /*****************************************************************************
  884.  * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
  885.  *****************************************************************************
  886.  * It is used for direct rendering as well as to get the right PTS for each
  887.  * decoded picture (even in indirect rendering mode).
  888.  *****************************************************************************/
  889. static void ffmpeg_SetFrameBufferPts( decoder_t *p_dec, AVFrame *p_ff_pic );
  891. static int ffmpeg_GetFrameBuf( struct AVCodecContext *p_context,
  892.                                AVFrame *p_ff_pic )
  893. {
  894.     decoder_t *p_dec = (decoder_t *)p_context->opaque;
  895.     decoder_sys_t *p_sys = p_dec->p_sys;
  896.     picture_t *p_pic;
  898.     /* Set picture PTS */
  899.     ffmpeg_SetFrameBufferPts( p_dec, p_ff_pic );
  901.     /* */
  902.     p_ff_pic->opaque = 0;
  904.     /* Not much to do in indirect rendering mode */
  905.     if( !p_sys->b_direct_rendering )
  906.     {
  907.         return avcodec_default_get_buffer( p_context, p_ff_pic );
  908.     }
  910.     /* Some codecs set pix_fmt only after the 1st frame has been decoded,
  911.      * so we need to check for direct rendering again. */
  913.     int i_width = p_sys->p_context->width;
  914.     int i_height = p_sys->p_context->height;
  915.     avcodec_align_dimensions( p_sys->p_context, &i_width, &i_height );
  917.     if( GetVlcChroma( &p_dec->fmt_out.video, p_context->pix_fmt ) != VLC_SUCCESS ||
  918.         p_sys->p_context->width % 16 || p_sys->p_context->height % 16 ||
  919.         /* We only pad picture up to 16 */
  920.         PAD(p_sys->p_context->width,16) < i_width || PAD(p_sys->p_context->height,16) < i_height ||
  921.         p_context->pix_fmt == PIX_FMT_PAL8 )
  922.         return avcodec_default_get_buffer( p_context, p_ff_pic );
  924.     p_dec->fmt_out.i_codec = p_dec->fmt_out.video.i_chroma;
  926.     /* Get a new picture */
  927.     //p_sys->p_vout->render.b_allow_modify_pics = 0;
  928.     p_pic = ffmpeg_NewPictBuf( p_dec, p_sys->p_context );
  929.     if( !p_pic )
  930.         return avcodec_default_get_buffer( p_context, p_ff_pic );
  932.     p_sys->p_context->draw_horiz_band = NULL;
  934.     p_ff_pic->opaque = (void*)p_pic;
  935.     p_ff_pic->type = FF_BUFFER_TYPE_USER;
  936.     p_ff_pic->data[0] = p_pic->p[0].p_pixels;
  937.     p_ff_pic->data[1] = p_pic->p[1].p_pixels;
  938.     p_ff_pic->data[2] = p_pic->p[2].p_pixels;
  939.     p_ff_pic->data[3] = NULL; /* alpha channel but I'm not sure */
  941.     p_ff_pic->linesize[0] = p_pic->p[0].i_pitch;
  942.     p_ff_pic->linesize[1] = p_pic->p[1].i_pitch;
  943.     p_ff_pic->linesize[2] = p_pic->p[2].i_pitch;
  944.     p_ff_pic->linesize[3] = 0;
  946.     decoder_LinkPicture( p_dec, p_pic );
  948.     /* FIXME what is that, should give good value */
  949.     p_ff_pic->age = 256*256*256*64; // FIXME FIXME from ffmpeg
  951.     return 0;
  952. }
  953. static int  ffmpeg_ReGetFrameBuf( struct AVCodecContext *p_context, AVFrame *p_ff_pic )
  954. {
  955.     decoder_t *p_dec = (decoder_t *)p_context->opaque;
  956.     int i_ret;
  958.     /* */
  959.     p_ff_pic->pts = AV_NOPTS_VALUE;
  961.     /* We always use default reget function, it works perfectly fine */
  962.     i_ret = avcodec_default_reget_buffer( p_context, p_ff_pic );
  964.     /* Set picture PTS if avcodec_default_reget_buffer didn't set it (through a
  965.      * ffmpeg_GetFrameBuf call) */
  966.     if( !i_ret && p_ff_pic->pts == AV_NOPTS_VALUE )
  967.         ffmpeg_SetFrameBufferPts( p_dec, p_ff_pic );
  969.     return i_ret;
  970. }
  972. static void ffmpeg_SetFrameBufferPts( decoder_t *p_dec, AVFrame *p_ff_pic )
  973. {
  974.     decoder_sys_t *p_sys = p_dec->p_sys;
  976.     /* Set picture PTS */
  977.     if( p_sys->input_pts )
  978.     {
  979.         p_ff_pic->pts = p_sys->input_pts;
  980.     }
  981.     else if( p_sys->input_dts )
  982.     {
  983.         /* Some demuxers only set the dts so let's try to find a useful
  984.          * timestamp from this */
  985.         if( !p_sys->p_context->has_b_frames || !p_sys->b_has_b_frames ||
  986.             !p_ff_pic->reference || !p_sys->i_pts )
  987.         {
  988.             p_ff_pic->pts = p_sys->input_dts;
  989.         }
  990.         else
  991.         {
  992.             p_ff_pic->pts = 0;
  993.         }
  994.     }
  995.     else
  996.     {
  997.         p_ff_pic->pts = 0;
  998.     }
  1000.     if( p_sys->i_pts ) /* make sure 1st frame has a pts > 0 */
  1001.     {
  1002.         p_sys->input_pts = p_sys->input_dts = 0;
  1003.     }
  1004. }
  1006. static void ffmpeg_ReleaseFrameBuf( struct AVCodecContext *p_context,
  1007.                                     AVFrame *p_ff_pic )
  1008. {
  1009.     decoder_t *p_dec = (decoder_t *)p_context->opaque;
  1011.     if( !p_ff_pic->opaque )
  1012.     {
  1013.         avcodec_default_release_buffer( p_context, p_ff_pic );
  1014.         return;
  1015.     }
  1017.     picture_t *p_pic = (picture_t*)p_ff_pic->opaque;
  1018.     decoder_UnlinkPicture( p_dec, p_pic );
  1020.     p_ff_pic->data[0] = NULL;
  1021.     p_ff_pic->data[1] = NULL;
  1022.     p_ff_pic->data[2] = NULL;
  1023.     p_ff_pic->data[3] = NULL;
  1024. }
  1026. static void ffmpeg_NextPts( decoder_t *p_dec )
  1027. {
  1028.     decoder_sys_t *p_sys = p_dec->p_sys;
  1030.     if( p_sys->i_pts <= 0 )
  1031.         return;
  1033.     /* interpolate the next PTS */
  1034.     if( p_dec->fmt_in.video.i_frame_rate > 0 &&
  1035.         p_dec->fmt_in.video.i_frame_rate_base > 0 )
  1036.     {
  1037.         p_sys->i_pts += INT64_C(1000000) *
  1038.             (2 + p_sys->p_ff_pic->repeat_pict) *
  1039.             p_dec->fmt_in.video.i_frame_rate_base /
  1040.             (2 * p_dec->fmt_in.video.i_frame_rate);
  1041.     }
  1042.     else if( p_sys->p_context->time_base.den > 0 )
  1043.     {
  1044. #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52,20,0)
  1045.         int i_tick = p_sys->p_context->ticks_per_frame;
  1046.         if( i_tick <= 0 )
  1047.             i_tick = 1;
  1048. #else
  1049.         int i_tick = 1;
  1050. #endif
  1052.         p_sys->i_pts += INT64_C(1000000) *
  1053.             (2 + p_sys->p_ff_pic->repeat_pict) *
  1054.             i_tick * p_sys->p_context->time_base.num /
  1055.             (2 * p_sys->p_context->time_base.den);
  1056.     }
  1057. }