1 /* GStreamer

     2  * Copyright (C) <1999> Erik Walthinsen <omega@temple-baptist.com>

     3  * Copyright (C) <2006> Nokia Corporation (contact <stefan.kost@nokia.com>)

     4  *

     5  * This library is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU Library General Public

     7  * License as published by the Free Software Foundation; either

     8  * version 2 of the License, or (at your option) any later version.

     9  *

    10  * This library is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  * Library General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU Library General Public

    16  * License along with this library; if not, write to the

    17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    18  * Boston, MA 02111-1307, USA.

    19  */

    20 /* Element-Checklist-Version: 5 */

    21 

    22 /**

    23  * SECTION:element-avidemux

    24  *

    25  * Demuxes an .avi file into raw or compressed audio and/or video streams.

    26  *

    27  * This element supports both push and pull-based scheduling, depending on the

    28  * capabilities of the upstream elements.

    29  *

    30  * <refsect2>

    31  * <title>Example launch line</title>

    32  * |[

    33  * gst-launch filesrc location=test.avi ! avidemux name=demux  demux.audio_00 ! decodebin ! audioconvert ! audioresample ! autoaudiosink   demux.video_00 ! queue ! decodebin ! ffmpegcolorspace ! videoscale ! autovideosink

    34  * ]| Play (parse and decode) an .avi file and try to output it to

    35  * an automatically detected soundcard and videosink. If the AVI file contains

    36  * compressed audio or video data, this will only work if you have the

    37  * right decoder elements/plugins installed.

    38  * </refsect2>

    39  *

    40  * Last reviewed on 2006-12-29 (0.10.6)

    41  */

    42 

    43 #ifdef HAVE_CONFIG_H

    44 #include "config.h"

    45 #endif

    46 

    47 #include <string.h>

    48 

    49 #include "gst/riff/riff-media.h"

    50 #include "gstavidemux.h"

    51 #include "avi-ids.h"

    52 #include <gst/gst-i18n-plugin.h>

    53 #include <gst/base/gstadapter.h>

    54 

    55 GST_DEBUG_CATEGORY_STATIC (avidemux_debug);

    56 #define GST_CAT_DEFAULT avidemux_debug

    57 

    58 GST_DEBUG_CATEGORY_EXTERN (GST_CAT_EVENT);

    59 

    60 static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",

    61     GST_PAD_SINK,

    62     GST_PAD_ALWAYS,

    63     GST_STATIC_CAPS ("video/x-msvideo")

    64     );

    65 

    66 static void gst_avi_demux_base_init (GstAviDemuxClass * klass);

    67 static void gst_avi_demux_class_init (GstAviDemuxClass * klass);

    68 static void gst_avi_demux_init (GstAviDemux * avi);

    69 static void gst_avi_demux_finalize (GObject * object);

    70 

    71 static void gst_avi_demux_reset (GstAviDemux * avi);

    72 

    73 #if 0

    74 static const GstEventMask *gst_avi_demux_get_event_mask (GstPad * pad);

    75 #endif

    76 static gboolean gst_avi_demux_handle_src_event (GstPad * pad, GstEvent * event);

    77 static gboolean gst_avi_demux_handle_sink_event (GstPad * pad,

    78     GstEvent * event);

    79 static gboolean gst_avi_demux_push_event (GstAviDemux * avi, GstEvent * event);

    80 

    81 #if 0

    82 static const GstFormat *gst_avi_demux_get_src_formats (GstPad * pad);

    83 #endif

    84 static const GstQueryType *gst_avi_demux_get_src_query_types (GstPad * pad);

    85 static gboolean gst_avi_demux_handle_src_query (GstPad * pad, GstQuery * query);

    86 static gboolean gst_avi_demux_src_convert (GstPad * pad, GstFormat src_format,

    87     gint64 src_value, GstFormat * dest_format, gint64 * dest_value);

    88 

    89 static gboolean gst_avi_demux_do_seek (GstAviDemux * avi, GstSegment * segment);

    90 static gboolean gst_avi_demux_handle_seek (GstAviDemux * avi, GstPad * pad,

    91     GstEvent * event);

    92 static void gst_avi_demux_loop (GstPad * pad);

    93 static gboolean gst_avi_demux_sink_activate (GstPad * sinkpad);

    94 static gboolean gst_avi_demux_sink_activate_pull (GstPad * sinkpad,

    95     gboolean active);

    96 static gboolean gst_avi_demux_activate_push (GstPad * pad, gboolean active);

    97 static GstFlowReturn gst_avi_demux_chain (GstPad * pad, GstBuffer * buf);

    98 

    99 static GstStateChangeReturn gst_avi_demux_change_state (GstElement * element,

   100     GstStateChange transition);

   101 

   102 static GstElementClass *parent_class = NULL;

   103 

   104 /* GObject methods */

   105 

   106 GType

   107 gst_avi_demux_get_type (void)

   108 {

   109   static GType avi_demux_type = 0;

   110 

   111   if (!avi_demux_type) {

   112     static const GTypeInfo avi_demux_info = {

   113       sizeof (GstAviDemuxClass),

   114       (GBaseInitFunc) gst_avi_demux_base_init,

   115       NULL,

   116       (GClassInitFunc) gst_avi_demux_class_init,

   117       NULL,

   118       NULL,

   119       sizeof (GstAviDemux),

   120       0,

   121       (GInstanceInitFunc) gst_avi_demux_init,

   122     };

   123 

   124     avi_demux_type =

   125         g_type_register_static (GST_TYPE_ELEMENT,

   126         "GstAviDemux", &avi_demux_info, 0);

   127   }

   128 

   129   return avi_demux_type;

   130 }

   131 

   132 static void

   133 gst_avi_demux_base_init (GstAviDemuxClass * klass)

   134 {

   135   static const GstElementDetails gst_avi_demux_details =

   136       GST_ELEMENT_DETAILS ("Avi demuxer",

   137       "Codec/Demuxer",

   138       "Demultiplex an avi file into audio and video",

   139       "Erik Walthinsen <omega@cse.ogi.edu>\n"

   140       "Wim Taymans <wim.taymans@chello.be>\n"

   141       "Ronald Bultje <rbultje@ronald.bitfreak.net>\n"

   142       "Thijs Vermeir <thijsvermeir@gmail.com>");

   143   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

   144   GstPadTemplate *videosrctempl, *audiosrctempl, *subsrctempl;

   145   GstCaps *audcaps, *vidcaps, *subcaps;

   146 

   147   audcaps = gst_riff_create_audio_template_caps ();

   148   gst_caps_append (audcaps, gst_caps_new_simple ("audio/x-avi-unknown", NULL));

   149   audiosrctempl = gst_pad_template_new ("audio_%02d",

   150       GST_PAD_SRC, GST_PAD_SOMETIMES, audcaps);

   151 

   152   vidcaps = gst_riff_create_video_template_caps ();

   153   gst_caps_append (vidcaps, gst_riff_create_iavs_template_caps ());

   154   gst_caps_append (vidcaps, gst_caps_new_simple ("video/x-avi-unknown", NULL));

   155   videosrctempl = gst_pad_template_new ("video_%02d",

   156       GST_PAD_SRC, GST_PAD_SOMETIMES, vidcaps);

   157 

   158   subcaps = gst_caps_new_simple ("application/x-subtitle-avi", NULL);

   159   subsrctempl = gst_pad_template_new ("subtitle_%02d",

   160       GST_PAD_SRC, GST_PAD_SOMETIMES, subcaps);

   161   gst_element_class_add_pad_template (element_class, audiosrctempl);

   162   gst_element_class_add_pad_template (element_class, videosrctempl);

   163   gst_element_class_add_pad_template (element_class, subsrctempl);

   164   gst_element_class_add_pad_template (element_class,

   165       gst_static_pad_template_get (&sink_templ));

   166   gst_element_class_set_details (element_class, &gst_avi_demux_details);

   167 }

   168 

   169 static void

   170 gst_avi_demux_class_init (GstAviDemuxClass * klass)

   171 {

   172   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);

   173   GObjectClass *gobject_class = (GObjectClass *) klass;

   174 

   175   GST_DEBUG_CATEGORY_INIT (avidemux_debug, "avidemux",

   176       0, "Demuxer for AVI streams");

   177 

   178   parent_class = g_type_class_peek_parent (klass);

   179 

   180   gobject_class->finalize = gst_avi_demux_finalize;

   181   gstelement_class->change_state =

   182       GST_DEBUG_FUNCPTR (gst_avi_demux_change_state);

   183 }

   184 

   185 static void

   186 gst_avi_demux_init (GstAviDemux * avi)

   187 {

   188   avi->sinkpad = gst_pad_new_from_static_template (&sink_templ, "sink");

   189   gst_pad_set_activate_function (avi->sinkpad,

   190       GST_DEBUG_FUNCPTR (gst_avi_demux_sink_activate));

   191   gst_pad_set_activatepull_function (avi->sinkpad,

   192       GST_DEBUG_FUNCPTR (gst_avi_demux_sink_activate_pull));

   193   gst_pad_set_activatepush_function (avi->sinkpad,

   194       GST_DEBUG_FUNCPTR (gst_avi_demux_activate_push));

   195   gst_pad_set_chain_function (avi->sinkpad,

   196       GST_DEBUG_FUNCPTR (gst_avi_demux_chain));

   197   gst_pad_set_event_function (avi->sinkpad,

   198       GST_DEBUG_FUNCPTR (gst_avi_demux_handle_sink_event));

   199   gst_element_add_pad (GST_ELEMENT (avi), avi->sinkpad);

   200 

   201   avi->adapter = gst_adapter_new ();

   202 

   203   gst_avi_demux_reset (avi);

   204 }

   205 

   206 static void

   207 gst_avi_demux_finalize (GObject * object)

   208 {

   209   GstAviDemux *avi = GST_AVI_DEMUX (object);

   210 

   211   GST_DEBUG ("AVI: finalize");

   212 

   213   g_object_unref (avi->adapter);

   214 

   215   G_OBJECT_CLASS (parent_class)->finalize (object);

   216 }

   217 

   218 static void

   219 gst_avi_demux_reset (GstAviDemux * avi)

   220 {

   221   gint i;

   222 

   223   GST_DEBUG ("AVI: reset");

   224 

   225   for (i = 0; i < avi->num_streams; i++) {

   226     g_free (avi->stream[i].strh);

   227     g_free (avi->stream[i].strf.data);

   228     if (avi->stream[i].name)

   229       g_free (avi->stream[i].name);

   230     if (avi->stream[i].initdata)

   231       gst_buffer_unref (avi->stream[i].initdata);

   232     if (avi->stream[i].extradata)

   233       gst_buffer_unref (avi->stream[i].extradata);

   234     if (avi->stream[i].pad) {

   235       gst_pad_set_active (avi->stream[i].pad, FALSE);

   236       gst_element_remove_pad (GST_ELEMENT (avi), avi->stream[i].pad);

   237     }

   238     if (avi->stream[i].taglist) {

   239       gst_tag_list_free (avi->stream[i].taglist);

   240       avi->stream[i].taglist = NULL;

   241     }

   242   }

   243   memset (&avi->stream, 0, sizeof (avi->stream));

   244 

   245   avi->header_state = GST_AVI_DEMUX_HEADER_TAG_LIST;

   246   avi->num_streams = 0;

   247   avi->num_v_streams = 0;

   248   avi->num_a_streams = 0;

   249   avi->num_t_streams = 0;

   250 

   251   avi->state = GST_AVI_DEMUX_START;

   252   avi->offset = 0;

   253 

   254   g_free (avi->index_entries);

   255   avi->index_entries = NULL;

   256   avi->index_size = 0;

   257   avi->index_offset = 0;

   258   avi->current_entry = 0;

   259   g_free (avi->avih);

   260   avi->avih = NULL;

   261 

   262   if (avi->seek_event) {

   263     gst_event_unref (avi->seek_event);

   264     avi->seek_event = NULL;

   265   }

   266 

   267   if (avi->globaltags)

   268     gst_tag_list_free (avi->globaltags);

   269   avi->globaltags = NULL;

   270 

   271   avi->got_tags = TRUE;         /* we always want to push global tags */

   272   avi->have_eos = FALSE;

   273 

   274   gst_adapter_clear (avi->adapter);

   275 

   276   gst_segment_init (&avi->segment, GST_FORMAT_TIME);

   277 }

   278 

   279 /* Index helper */

   280 static gst_avi_index_entry *

   281 gst_avi_demux_index_last (GstAviDemux * avi, gint stream_nr)

   282 {

   283   gint i;

   284   gst_avi_index_entry *result = NULL;

   285 

   286   for (i = avi->index_size - 1; i >= 0; i--) {

   287     if (avi->index_entries[i].stream_nr == stream_nr) {

   288       result = &avi->index_entries[i];

   289       break;

   290     }

   291   }

   292   return result;

   293 }

   294 

   295 static gst_avi_index_entry *

   296 gst_avi_demux_index_next (GstAviDemux * avi, gint stream_nr, gint last,

   297     guchar flags)

   298 {

   299   gint i;

   300   gst_avi_index_entry *result = NULL, *entry;

   301 

   302   for (i = last + 1; i < avi->index_size; i++) {

   303     entry = &avi->index_entries[i];

   304 

   305     if (entry->stream_nr != stream_nr)

   306       continue;

   307 

   308     if ((entry->flags & flags) == flags) {

   309       result = entry;

   310       break;

   311     }

   312   }

   313   return result;

   314 }

   315 

   316 static gst_avi_index_entry *

   317 gst_avi_demux_index_prev (GstAviDemux * avi, gint stream_nr, gint last,

   318     guchar flags)

   319 {

   320   gint i;

   321   gst_avi_index_entry *result = NULL, *entry;

   322 

   323   for (i = last - 1; i >= 0; i--) {

   324     entry = &avi->index_entries[i];

   325 

   326     if (entry->stream_nr != stream_nr)

   327       continue;

   328 

   329     if ((entry->flags & flags) == flags) {

   330       result = entry;

   331       break;

   332     }

   333   }

   334   return result;

   335 }

   336 

   337 static gint

   338 gst_avi_demux_index_entry_search (gst_avi_index_entry * entry, guint64 * time)

   339 {

   340   if (entry->ts < *time)

   341     return -1;

   342   else if (entry->ts > *time)

   343     return 1;

   344   return 0;

   345 }

   346 

   347 /*

   348  * gst_avi_index_entry:

   349  * @avi: Avi object

   350  * @stream_nr: stream number

   351  * @time: seek time position

   352  *

   353  * Finds the index entry which time is less or equal than the requested time.

   354  *

   355  * Returns: the found index entry or %NULL

   356  */

   357 static gst_avi_index_entry *

   358 gst_avi_demux_index_entry_for_time (GstAviDemux * avi,

   359     gint stream_nr, guint64 time)

   360 {

   361   gst_avi_index_entry *entry = NULL;

   362   guint n;

   363 

   364   GST_LOG_OBJECT (avi, "stream_nr:%d , time:%" GST_TIME_FORMAT,

   365       stream_nr, GST_TIME_ARGS (time));

   366 

   367   entry = gst_util_array_binary_search (avi->index_entries,

   368       avi->index_size,

   369       sizeof (gst_avi_index_entry),

   370       (GCompareDataFunc) gst_avi_demux_index_entry_search,

   371       GST_SEARCH_MODE_BEFORE, &time, NULL);

   372 

   373   n = entry - avi->index_entries;

   374   if (entry == NULL) {

   375     entry = &avi->index_entries[0];

   376     n = 0;

   377     while (entry->stream_nr != stream_nr && n < avi->index_size - 1) {

   378       n++;

   379       entry = &avi->index_entries[n];

   380     }

   381   } else if (entry->stream_nr != stream_nr) {

   382     while (entry->stream_nr != stream_nr && n > 0) {

   383       n--;

   384       entry = &avi->index_entries[n];

   385     }

   386   }

   387 

   388   GST_LOG_OBJECT (avi,

   389       "best at entry %u / ts:%" GST_TIME_FORMAT " / dur:%" GST_TIME_FORMAT

   390       " flags:%02x", n, GST_TIME_ARGS (entry->ts), GST_TIME_ARGS (entry->dur),

   391       entry->flags);

   392 

   393   return entry;

   394 }

   395 

   396 /* GstElement methods */

   397 

   398 #if 0

   399 static const GstFormat *

   400 gst_avi_demux_get_src_formats (GstPad * pad)

   401 {

   402   avi_stream_context *stream = gst_pad_get_element_private (pad);

   403 

   404   static const GstFormat src_a_formats[] = {

   405     GST_FORMAT_TIME,

   406     GST_FORMAT_BYTES,

   407     GST_FORMAT_DEFAULT,

   408     0

   409   };

   410   static const GstFormat src_v_formats[] = {

   411     GST_FORMAT_TIME,

   412     GST_FORMAT_DEFAULT,

   413     0

   414   };

   415 

   416   return (stream->strh->type == GST_RIFF_FCC_auds ?

   417       src_a_formats : src_v_formats);

   418 }

   419 #endif

   420 

   421 /* assumes stream->strf.auds->av_bps != 0 */

   422 static inline GstClockTime

   423 avi_stream_convert_bytes_to_time_unchecked (avi_stream_context * stream,

   424     guint64 bytes)

   425 {

   426   return gst_util_uint64_scale (bytes, GST_SECOND, stream->strf.auds->av_bps);

   427 }

   428 

   429 /* assumes stream->strh->rate != 0 */

   430 static inline GstClockTime

   431 avi_stream_convert_frames_to_time_unchecked (avi_stream_context * stream,

   432     guint64 frames)

   433 {

   434   return gst_util_uint64_scale (frames, stream->strh->scale * GST_SECOND,

   435       stream->strh->rate);

   436 }

   437 

   438 static gboolean

   439 gst_avi_demux_src_convert (GstPad * pad,

   440     GstFormat src_format,

   441     gint64 src_value, GstFormat * dest_format, gint64 * dest_value)

   442 {

   443   avi_stream_context *stream = gst_pad_get_element_private (pad);

   444   gboolean res = TRUE;

   445 

   446   GST_LOG_OBJECT (pad,

   447       "Received  src_format:%s, src_value:%" G_GUINT64_FORMAT

   448       ", dest_format:%s", gst_format_get_name (src_format), src_value,

   449       gst_format_get_name (*dest_format));

   450 

   451   if (G_UNLIKELY (src_format == *dest_format)) {

   452     *dest_value = src_value;

   453     goto done;

   454   }

   455   if (G_UNLIKELY (!stream->strh || !stream->strf.data)) {

   456     res = FALSE;

   457     goto done;

   458   }

   459   if (G_UNLIKELY (stream->strh->type == GST_RIFF_FCC_vids &&

   460           (src_format == GST_FORMAT_BYTES

   461               || *dest_format == GST_FORMAT_BYTES))) {

   462     res = FALSE;

   463     goto done;

   464   }

   465 

   466   switch (src_format) {

   467     case GST_FORMAT_TIME:

   468       switch (*dest_format) {

   469         case GST_FORMAT_BYTES:

   470           *dest_value = gst_util_uint64_scale (src_value,

   471               (guint64) stream->strf.auds->av_bps, GST_SECOND);

   472           break;

   473         case GST_FORMAT_DEFAULT:

   474         {

   475           gdouble error;

   476 

   477           *dest_value = gst_util_uint64_scale (src_value, stream->strh->rate,

   478               stream->strh->scale * GST_SECOND);

   479 

   480           /* Attempt to round to nearest integer: if the difference is more

   481            * than 0.5 (less than -0.5), it means that gst_util_uint64_scale()

   482            * just truncated an integer, while it had to be rounded

   483            */

   484           error = *dest_value * GST_SECOND -

   485               src_value * stream->strh->rate / stream->strh->scale;

   486           if (error <= -0.5)

   487             *dest_value += 1;

   488           break;

   489         }

   490         default:

   491           res = FALSE;

   492           break;

   493       }

   494       break;

   495     case GST_FORMAT_BYTES:

   496       switch (*dest_format) {

   497         case GST_FORMAT_TIME:

   498           if (stream->strf.auds->av_bps != 0) {

   499             *dest_value = avi_stream_convert_bytes_to_time_unchecked (stream,

   500                 src_value);

   501           } else

   502             res = FALSE;

   503           break;

   504         default:

   505           res = FALSE;

   506           break;

   507       }

   508       break;

   509     case GST_FORMAT_DEFAULT:

   510       switch (*dest_format) {

   511         case GST_FORMAT_TIME:

   512           *dest_value =

   513               avi_stream_convert_frames_to_time_unchecked (stream, src_value);

   514           break;

   515         default:

   516           res = FALSE;

   517           break;

   518       }

   519       break;

   520     default:

   521       res = FALSE;

   522   }

   523 

   524 done:

   525   GST_LOG_OBJECT (pad,

   526       "Returning res:%d dest_format:%s dest_value:%" G_GUINT64_FORMAT, res,

   527       gst_format_get_name (*dest_format), *dest_value);

   528   return res;

   529 }

   530 

   531 static const GstQueryType *

   532 gst_avi_demux_get_src_query_types (GstPad * pad)

   533 {

   534   static const GstQueryType src_types[] = {

   535     GST_QUERY_POSITION,

   536     GST_QUERY_DURATION,

   537     GST_QUERY_SEEKING,

   538     GST_QUERY_CONVERT,

   539     0

   540   };

   541 

   542   return src_types;

   543 }

   544 

   545 static gboolean

   546 gst_avi_demux_handle_src_query (GstPad * pad, GstQuery * query)

   547 {

   548   gboolean res = TRUE;

   549   GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad));

   550 

   551   avi_stream_context *stream = gst_pad_get_element_private (pad);

   552 

   553   if (!stream->strh || !stream->strf.data)

   554     return gst_pad_query_default (pad, query);

   555 

   556   switch (GST_QUERY_TYPE (query)) {

   557     case GST_QUERY_POSITION:{

   558       gint64 pos = 0;

   559 

   560       GST_DEBUG ("pos query for stream %d: frames %d, bytes %" G_GUINT64_FORMAT,

   561           stream->num, stream->current_frame, stream->current_byte);

   562 

   563       if (stream->strh->type == GST_RIFF_FCC_auds) {

   564         if (stream->is_vbr) {

   565           /* VBR */

   566           pos = gst_util_uint64_scale ((gint64) stream->current_frame *

   567               stream->strh->scale, GST_SECOND, (guint64) stream->strh->rate);

   568           GST_DEBUG_OBJECT (avi, "VBR convert frame %u, time %"

   569               GST_TIME_FORMAT, stream->current_frame, GST_TIME_ARGS (pos));

   570         } else if (stream->strf.auds->av_bps != 0) {

   571           /* CBR */

   572           pos = gst_util_uint64_scale (stream->current_byte, GST_SECOND,

   573               (guint64) stream->strf.auds->av_bps);

   574           GST_DEBUG_OBJECT (avi,

   575               "CBR convert bytes %" G_GUINT64_FORMAT ", time %" GST_TIME_FORMAT,

   576               stream->current_byte, GST_TIME_ARGS (pos));

   577         } else if (stream->total_frames != 0 && stream->total_bytes != 0) {

   578           /* calculate timestamps based on percentage of length */

   579           guint64 xlen = avi->avih->us_frame *

   580               avi->avih->tot_frames * GST_USECOND;

   581 

   582           if (stream->is_vbr) {

   583             pos = gst_util_uint64_scale (xlen, stream->current_frame,

   584                 stream->total_frames);

   585             GST_DEBUG_OBJECT (avi, "VBR perc convert frame %u, time %"

   586                 GST_TIME_FORMAT, stream->current_frame, GST_TIME_ARGS (pos));

   587           } else {

   588             pos = gst_util_uint64_scale (xlen, stream->current_byte,

   589                 stream->total_bytes);

   590             GST_DEBUG_OBJECT (avi, "CBR perc convert bytes %" G_GUINT64_FORMAT

   591                 ", time %" GST_TIME_FORMAT, stream->current_byte,

   592                 GST_TIME_ARGS (pos));

   593           }

   594         } else {

   595           /* we don't know */

   596           res = FALSE;

   597         }

   598       } else {

   599         if (stream->strh->rate != 0) {

   600           pos = gst_util_uint64_scale ((guint64) stream->current_frame *

   601               stream->strh->scale, GST_SECOND, (guint64) stream->strh->rate);

   602         } else {

   603           pos = stream->current_frame * avi->avih->us_frame * GST_USECOND;

   604         }

   605       }

   606       if (res) {

   607         GST_DEBUG ("pos query : %" GST_TIME_FORMAT, GST_TIME_ARGS (pos));

   608         gst_query_set_position (query, GST_FORMAT_TIME, pos);

   609       } else

   610         GST_WARNING ("pos query failed");

   611       break;

   612     }

   613     case GST_QUERY_DURATION:

   614     {

   615       GstFormat fmt;

   616 

   617       if (stream->strh->type != GST_RIFF_FCC_auds &&

   618           stream->strh->type != GST_RIFF_FCC_vids) {

   619         res = FALSE;

   620         break;

   621       }

   622 

   623       gst_query_parse_duration (query, &fmt, NULL);

   624 

   625       switch (fmt) {

   626         case GST_FORMAT_TIME:

   627           gst_query_set_duration (query, fmt, stream->duration);

   628           break;

   629         case GST_FORMAT_DEFAULT:

   630         {

   631           gint64 dur;

   632           GST_DEBUG_OBJECT (query, "total frames is %" G_GUINT32_FORMAT,

   633               stream->total_frames);

   634 

   635           if (stream->total_frames >= 0)

   636             gst_query_set_duration (query, fmt, stream->total_frames);

   637           else if (gst_pad_query_convert (pad, GST_FORMAT_TIME,

   638                   stream->duration, &fmt, &dur))

   639             gst_query_set_duration (query, fmt, dur);

   640           break;

   641         }

   642         default:

   643           res = FALSE;

   644           break;

   645       }

   646       break;

   647     }

   648     case GST_QUERY_SEEKING:{

   649       GstFormat fmt;

   650 

   651       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);

   652       if (fmt == GST_FORMAT_TIME) {

   653         gboolean seekable = TRUE;

   654 

   655         if (avi->streaming) {

   656           seekable = FALSE;

   657         } else {

   658           if (avi->index_entries == NULL) {

   659             seekable = FALSE;

   660             /* FIXME: when building index_entried, count keyframes

   661                if (!(avi->key_frame_ct > 1))

   662                seekable = FALSE;

   663              */

   664           }

   665         }

   666 

   667         gst_query_set_seeking (query, GST_FORMAT_TIME, seekable,

   668             0, stream->duration);

   669         res = TRUE;

   670       }

   671       break;

   672     }

   673     case GST_QUERY_CONVERT:{

   674       GstFormat src_fmt, dest_fmt;

   675       gint64 src_val, dest_val;

   676 

   677       gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);

   678       if ((res = gst_avi_demux_src_convert (pad, src_fmt, src_val, &dest_fmt,

   679                   &dest_val)))

   680         gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);

   681       else

   682         res = gst_pad_query_default (pad, query);

   683       break;

   684     }

   685     default:

   686       res = gst_pad_query_default (pad, query);

   687       break;

   688   }

   689 

   690   gst_object_unref (avi);

   691   return res;

   692 }

   693 

   694 #if 0

   695 static const GstEventMask *

   696 gst_avi_demux_get_event_mask (GstPad * pad)

   697 {

   698   static const GstEventMask masks[] = {

   699     {GST_EVENT_SEEK, GST_SEEK_METHOD_SET | GST_SEEK_FLAG_KEY_UNIT},

   700     {0,}

   701   };

   702 

   703   return masks;

   704 }

   705 #endif

   706 

   707 static gboolean

   708 gst_avi_demux_handle_sink_event (GstPad * pad, GstEvent * event)

   709 {

   710   gboolean res = TRUE;

   711   GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad));

   712 

   713   GST_DEBUG_OBJECT (avi,

   714       "have event type %s: %p on sink pad", GST_EVENT_TYPE_NAME (event), event);

   715 

   716   switch (GST_EVENT_TYPE (event)) {

   717     case GST_EVENT_NEWSEGMENT:

   718       /* Drop NEWSEGMENT events, new ones are generated later */

   719       gst_event_unref (event);

   720       break;

   721     case GST_EVENT_EOS:

   722     {

   723       if (avi->state != GST_AVI_DEMUX_MOVI) {

   724         gst_event_unref (event);

   725         GST_ELEMENT_ERROR (avi, STREAM, DEMUX,

   726             (NULL), ("got eos and didn't receive a complete header object"));

   727       } else if (!gst_avi_demux_push_event (avi, event)) {

   728         GST_ELEMENT_ERROR (avi, STREAM, DEMUX,

   729             (NULL), ("got eos but no streams (yet)"));

   730       }

   731       break;

   732     }

   733     default:

   734       res = gst_pad_event_default (pad, event);

   735       break;

   736   }

   737 

   738   gst_object_unref (avi);

   739 

   740   return res;

   741 }

   742 

   743 static gboolean

   744 gst_avi_demux_handle_src_event (GstPad * pad, GstEvent * event)

   745 {

   746   gboolean res = TRUE;

   747   GstAviDemux *avi = GST_AVI_DEMUX (gst_pad_get_parent (pad));

   748 

   749   GST_DEBUG_OBJECT (avi,

   750       "have event type %s: %p on src pad", GST_EVENT_TYPE_NAME (event), event);

   751 

   752   switch (GST_EVENT_TYPE (event)) {

   753     case GST_EVENT_SEEK:

   754       /* handle seeking only in pull mode */

   755       if (!avi->streaming) {

   756         res = gst_avi_demux_handle_seek (avi, pad, event);

   757         gst_event_unref (event);

   758       } else {

   759         res = gst_pad_event_default (pad, event);

   760       }

   761       break;

   762     case GST_EVENT_QOS:

   763     case GST_EVENT_NAVIGATION:

   764       res = FALSE;

   765       gst_event_unref (event);

   766       break;

   767     default:

   768       res = gst_pad_event_default (pad, event);

   769       break;

   770   }

   771 

   772   gst_object_unref (avi);

   773 

   774   return res;

   775 }

   776 

   777 /* streaming helper (push) */

   778 

   779 /*

   780  * gst_avi_demux_peek_chunk_info:

   781  * @avi: Avi object

   782  * @tag: holder for tag

   783  * @size: holder for tag size

   784  *

   785  * Peek next chunk info (tag and size)

   786  *

   787  * Returns: TRUE when one chunk info has been got

   788  */

   789 static gboolean

   790 gst_avi_demux_peek_chunk_info (GstAviDemux * avi, guint32 * tag, guint32 * size)

   791 {

   792   const guint8 *data = NULL;

   793 

   794   if (gst_adapter_available (avi->adapter) < 8) {

   795     return FALSE;

   796   }

   797 

   798   data = gst_adapter_peek (avi->adapter, 8);

   799   *tag = GST_READ_UINT32_LE (data);

   800   *size = GST_READ_UINT32_LE (data + 4);

   801 

   802   return TRUE;

   803 }

   804 

   805 /*

   806  * gst_avi_demux_peek_chunk:

   807  * @avi: Avi object

   808  * @tag: holder for tag

   809  * @size: holder for tag size

   810  *

   811  * Peek enough data for one full chunk

   812  *

   813  * Returns: %TRUE when one chunk has been got

   814  */

   815 static gboolean

   816 gst_avi_demux_peek_chunk (GstAviDemux * avi, guint32 * tag, guint32 * size)

   817 {

   818   guint32 peek_size = 0;

   819   gint available;

   820 

   821   if (!gst_avi_demux_peek_chunk_info (avi, tag, size)) {

   822     return FALSE;

   823   }

   824   /* FIXME: shouldn't this check go to gst_avi_demux_peek_chunk_info() already */

   825   if (!(*size) || (*size) == -1) {

   826     GST_INFO ("Invalid chunk size %d for tag %" GST_FOURCC_FORMAT,

   827         *size, GST_FOURCC_ARGS (*tag));

   828     return FALSE;

   829   }

   830   peek_size = (*size + 1) & ~1;

   831   available = gst_adapter_available (avi->adapter);

   832 

   833   GST_DEBUG ("Need to peek chunk of %d bytes to read chunk %" GST_FOURCC_FORMAT

   834       ", %d bytes available", *size, GST_FOURCC_ARGS (*tag), available);

   835 

   836   if (available >= (8 + peek_size)) {

   837     return TRUE;

   838   } else {

   839     return FALSE;

   840   }

   841 }

   842 

   843 /* AVI init */

   844 

   845 /*

   846  * gst_avi_demux_parse_file_header:

   847  * @element: caller element (used for errors/debug).

   848  * @buf: input data to be used for parsing.

   849  *

   850  * "Open" a RIFF/AVI file. The buffer should be at least 12

   851  * bytes long. Takes ownership of @buf.

   852  *

   853  * Returns: TRUE if the file is a RIFF/AVI file, FALSE otherwise.

   854  *          Throws an error, caller should error out (fatal).

   855  */

   856 static gboolean

   857 gst_avi_demux_parse_file_header (GstElement * element, GstBuffer * buf)

   858 {

   859   guint32 doctype;

   860 

   861   /* riff_parse posts an error */

   862   if (!gst_riff_parse_file_header (element, buf, &doctype))

   863     return FALSE;

   864 

   865   if (doctype != GST_RIFF_RIFF_AVI)

   866     goto not_avi;

   867 

   868   return TRUE;

   869 

   870   /* ERRORS */

   871 not_avi:

   872   {

   873     GST_ELEMENT_ERROR (element, STREAM, WRONG_TYPE, (NULL),

   874         ("File is not an AVI file: %" GST_FOURCC_FORMAT,

   875             GST_FOURCC_ARGS (doctype)));

   876     return FALSE;

   877   }

   878 }

   879 

   880 /*

   881  * Read AVI file tag when streaming

   882  */

   883 static GstFlowReturn

   884 gst_avi_demux_stream_init_push (GstAviDemux * avi)

   885 {

   886   if (gst_adapter_available (avi->adapter) >= 12) {

   887     GstBuffer *tmp;

   888 

   889     tmp = gst_adapter_take_buffer (avi->adapter, 12);

   890 

   891     GST_DEBUG ("Parsing avi header");

   892     if (!gst_avi_demux_parse_file_header (GST_ELEMENT (avi), tmp)) {

   893       return GST_FLOW_ERROR;

   894     }

   895     GST_DEBUG ("header ok");

   896     avi->offset += 12;

   897 

   898     avi->state = GST_AVI_DEMUX_HEADER;

   899   }

   900   return GST_FLOW_OK;

   901 }

   902 

   903 /*

   904  * Read AVI file tag

   905  */

   906 static GstFlowReturn

   907 gst_avi_demux_stream_init_pull (GstAviDemux * avi)

   908 {

   909   GstFlowReturn res;

   910   GstBuffer *buf = NULL;

   911 

   912   res = gst_pad_pull_range (avi->sinkpad, avi->offset, 12, &buf);

   913   if (res != GST_FLOW_OK)

   914     return res;

   915   else if (!gst_avi_demux_parse_file_header (GST_ELEMENT_CAST (avi), buf))

   916     goto wrong_header;

   917 

   918   avi->offset += 12;

   919 

   920   return GST_FLOW_OK;

   921 

   922   /* ERRORS */

   923 wrong_header:

   924   {

   925     GST_DEBUG_OBJECT (avi, "error parsing file header");

   926     return GST_FLOW_ERROR;

   927   }

   928 }

   929 

   930 /* AVI header handling */

   931 

   932 /*

   933  * gst_avi_demux_parse_avih:

   934  * @element: caller element (used for errors/debug).

   935  * @buf: input data to be used for parsing.

   936  * @avih: pointer to structure (filled in by function) containing

   937  *        stream information (such as flags, number of streams, etc.).

   938  *

   939  * Read 'avih' header. Discards buffer after use.

   940  *

   941  * Returns: TRUE on success, FALSE otherwise. Throws an error if

   942  *          the header is invalid. The caller should error out

   943  *          (fatal).

   944  */

   945 static gboolean

   946 gst_avi_demux_parse_avih (GstElement * element,

   947     GstBuffer * buf, gst_riff_avih ** _avih)

   948 {

   949   gst_riff_avih *avih;

   950 

   951   if (buf == NULL)

   952     goto no_buffer;

   953 

   954   if (GST_BUFFER_SIZE (buf) < sizeof (gst_riff_avih))

   955     goto avih_too_small;

   956 

   957   avih = g_memdup (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));

   958 

   959 #if (G_BYTE_ORDER == G_BIG_ENDIAN)

   960   avih->us_frame = GUINT32_FROM_LE (avih->us_frame);

   961   avih->max_bps = GUINT32_FROM_LE (avih->max_bps);

   962   avih->pad_gran = GUINT32_FROM_LE (avih->pad_gran);

   963   avih->flags = GUINT32_FROM_LE (avih->flags);

   964   avih->tot_frames = GUINT32_FROM_LE (avih->tot_frames);

   965   avih->init_frames = GUINT32_FROM_LE (avih->init_frames);

   966   avih->streams = GUINT32_FROM_LE (avih->streams);

   967   avih->bufsize = GUINT32_FROM_LE (avih->bufsize);

   968   avih->width = GUINT32_FROM_LE (avih->width);

   969   avih->height = GUINT32_FROM_LE (avih->height);

   970   avih->scale = GUINT32_FROM_LE (avih->scale);

   971   avih->rate = GUINT32_FROM_LE (avih->rate);

   972   avih->start = GUINT32_FROM_LE (avih->start);

   973   avih->length = GUINT32_FROM_LE (avih->length);

   974 #endif

   975 

   976   /* debug stuff */

   977   GST_INFO_OBJECT (element, "avih tag found:");

   978   GST_INFO_OBJECT (element, " us_frame    %u", avih->us_frame);

   979   GST_INFO_OBJECT (element, " max_bps     %u", avih->max_bps);

   980   GST_INFO_OBJECT (element, " pad_gran    %u", avih->pad_gran);

   981   GST_INFO_OBJECT (element, " flags       0x%08x", avih->flags);

   982   GST_INFO_OBJECT (element, " tot_frames  %u", avih->tot_frames);

   983   GST_INFO_OBJECT (element, " init_frames %u", avih->init_frames);

   984   GST_INFO_OBJECT (element, " streams     %u", avih->streams);

   985   GST_INFO_OBJECT (element, " bufsize     %u", avih->bufsize);

   986   GST_INFO_OBJECT (element, " width       %u", avih->width);

   987   GST_INFO_OBJECT (element, " height      %u", avih->height);

   988   GST_INFO_OBJECT (element, " scale       %u", avih->scale);

   989   GST_INFO_OBJECT (element, " rate        %u", avih->rate);

   990   GST_INFO_OBJECT (element, " start       %u", avih->start);

   991   GST_INFO_OBJECT (element, " length      %u", avih->length);

   992 

   993   *_avih = avih;

   994   gst_buffer_unref (buf);

   995 

   996   return TRUE;

   997 

   998   /* ERRORS */

   999 no_buffer:

  1000   {

  1001     GST_ELEMENT_ERROR (element, STREAM, DEMUX, (NULL), ("No buffer"));

  1002     return FALSE;

  1003   }

  1004 avih_too_small:

  1005   {

  1006     GST_ELEMENT_ERROR (element, STREAM, DEMUX, (NULL),

  1007         ("Too small avih (%d available, %d needed)",

  1008             GST_BUFFER_SIZE (buf), (int) sizeof (gst_riff_avih)));

  1009     gst_buffer_unref (buf);

  1010     return FALSE;

  1011   }

  1012 }

  1013 

  1014 /*

  1015  * gst_avi_demux_parse_superindex:

  1016  * @avi: caller element (used for debugging/errors).

  1017  * @buf: input data to use for parsing.

  1018  * @locations: locations in the file (byte-offsets) that contain

  1019  *             the actual indexes (see get_avi_demux_parse_subindex()).

  1020  *             The array ends with GST_BUFFER_OFFSET_NONE.

  1021  *

  1022  * Reads superindex (openDML-2 spec stuff) from the provided data.

  1023  *

  1024  * Returns: TRUE on success, FALSE otherwise. Indexes should be skipped

  1025  *          on error, but they are not fatal.

  1026  */

  1027 static gboolean

  1028 gst_avi_demux_parse_superindex (GstAviDemux * avi,

  1029     GstBuffer * buf, guint64 ** _indexes)

  1030 {

  1031   guint8 *data;

  1032   guint16 bpe = 16;

  1033   guint32 num, i;

  1034   guint64 *indexes;

  1035   guint size;

  1036 

  1037   *_indexes = NULL;

  1038 

  1039   size = buf ? GST_BUFFER_SIZE (buf) : 0;

  1040   if (size < 24)

  1041     goto too_small;

  1042 

  1043   data = GST_BUFFER_DATA (buf);

  1044 

  1045   /* check type of index. The opendml2 specs state that

  1046    * there should be 4 dwords per array entry. Type can be

  1047    * either frame or field (and we don't care). */

  1048   if (GST_READ_UINT16_LE (data) != 4 ||

  1049       (data[2] & 0xfe) != 0x0 || data[3] != 0x0) {

  1050     GST_WARNING_OBJECT (avi,

  1051         "Superindex for stream has unexpected "

  1052         "size_entry %d (bytes) or flags 0x%02x/0x%02x",

  1053         GST_READ_UINT16_LE (data), data[2], data[3]);

  1054     bpe = GST_READ_UINT16_LE (data) * 4;

  1055   }

  1056   num = GST_READ_UINT32_LE (&data[4]);

  1057 

  1058   indexes = g_new (guint64, num + 1);

  1059   for (i = 0; i < num; i++) {

  1060     if (size < 24 + bpe * (i + 1))

  1061       break;

  1062     indexes[i] = GST_READ_UINT64_LE (&data[24 + bpe * i]);

  1063   }

  1064   indexes[i] = GST_BUFFER_OFFSET_NONE;

  1065   *_indexes = indexes;

  1066 

  1067   gst_buffer_unref (buf);

  1068 

  1069   return TRUE;

  1070 

  1071   /* ERRORS */

  1072 too_small:

  1073   {

  1074     GST_ERROR_OBJECT (avi,

  1075         "Not enough data to parse superindex (%d available, 24 needed)", size);

  1076     if (buf)

  1077       gst_buffer_unref (buf);

  1078     return FALSE;

  1079   }

  1080 }

  1081 

  1082 /*

  1083  * gst_avi_demux_parse_subindex:

  1084  * @avi: Avi object

  1085  * @buf: input data to use for parsing.

  1086  * @stream: stream context.

  1087  * @entries_list: a list (returned by the function) containing all the

  1088  *           indexes parsed in this specific subindex. The first

  1089  *           entry is also a pointer to allocated memory that needs

  1090  *           to be free´ed. May be NULL if no supported indexes were

  1091  *           found.

  1092  *

  1093  * Reads superindex (openDML-2 spec stuff) from the provided data.

  1094  * The buffer will be discarded after use.

  1095  *

  1096  * Returns: TRUE on success, FALSE otherwise. Errors are fatal, we

  1097  *          throw an error, caller should bail out asap.

  1098  */

  1099 static gboolean

  1100 gst_avi_demux_parse_subindex (GstAviDemux * avi,

  1101     GstBuffer * buf, avi_stream_context * stream, GList ** _entries_list)

  1102 {

  1103   guint8 *data = GST_BUFFER_DATA (buf);

  1104   guint16 bpe;

  1105   guint32 num, i;

  1106   guint64 baseoff;

  1107   gst_avi_index_entry *entries, *entry;

  1108   GList *entries_list = NULL;

  1109   guint size;

  1110 

  1111   *_entries_list = NULL;

  1112 

  1113   size = buf ? GST_BUFFER_SIZE (buf) : 0;

  1114 

  1115   /* check size */

  1116   if (size < 24)

  1117     goto too_small;

  1118 

  1119   /* We don't support index-data yet */

  1120   if (data[3] & 0x80)

  1121     goto not_implemented;

  1122 

  1123   /* check type of index. The opendml2 specs state that

  1124    * there should be 4 dwords per array entry. Type can be

  1125    * either frame or field (and we don't care). */

  1126   bpe = (data[2] & 0x01) ? 12 : 8;

  1127   if (GST_READ_UINT16_LE (data) != bpe / 4 ||

  1128       (data[2] & 0xfe) != 0x0 || data[3] != 0x1) {

  1129     GST_WARNING_OBJECT (avi,

  1130         "Superindex for stream %d has unexpected "

  1131         "size_entry %d (bytes) or flags 0x%02x/0x%02x",

  1132         stream->num, GST_READ_UINT16_LE (data), data[2], data[3]);

  1133     bpe = GST_READ_UINT16_LE (data) * 4;

  1134   }