4 * Copyright (c) 2012, Collabora Ltd.
5 * Author: Thibault Saunier <thibault.saunier@collabora.com>
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
27 #include "media-descriptor.h"
29 #include "gst-validate-internal.h"
31 struct _GstValidateMediaDescriptorPrivate
33 GstValidateMediaFileNode *filenode;
36 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GstValidateMediaDescriptor,
37 gst_validate_media_descriptor, GST_TYPE_OBJECT,
38 G_ADD_PRIVATE (GstValidateMediaDescriptor)
39 G_IMPLEMENT_INTERFACE (GST_TYPE_VALIDATE_REPORTER, NULL));
42 free_tagnode (GstValidateMediaTagNode * tagnode)
44 g_free (tagnode->str_open);
45 g_free (tagnode->str_close);
47 gst_tag_list_unref (tagnode->taglist);
49 g_slice_free (GstValidateMediaTagNode, tagnode);
53 free_tagsnode (GstValidateMediaTagsNode * tagsnode)
55 g_free (tagsnode->str_open);
56 g_free (tagsnode->str_close);
57 g_list_free_full (tagsnode->tags, (GDestroyNotify) free_tagnode);
58 g_slice_free (GstValidateMediaTagsNode, tagsnode);
62 free_framenode (GstValidateMediaFrameNode * framenode)
64 g_free (framenode->str_open);
65 g_free (framenode->str_close);
68 gst_buffer_unref (framenode->buf);
70 g_slice_free (GstValidateMediaFrameNode, framenode);
74 free_segmentnode (GstValidateSegmentNode * segmentnode)
76 g_free (segmentnode->str_open);
77 g_free (segmentnode->str_close);
79 g_slice_free (GstValidateSegmentNode, segmentnode);
83 free_streamnode (GstValidateMediaStreamNode * streamnode)
86 gst_caps_unref (streamnode->caps);
88 g_list_free_full (streamnode->frames, (GDestroyNotify) free_framenode);
89 g_list_free_full (streamnode->segments, (GDestroyNotify) free_segmentnode);
92 gst_object_unref (streamnode->pad);
95 free_tagsnode (streamnode->tags);
97 g_free (streamnode->padname);
98 g_free (streamnode->id);
99 g_free (streamnode->str_open);
100 g_free (streamnode->str_close);
101 g_slice_free (GstValidateMediaStreamNode, streamnode);
105 gst_validate_filenode_free (GstValidateMediaFileNode * filenode)
107 g_list_free_full (filenode->streams, (GDestroyNotify) free_streamnode);
109 free_tagsnode (filenode->tags);
111 g_free (filenode->uri);
114 gst_caps_unref (filenode->caps);
116 g_free (filenode->str_open);
117 g_free (filenode->str_close);
119 g_slice_free (GstValidateMediaFileNode, filenode);
123 gst_validate_tag_node_compare
124 (GstValidateMediaTagNode * tnode, const GstTagList * tlist)
126 if (gst_structure_is_equal (GST_STRUCTURE (tlist),
127 GST_STRUCTURE (tnode->taglist)) == FALSE) {
145 gst_validate_media_descriptor_dispose (GstValidateMediaDescriptor * self)
147 G_OBJECT_CLASS (gst_validate_media_descriptor_parent_class)->dispose (G_OBJECT
152 gst_validate_media_descriptor_finalize (GstValidateMediaDescriptor * self)
154 if (self->priv->filenode)
155 gst_validate_filenode_free (self->priv->filenode);
157 G_OBJECT_CLASS (gst_validate_media_descriptor_parent_class)->finalize
162 gst_validate_media_descriptor_init (GstValidateMediaDescriptor * self)
164 self->priv = gst_validate_media_descriptor_get_instance_private (self);
165 self->priv->filenode = g_slice_new0 (GstValidateMediaFileNode);
169 _set_property (GObject * object, guint prop_id,
170 const GValue * value, GParamSpec * pspec)
174 /* we assume the runner is valid as long as this scenario is,
176 gst_validate_reporter_set_runner (GST_VALIDATE_REPORTER (object),
177 g_value_get_object (value));
185 _get_property (GObject * object, guint prop_id,
186 GValue * value, GParamSpec * pspec)
190 /* we assume the runner is valid as long as this scenario is,
192 g_value_take_object (value,
193 gst_validate_reporter_get_runner (GST_VALIDATE_REPORTER (object)));
201 gst_validate_media_descriptor_class_init (GstValidateMediaDescriptorClass *
204 GObjectClass *object_class = G_OBJECT_CLASS (self_class);
206 object_class->dispose =
207 (void (*)(GObject * object)) gst_validate_media_descriptor_dispose;
208 object_class->finalize =
209 (void (*)(GObject * object)) gst_validate_media_descriptor_finalize;
211 object_class->get_property = _get_property;
212 object_class->set_property = _set_property;
214 g_object_class_install_property (object_class, PROP_RUNNER,
215 g_param_spec_object ("validate-runner", "VALIDATE Runner",
216 "The Validate runner to report errors to",
217 GST_TYPE_VALIDATE_RUNNER,
218 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
222 compare_tags (GstValidateMediaDescriptor * ref,
223 GstValidateMediaStreamNode * rstream, GstValidateMediaStreamNode * cstream)
226 GstValidateMediaTagNode *rtag, *ctag;
227 GList *rtag_list, *ctag_list;
228 GstValidateMediaTagsNode *rtags, *ctags;
230 rtags = rstream->tags;
231 ctags = cstream->tags;
232 if (!rtags && !ctags)
234 else if (!rtags && ctags) {
236 GString *all_tags = g_string_new (NULL);
238 for (taglist = ctags->tags; taglist; taglist = taglist->next) {
239 gchar *stags = gst_tag_list_to_string (((GstValidateMediaTagNode *)
240 taglist->data)->taglist);
242 g_string_append_printf (all_tags, "%s\n", stags);
246 GST_VALIDATE_REPORT (ref, FILE_TAG_DETECTION_INCORRECT,
247 "Reference descriptor for stream %s has NO tags"
248 " but tags found: %s", rstream->id, all_tags->str);
250 g_string_free (all_tags, TRUE);
253 } else if (rtags && !ctags) {
255 GString *all_tags = g_string_new (NULL);
257 for (taglist = rtags->tags; taglist; taglist = taglist->next) {
258 gchar *stags = gst_tag_list_to_string (((GstValidateMediaTagNode *)
259 taglist->data)->taglist);
261 g_string_append_printf (all_tags, "%s\n", stags);
265 GST_VALIDATE_REPORT (ref, FILE_TAG_DETECTION_INCORRECT,
266 "Reference descriptor for stream %s has tags:\n %s\n"
267 " but NO tags found on the stream", rstream->id, all_tags->str);
269 g_string_free (all_tags, TRUE);
273 for (rtag_list = rtags->tags; rtag_list; rtag_list = rtag_list->next) {
274 rtag = rtag_list->data;
276 for (ctag_list = ctags->tags; ctag_list; ctag_list = ctag_list->next) {
277 ctag = ctag_list->data;
278 if (gst_tag_list_is_equal (rtag->taglist, ctag->taglist)) {
285 if (found == FALSE) {
286 gchar *rtaglist = gst_tag_list_to_string (rtag->taglist);
288 GST_VALIDATE_REPORT (ref, FILE_TAG_DETECTION_INCORRECT,
289 "Reference descriptor for stream %s has tags %s"
290 " but no equivalent taglist was found on the compared stream",
291 rstream->id, rtaglist);
301 /* Workaround false warning caused by differnet file path */
303 stream_id_is_equal (const gchar * uri, const gchar * rid, const gchar * cid)
306 const gchar *stream_id;
308 /* Simple case it's the same */
309 if (g_strcmp0 (rid, cid) == 0)
312 /* If it's not from file or from our local http server, it should have been the same */
313 if (!g_str_has_prefix (uri, "file://")
314 && !g_str_has_prefix (uri, "imagesequence:/")
315 && !g_str_has_prefix (uri, "http://127.0.0.1"))
318 /* taken from basesrc, compute the reference stream-id */
319 cs = g_checksum_new (G_CHECKSUM_SHA256);
320 g_checksum_update (cs, (const guchar *) uri, strlen (uri));
322 stream_id = g_checksum_get_string (cs);
324 /* If the reference stream_id is the URI SHA256, that means we have a single
325 * stream file (no demuxing), just assume it's the same id */
326 if (g_strcmp0 (rid, stream_id) == 0) {
327 g_checksum_free (cs);
331 /* It should always be prefixed with the SHA256, otherwise it likely means
332 * that basesrc is no longer using a SHA256 checksum on the URI, and this
333 * workaround will need to be fixed */
334 if (!g_str_has_prefix (rid, stream_id)) {
335 g_checksum_free (cs);
338 g_checksum_free (cs);
340 /* we strip the IDS to the delimitor, and then compare */
341 rid = strchr (rid, '/');
342 cid = strchr (cid, '/');
344 if (rid == NULL || cid == NULL)
347 if (g_strcmp0 (rid, cid) == 0)
354 compare_segments (GstValidateMediaDescriptor * ref,
356 GstValidateMediaStreamNode * rstream,
357 GstValidateSegmentNode * rsegment, GstValidateSegmentNode * csegment)
359 if (rsegment->next_frame_id != csegment->next_frame_id) {
360 GST_VALIDATE_REPORT (ref, FILE_SEGMENT_INCORRECT,
361 "Segment %" GST_SEGMENT_FORMAT
362 " didn't come before the same frame ID, expected to come before %d, came before %d",
363 &rsegment->segment, rsegment->next_frame_id, csegment->next_frame_id);
366 #define CHECK_SEGMENT_FIELD(fieldname, format) \
367 if (rsegment->segment.fieldname != csegment->segment.fieldname) { \
368 GST_ERROR ("Expected: %" GST_SEGMENT_FORMAT " got: %" GST_SEGMENT_FORMAT, \
369 &rsegment->segment, &csegment->segment); \
370 GST_VALIDATE_REPORT (ref, FILE_SEGMENT_INCORRECT, \
371 "Stream %s segment %d has " #fieldname \
372 " mismatch, Expected " format " got: " format , \
373 rstream->id, i, rsegment->segment.fieldname, \
374 csegment->segment.fieldname); \
378 CHECK_SEGMENT_FIELD (flags, "%d");
379 CHECK_SEGMENT_FIELD (rate, "%f");
380 CHECK_SEGMENT_FIELD (applied_rate, "%f");
381 CHECK_SEGMENT_FIELD (base, "%" G_GUINT64_FORMAT);
382 CHECK_SEGMENT_FIELD (offset, "%" G_GUINT64_FORMAT);
383 CHECK_SEGMENT_FIELD (start, "%" G_GUINT64_FORMAT);
384 CHECK_SEGMENT_FIELD (stop, "%" G_GUINT64_FORMAT);
385 CHECK_SEGMENT_FIELD (time, "%" G_GUINT64_FORMAT);
386 /* We do not compare segment position since it's a field for usage only within the element */
387 /* CHECK_SEGMENT_FIELD (position, "%" G_GUINT64_FORMAT); */
388 CHECK_SEGMENT_FIELD (duration, "%" G_GUINT64_FORMAT);
394 append_segment_diff (GString * diff, char diffsign, GList * segments)
398 for (tmp = segments; tmp; tmp = tmp->next) {
400 gst_info_strdup_printf ("%c %" GST_SEGMENT_FORMAT "\n", diffsign,
401 &((GstValidateSegmentNode *) tmp->data)->segment);
402 g_string_append (diff, ssegment);
409 compare_segment_list (GstValidateMediaDescriptor * ref,
410 GstValidateMediaStreamNode * rstream, GstValidateMediaStreamNode * cstream)
413 GList *rsegments, *csegments;
415 /* Keep compatibility with media stream files that do not have segments */
416 if (rstream->segments
417 && g_list_length (rstream->segments) !=
418 g_list_length (cstream->segments)) {
419 GString *diff = g_string_new (NULL);
421 append_segment_diff (diff, '-', rstream->segments);
422 append_segment_diff (diff, '+', cstream->segments);
423 GST_VALIDATE_REPORT (ref, FILE_SEGMENT_INCORRECT,
424 "Stream reference has %i segments, compared one has %i segments\n%s",
425 g_list_length (rstream->segments), g_list_length (cstream->segments),
427 g_string_free (diff, TRUE);
430 for (i = 0, rsegments = rstream->segments, csegments = cstream->segments;
432 rsegments = rsegments->next, csegments = csegments->next, i++) {
433 GstValidateSegmentNode *rsegment, *csegment;
435 if (csegments == NULL) {
436 /* The list was checked to be of the same size */
437 g_assert_not_reached ();
441 rsegment = rsegments->data;
442 csegment = csegments->data;
444 if (!compare_segments (ref, i, rstream, rsegment, csegment))
452 compare_frames (GstValidateMediaDescriptor * ref,
453 GstValidateMediaStreamNode *
454 rstream, GstValidateMediaFrameNode * rframe,
455 GstValidateMediaFrameNode * cframe)
457 if (rframe->id != cframe->id) {
458 GST_VALIDATE_REPORT (ref, FILE_FRAMES_INCORRECT,
459 "Stream frame %s ids mismatch: %" G_GUINT64_FORMAT " != %"
460 G_GUINT64_FORMAT, rstream->id, rframe->id, cframe->id);
463 #define CHECK_FRAME_FIELD(fieldname, format, unknown_value) \
464 if (rframe->fieldname != unknown_value && rframe->fieldname != cframe->fieldname) { \
465 GST_VALIDATE_REPORT (ref, FILE_FRAMES_INCORRECT, \
466 "Stream %s frames with id %" G_GUINT64_FORMAT " have " #fieldname \
467 " mismatch. Expected " format ", got " format, rstream->id, \
468 rframe->id, rframe->fieldname, cframe->fieldname); \
472 CHECK_FRAME_FIELD (pts, "%" G_GUINT64_FORMAT, GST_VALIDATE_UNKNOWN_UINT64);
473 CHECK_FRAME_FIELD (dts, "%" G_GUINT64_FORMAT, GST_VALIDATE_UNKNOWN_UINT64);
474 CHECK_FRAME_FIELD (duration, "%" G_GUINT64_FORMAT,
475 GST_VALIDATE_UNKNOWN_UINT64);
476 CHECK_FRAME_FIELD (running_time, "%" G_GUINT64_FORMAT,
477 GST_VALIDATE_UNKNOWN_UINT64);
478 CHECK_FRAME_FIELD (is_keyframe, "%d", GST_VALIDATE_UNKNOWN_BOOL);
484 compare_frames_list (GstValidateMediaDescriptor * ref,
485 GstValidateMediaStreamNode * rstream, GstValidateMediaStreamNode * cstream)
487 GList *rframes, *cframes;
489 if (g_list_length (rstream->frames) != g_list_length (cstream->frames)) {
490 GST_VALIDATE_REPORT (ref, FILE_FRAMES_INCORRECT,
491 "Stream reference has %i frames, compared one has %i frames",
492 g_list_length (rstream->frames), g_list_length (cstream->frames));
496 for (rframes = rstream->frames, cframes = cstream->frames; rframes;
497 rframes = g_list_next (rframes), cframes = g_list_next (cframes)) {
498 GstValidateMediaFrameNode *rframe, *cframe;
500 if (cframes == NULL) {
501 /* The list was checked to be of the same size */
502 g_assert_not_reached ();
506 rframe = rframes->data;
507 cframe = cframes->data;
509 if (!compare_frames (ref, rstream, rframe, cframe)) {
518 caps_cleanup_parsing_fields (GstCaps * caps)
521 GstCaps *res = gst_caps_copy (caps);
523 for (i = 0; i < gst_caps_get_size (res); i++) {
524 GstStructure *s = gst_caps_get_structure (res, i);
526 gst_structure_remove_fields (s, "stream-format", "codec_data", "parsed",
527 "frames", "alignment", NULL);
533 /* Return TRUE if found FALSE otherwise */
535 compare_streams (GstValidateMediaDescriptor * ref,
536 GstValidateMediaStreamNode * rstream, GstValidateMediaStreamNode * cstream)
538 GstCaps *rcaps, *ccaps;
540 if (!stream_id_is_equal (ref->priv->filenode->uri, rstream->id, cstream->id))
543 rcaps = caps_cleanup_parsing_fields (rstream->caps);
544 ccaps = caps_cleanup_parsing_fields (cstream->caps);
546 if (!gst_caps_is_equal (rcaps, ccaps)) {
547 gchar *rcaps_str = gst_caps_to_string (rcaps),
548 *ccaps_str = gst_caps_to_string (ccaps);
549 GST_VALIDATE_REPORT (ref, FILE_PROFILE_INCORRECT,
550 "Reference descriptor for stream %s has caps: %s"
551 " but compared stream %s has caps: %s",
552 rstream->id, rcaps_str, cstream->id, ccaps_str);
557 gst_caps_unref (rcaps);
558 gst_caps_unref (ccaps);
559 /* We ignore the return value on purpose as this is not critical */
560 compare_tags (ref, rstream, cstream);
562 compare_segment_list (ref, rstream, cstream);
563 compare_frames_list (ref, rstream, cstream);
569 gst_validate_media_descriptors_compare (GstValidateMediaDescriptor * ref,
570 GstValidateMediaDescriptor * compared)
573 GstValidateMediaFileNode
574 * rfilenode = ref->priv->filenode, *cfilenode = compared->priv->filenode;
576 if (rfilenode->duration != cfilenode->duration) {
577 GST_VALIDATE_REPORT (ref, FILE_DURATION_INCORRECT,
578 "Duration %" GST_TIME_FORMAT " is different from the reference %"
579 GST_TIME_FORMAT, GST_TIME_ARGS (cfilenode->duration),
580 GST_TIME_ARGS (rfilenode->duration));
583 if (rfilenode->seekable != cfilenode->seekable) {
584 GST_VALIDATE_REPORT (ref, FILE_SEEKABLE_INCORRECT,
585 "File known as %s but is reported %s now",
586 rfilenode->seekable ? "seekable" : "not seekable",
587 cfilenode->seekable ? "seekable" : "not seekable");
590 if (g_list_length (rfilenode->streams) != g_list_length (cfilenode->streams)) {
591 GST_VALIDATE_REPORT (ref, FILE_PROFILE_INCORRECT,
592 "Reference descriptor has %i streams != compared which has %i streams",
593 g_list_length (rfilenode->streams), g_list_length (cfilenode->streams));
599 for (rstream_list = rfilenode->streams; rstream_list;
600 rstream_list = rstream_list->next) {
602 gboolean sfound = FALSE;
604 for (cstream_list = cfilenode->streams; cstream_list;
605 cstream_list = cstream_list->next) {
607 sfound = compare_streams (ref, rstream_list->data, cstream_list->data);
613 GST_VALIDATE_REPORT (ref, FILE_PROFILE_INCORRECT,
614 "Could not find stream %s in the compared descriptor",
615 ((GstValidateMediaStreamNode *) rstream_list->data)->id);
623 gst_validate_media_descriptor_detects_frames (GstValidateMediaDescriptor * self)
625 g_return_val_if_fail (GST_IS_VALIDATE_MEDIA_DESCRIPTOR (self), FALSE);
626 g_return_val_if_fail (self->priv->filenode, FALSE);
628 return self->priv->filenode->frame_detection;
632 * gst_validate_media_descriptor_get_buffers: (skip):
635 gst_validate_media_descriptor_get_buffers (GstValidateMediaDescriptor * self,
636 GstPad * pad, GCompareFunc compare_func, GList ** bufs)
638 GList *tmpstream, *tmpframe;
639 gboolean check = (pad == NULL), ret = FALSE;
640 GstCaps *pad_caps = gst_pad_get_current_caps (pad);
642 g_return_val_if_fail (GST_IS_VALIDATE_MEDIA_DESCRIPTOR (self), FALSE);
643 g_return_val_if_fail (self->priv->filenode, FALSE);
645 for (tmpstream = self->priv->filenode->streams;
646 tmpstream; tmpstream = tmpstream->next) {
647 GstValidateMediaStreamNode
648 * streamnode = (GstValidateMediaStreamNode *) tmpstream->data;
650 if (pad && streamnode->pad == pad)
653 if (!streamnode->pad && gst_caps_is_subset (pad_caps, streamnode->caps)) {
659 for (tmpframe = streamnode->frames; tmpframe; tmpframe = tmpframe->next) {
662 g_list_insert_sorted (*bufs,
664 (GstValidateMediaFrameNode
665 *) tmpframe->data)->buf), compare_func);
668 g_list_prepend (*bufs,
670 (GstValidateMediaFrameNode *) tmpframe->data)->buf));
681 if (compare_func == NULL)
682 *bufs = g_list_reverse (*bufs);
684 gst_caps_unref (pad_caps);
689 gst_validate_media_descriptor_has_frame_info (GstValidateMediaDescriptor * self)
693 for (tmpstream = self->priv->filenode->streams;
694 tmpstream; tmpstream = tmpstream->next) {
695 GstValidateMediaStreamNode
696 * streamnode = (GstValidateMediaStreamNode *) tmpstream->data;
698 if (g_list_length (streamnode->frames))
706 gst_validate_media_descriptor_get_duration (GstValidateMediaDescriptor * self)
708 g_return_val_if_fail (GST_IS_VALIDATE_MEDIA_DESCRIPTOR (self), FALSE);
709 g_return_val_if_fail (self->priv->filenode, FALSE);
711 return self->priv->filenode->duration;
715 gst_validate_media_descriptor_get_seekable (GstValidateMediaDescriptor * self)
717 g_return_val_if_fail (GST_IS_VALIDATE_MEDIA_DESCRIPTOR (self), FALSE);
718 g_return_val_if_fail (self->priv->filenode, FALSE);
720 return self->priv->filenode->seekable;
724 * gst_validate_media_descriptor_get_pads: (skip):
727 gst_validate_media_descriptor_get_pads (GstValidateMediaDescriptor * self)
729 GList *ret = NULL, *tmp;
731 for (tmp = self->priv->filenode->streams; tmp; tmp = tmp->next) {
732 GstValidateMediaStreamNode
733 * snode = (GstValidateMediaStreamNode *) tmp->data;
734 ret = g_list_append (ret, gst_pad_new (snode->padname, GST_PAD_UNKNOWN));
741 GstValidateMediaFileNode *
742 gst_validate_media_descriptor_get_file_node (GstValidateMediaDescriptor * self)
744 return self->priv->filenode;