mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-27 20:21:24 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/hdvparse/gsthdvparse.c
Tim-Philipp Müller 9e1b75fda3 Fix FSF address 
https://bugzilla.gnome.org/show_bug.cgi?id=687520
2012-11-04 00:09:59 +00:00

890 lines
27 KiB
C
Raw Blame History

/*
* GStreamer
* Copyright (C) 2009 Edward Hervey <bilboed@bilboed.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:element-HDVParse
*
* <refsect2>
* <title>Example launch line</title>
* <para>
* <programlisting>
* gst-launch -v -m filesrc ! mpegtsdemux ! hdvparse ! fakesink silent=TRUE
* </programlisting>
* </para>
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include "gsthdvparse.h"
GST_DEBUG_CATEGORY_STATIC (gst_hdvparse_debug);
#define GST_CAT_DEFAULT gst_hdvparse_debug
/* Filter signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
PROP_0,
};
#define CLOCK_BASE 9LL
#define CLOCK_FREQ (CLOCK_BASE * 10000)
#define MPEGTIME_TO_GSTTIME(time) (gst_util_uint64_scale ((time), \
GST_MSECOND/10, CLOCK_BASE))
#define GSTTIME_TO_MPEGTIME(time) (gst_util_uint64_scale ((time), \
CLOCK_BASE, GST_MSECOND/10))
/* If set to 1, then extra validation will be applied to check
* for complete spec compliance wherever applicable. */
#define VALIDATE 0
/* Binary-coded decimal reading macro */
#define BCD(c) ( ((((c) >> 4) & 0x0f) * 10) + ((c) & 0x0f) )
/* Same as before, but with a mask */
#define BCD_M(c, mask) (BCD ((c) & (mask)))
/* the capabilities of the inputs and outputs.
*
* describe the real formats here.
*/
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("hdv/aux-v;hdv/aux-a")
);
static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS
("hdv/aux-v,parsed=(boolean)True;hdv/aux-a,parsed=(boolean)True")
);
/* debug category for fltering log messages
*
* exchange the string 'Template HDVParse' with your description
*/
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (gst_hdvparse_debug, "hdvparse", 0, "HDV private stream parser");
GST_BOILERPLATE_FULL (GstHDVParse, gst_hdvparse, GstBaseTransform,
GST_TYPE_BASE_TRANSFORM, DEBUG_INIT);
static GstFlowReturn gst_hdvparse_transform_ip (GstBaseTransform * base,
GstBuffer * outbuf);
static GstCaps *gst_hdvparse_transform_caps (GstBaseTransform * trans,
GstPadDirection dir, GstCaps * incaps);
/* GObject vmethod implementations */
static void
gst_hdvparse_base_init (gpointer klass)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&src_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&sink_template));
gst_element_class_set_static_metadata (element_class, "HDVParser",
"Data/Parser",
"HDV private stream Parser", "Edward Hervey <bilboed@bilboed.com>");
}
/* initialize the HDVParse's class */
static void
gst_hdvparse_class_init (GstHDVParseClass * klass)
{
GST_BASE_TRANSFORM_CLASS (klass)->transform_ip =
GST_DEBUG_FUNCPTR (gst_hdvparse_transform_ip);
GST_BASE_TRANSFORM_CLASS (klass)->transform_caps =
GST_DEBUG_FUNCPTR (gst_hdvparse_transform_caps);
}
/* initialize the new element
* initialize instance structure
*/
static void
gst_hdvparse_init (GstHDVParse * filter, GstHDVParseClass * klass)
{
GstBaseTransform *transform = GST_BASE_TRANSFORM (filter);
gst_base_transform_set_in_place (transform, TRUE);
gst_base_transform_set_passthrough (transform, TRUE);
}
static GstCaps *
gst_hdvparse_transform_caps (GstBaseTransform * trans, GstPadDirection dir,
GstCaps * incaps)
{
GstCaps *res = NULL;
GstStructure *st = gst_caps_get_structure (incaps, 0);
GST_WARNING_OBJECT (trans, "dir:%d, incaps:%" GST_PTR_FORMAT, dir, incaps);
if (dir == GST_PAD_SINK) {
res = gst_caps_new_simple (gst_structure_get_name (st),
"parsed", G_TYPE_BOOLEAN, TRUE, NULL);
} else {
res = gst_caps_new_simple (gst_structure_get_name (st), NULL);
}
return res;
}
static inline const gchar *
sfr_to_framerate (guint8 sfr)
{
switch (sfr) {
case 4:
return "30000/1001";
case 3:
return "25/1";
case 1:
return "24000/1001";
default:
return "RESERVED";
}
}
static GstFlowReturn
parse_dv_multi_pack (GstHDVParse * filter, guint8 * data, guint64 size,
GstStructure * st)
{
guint64 offs = 1;
while (size / 5) {
GST_LOG ("DV pack 0x%x", data[offs]);
switch (data[offs]) {
case 0x70:{
guint8 irispos, ae, agc, wbmode, whitebal, focusmode, focuspos;
irispos = data[offs + 1] & 0x3f;
ae = data[offs + 2] >> 4;
agc = data[offs + 2] & 0xf;
wbmode = data[offs + 3] >> 5;
whitebal = data[offs + 3] & 0x1f;
focusmode = data[offs + 4] >> 7;
focuspos = data[offs + 4] & 0x7f;
GST_LOG (" Consumer Camera 1");
GST_LOG (" Iris position %d (0x%x)", irispos, irispos);
/* Iris position = 2 ^ (IP/8) (for 0 < IP < 0x3C) */
if (irispos < 0x3c) {
GST_LOG (" IRIS F%0.2f", powf (2.0, (((float) irispos) / 8.0)));
gst_structure_set (st, "aperture-fnumber", G_TYPE_FLOAT,
powf (2.0, (((float) irispos) / 8.0)), NULL);
} else if (irispos == 0x3d) {
GST_LOG (" IRIS < 1.0");
} else if (irispos == 0x3e) {
GST_LOG (" IRIS closed");
}
/* AE Mode:
* 0 : Full automatic
* 1 : Gain Priority mode
* 2 : Shutter Priority mode
* 3 : Iris priority mode
* 4 : Manual
* ..: Reserved
* F : No information */
GST_LOG (" AE Mode: %d (0x%x)", ae, ae);
GST_LOG (" AGC: %d (0x%x)", agc, agc);
if (agc < 0xd) {
/* This is what the spec says.. but I'm not seeing the same on my camera :( */
GST_LOG (" Gain:%02.2fdB", (agc * 3.0) - 3.0);
gst_structure_set (st, "gain", G_TYPE_FLOAT, (agc * 3.0) - 3.0, NULL);
}
/* White balance mode
* 0 : Automatic
* 1 : hold
* 2 : one push
* 3 : pre-set
* 7 : no-information */
if (wbmode != 7)
GST_LOG (" White balance mode : %d (0x%x)", wbmode, wbmode);
/* White balance
* 0 : Candle
* 1 : Incandescent lamp
* 2 : low color temperature fluorescent lamp
* 3 : high color temperature fluorescent lamp
* 4 : sunlight
* 5 : cloudy weather
* F : No information
*/
if (whitebal != 0xf)
GST_LOG (" White balance : %d (0x%x)", whitebal, whitebal);
if (focuspos != 0x7f) {
GST_LOG (" Focus mode : %s", focusmode ? "MANUAL" : "AUTOMATIC");
GST_LOG (" Focus position: %d (0x%x)", focuspos, focuspos);
}
}
break;
case 0x71:{
guint8 v_pan, h_pan, focal_length, e_zoom;
gboolean is, zen;
v_pan = data[offs + 1] & 0x3f;
is = data[offs + 2] >> 7;
h_pan = data[offs + 2] & 0x7f;
focal_length = data[offs + 3];
zen = data[offs + 4] >> 7;
e_zoom = data[offs + 4] & 0x7f;
GST_LOG (" Consumer Camera 2");
if (v_pan != 0x3f)
GST_LOG (" Vertical Panning : %d (0x%d)", v_pan, v_pan);
if (h_pan != 0x7f)
GST_LOG (" Horizontal Panning : %d (0x%d)", h_pan, h_pan);
GST_LOG (" Stabilizer : %s", is ? "OFF" : "ON");
if (focal_length != 0xff)
GST_LOG (" Focal Length : %f mm",
(focal_length & 0x7f) * pow (10, focal_length & 0x80));
if (zen == 0)
GST_LOG (" Electric Zoom %02dd.%03d", e_zoom >> 5, e_zoom & 0x1f);
}
break;
case 0x7f:{
guint16 speed;
guint16 speedint;
GST_LOG (" Shutter");
if (data[offs + 1] != 0xff)
GST_LOG (" Shutter Speed (1) : %d, 0x%x",
data[offs + 1], data[offs + 1]);
if (data[offs + 2] != 0xff)
GST_LOG (" Shutter Speed (1) : %d, 0x%x",
data[offs + 2], data[offs + 2]);
speed = data[offs + 3] | (data[offs + 4] & 0x7f) << 8;
/* The shutter speed is 1/(CSS * horizontal scanning period) */
/* FIXME : 34000 is a value interpolated by observations */
speedint = (int) (34000.0 / (float) speed);
/* Only the highest two decimal digits are valid */
if (speedint > 100)
speedint = speedint / 10 * 10;
GST_LOG (" Shutter speed : 1/%d", speedint);
gst_structure_set (st, "shutter-speed", GST_TYPE_FRACTION,
1, speedint, NULL);
}
break;
default:
GST_MEMDUMP ("Unknown pack", data + offs, 5);
break;
}
size -= 5;
offs += 5;
}
return GST_FLOW_OK;
}
static GstFlowReturn
parse_video_frame (GstHDVParse * filter, guint8 * data, guint64 size,
GstStructure * st)
{
guint32 etn, bitrate;
guint8 nbframes, data_h, hdr_size, sfr, sdm;
guint8 aspect, framerate, profile, level, format, chroma;
guint8 gop_n, gop_m, cgms, recst, abst;
guint16 vbv_delay, width, height, vbv_buffer;
guint64 dts;
gboolean pf, tf, rf;
GST_LOG_OBJECT (filter, "Video Frame Pack");
/* Byte | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* ---------------------------------
* 0 | Size (0x39) |
* ---------------------------------
* 1 | |
* 2 | ETN |
* 3 | |
* ---------------------------------
*/
if (data[0] != 0x39) {
GST_WARNING ("Invalid size for Video frame");
return GST_FLOW_ERROR;
}
etn = data[3] << 16 | data[2] << 8 | data[1];
GST_LOG_OBJECT (filter, " ETN : %" G_GUINT32_FORMAT, etn);
/* Pack-V Information
* ---------------------------------
* 4 | Number of Video Frames |
* ---------------------------------
* 5 | 0 | 0 | 0 | 0 | DATA-H |
* ---------------------------------
* 6 | VBV |
* 7 | DELAY |
* ---------------------------------
* 8 | HEADER SIZE |
* ---------------------------------
* 9 | |
* 10 | DTS |
* 11 | |
* 12 | |
* ----------------------------- |
* 13 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | |
* ---------------------------------
* 14 |PF |TF |RF | 0 | SFR |
* ---------------------------------
*/
nbframes = data[4];
if (VALIDATE && (data[5] >> 4))
return GST_FLOW_ERROR;
data_h = data[5] & 0xf;
vbv_delay = data[6] | data[7] << 8;
hdr_size = data[8];
dts = data[9] | data[10] << 8 | data[11] << 16 | data[12] << 24;
dts |= (guint64) (data[13] & 0x1) << 32;
if (G_UNLIKELY (VALIDATE && (data[13] & 0xfe))) {
return GST_FLOW_ERROR;
}
pf = data[14] & 0x80;
tf = data[14] & 0x40;
rf = data[14] & 0x20;
if (G_UNLIKELY (VALIDATE && (data[14] & 0x10)))
return GST_FLOW_ERROR;
sfr = data[14] & 0x07;
GST_LOG_OBJECT (filter, " Pack-V Information");
GST_LOG_OBJECT (filter, " Number of Video Frames : %d", nbframes);
GST_LOG_OBJECT (filter, " Leading PES-V picture type %s (0x%x)",
(data_h == 0x1) ? "I-picture" : "other", data_h);
GST_LOG_OBJECT (filter, " VBV Delay of first frame: %" G_GUINT32_FORMAT,
vbv_delay);
GST_LOG_OBJECT (filter, " Header Size:%d", hdr_size);
GST_LOG_OBJECT (filter, " DTS: %" GST_TIME_FORMAT " (%" G_GUINT64_FORMAT ")",
GST_TIME_ARGS (MPEGTIME_TO_GSTTIME (dts)), dts);
GST_LOG_OBJECT (filter, " Video source : %s %s %s (0x%x 0x%x 0x%x)",
pf ? "Progressive" : "Interlaced",
tf ? "TFF" : "", rf ? "RFF" : "", pf, tf, rf);
GST_LOG_OBJECT (filter, " Source Frame Rate : %s (0x%x)",
sfr_to_framerate (sfr), sfr);
gst_structure_set (st, "DTS", G_TYPE_UINT64, MPEGTIME_TO_GSTTIME (dts),
"interlaced", G_TYPE_BOOLEAN, !pf, NULL);
/* Search Data Mode
* ---------------------------------
* 15 | Search Data Mode |
* ---------------------------------
*/
sdm = data[15];
GST_LOG_OBJECT (filter, " Search Data Mode : 0x%x", sdm);
GST_LOG_OBJECT (filter, " %s %s %s",
sdm & 0x2 ? "8x-Base" : "",
sdm & 0x4 ? "8x-Helper" : "", sdm & 0x10 ? "24x" : "");
/* Video Mode
* ---------------------------------
* 16 | Horizontal size |
* ----------------- |
* 17 | 0 | 0 | 0 | 0 | |
* ---------------------------------
* 18 | Vertical size |
* ----------------- |
* 19 | 0 | 0 | 0 | 0 | |
* ---------------------------------
* 20 | Aspect ratio | Frame Rate |
* ---------------------------------
* 21 | |
* 22 | bitrate |
* ------------------------- |
* 23 | 0 | 0 | 0 | 0 | 0 | 0 | |
* ---------------------------------
* 24 | VBV Buffer size |
* ------------------------- |
* 25 | 0 | 0 | 0 | 0 | 0 | 0 | |
* ---------------------------------
* 26 | 0 | Profile | Level |
* ---------------------------------
* 27 | 0 | Format |Chroma | 0 | 0 |
* ---------------------------------
* 28 | GOP N | GOP M |
* ---------------------------------
*/
width = data[16] | (data[17] & 0xf) << 8;
height = data[18] | (data[19] & 0xf) << 8;
if (VALIDATE && ((data[17] & 0xf0) || data[19] & 0xf0))
return GST_FLOW_ERROR;
aspect = data[20] >> 4;
framerate = data[20] & 0xf;
bitrate = data[21] | data[22] << 8 | (data[23] & 0x3) << 16;
if (VALIDATE && (data[23] & 0xfc))
return GST_FLOW_ERROR;
vbv_buffer = data[24] | (data[25] & 0x3) << 8;
if (VALIDATE && (data[25] & 0xfc))
return GST_FLOW_ERROR;
profile = (data[26] >> 4) & 0x7;
level = data[26] & 0xf;
format = (data[27] >> 4) & 0x7;
chroma = (data[27] >> 2) & 0x3;
gop_n = data[28] >> 3;
gop_m = data[28] & 0x7;
GST_LOG_OBJECT (filter, " Video Mode");
GST_LOG_OBJECT (filter, " width:%d, height:%d", width, height);
GST_LOG_OBJECT (filter, " Aspect Ratio : %s (0x%x)",
(aspect == 0x3) ? "16/9" : "RESERVED", aspect);
GST_LOG_OBJECT (filter, " Framerate: %s (0x%x)",
sfr_to_framerate (framerate), framerate);
GST_LOG_OBJECT (filter, " Bitrate: %d bit/s", bitrate * 400);
GST_LOG_OBJECT (filter, " VBV buffer Size : %d bits",
vbv_buffer * 16 * 1024);
GST_LOG_OBJECT (filter, " MPEG Profile : %s (0x%x)",
(profile == 0x4) ? "Main" : "RESERVED", profile);
GST_LOG_OBJECT (filter, " MPEG Level : %s (0x%x)",
(level == 0x6) ? "High-1440" : "RESERVED", level);
GST_LOG_OBJECT (filter, " Video format : %s (0x%x)",
(format == 0) ? "Component" : "Reserved", format);
GST_LOG_OBJECT (filter, " Chroma : %s (0x%x)",
(chroma == 0x1) ? "4:2:0" : "RESERVED", chroma);
GST_LOG_OBJECT (filter, " GOP N/M : %d / %d", gop_n, gop_m);
/* data availability
* ---------------------------------
* 29 | 0 | 0 | 0 | 0 | 0 |PE2|PE1|PE0|
* ---------------------------------
* PE0 : HD2 TTC is valid
* PE1 : REC DATE is valid
* PE2 : REC TIME is valid
*/
if (data[29] & 0x1) {
guint8 fr, sec, min, hr;
gboolean bf, df;
gchar *ttcs;
/* HD2 TTC
* ---------------------------------
* 30 |BF |DF |Tens Fr|Units of Frames|
* ---------------------------------
* 31 | 1 |Tens second|Units of Second|
* ---------------------------------
* 32 | 1 |Tens minute|Units of Minute|
* ---------------------------------
* 33 | 1 | 1 |Tens Hr|Units of Hours |
* ---------------------------------
*/
bf = data[30] >> 7;
df = (data[30] >> 6) & 0x1;
fr = BCD (data[30] & 0x3f);
sec = BCD (data[31] & 0x7f);
min = BCD (data[32] & 0x7f);
hr = BCD (data[33] & 0x3f);
GST_LOG_OBJECT (filter, " HD2 Title Time Code");
GST_LOG_OBJECT (filter, " BF:%d, Drop Frame:%d", bf, df);
ttcs = g_strdup_printf ("%02d:%02d:%02d.%02d", hr, min, sec, fr);
GST_LOG_OBJECT (filter, " Timecode %s", ttcs);
/* FIXME : Use framerate information from above to convert to GstClockTime */
gst_structure_set (st, "title-time-code", G_TYPE_STRING, ttcs, NULL);
g_free (ttcs);
}
if (data[29] & 0x2) {
gboolean ds, tm;
guint8 tz, day, dow, month, year;
GDate *date;
/* REC DATE
* ---------------------------------
* 34 |DS |TM |Tens TZ|Units of TimeZn|
* ---------------------------------
* 35 | 1 | 1 |Tens dy| Units of Days |
* ---------------------------------
* 36 | Week |TMN|Units of Months|
* ---------------------------------
* 37 | Tens of Years |Units of Years |
* ---------------------------------
*/
ds = data[34] >> 7;
tm = (data[34] >> 6) & 0x1;
tz = BCD (data[34] & 0x3f);
day = BCD (data[35] & 0x3f);
dow = data[36] >> 5;
month = BCD (data[36] & 0x1f);
year = BCD (data[37]);
GST_LOG_OBJECT (filter, " REC DATE");
GST_LOG_OBJECT (filter, " ds:%d, tm:%d", ds, tm);
GST_LOG_OBJECT (filter, " Timezone: %d", tz);
GST_LOG_OBJECT (filter, " Date: %d %02d/%02d/%04d", dow, day, month, year);
date = g_date_new_dmy (day, month, year);
gst_structure_set (st, "date", GST_TYPE_DATE, date,
"timezone", G_TYPE_INT, tz,
"daylight-saving", G_TYPE_BOOLEAN, ds, NULL);
g_date_free (date);
}
if (data[29] & 0x4) {
guint8 fr, sec, min, hr;
gchar *times;
/* REC TIME
* ---------------------------------
* 38 | 1 | 1 |Tens Fr|Units of Frames|
* ---------------------------------
* 39 | 1 |Tens second|Units of Second|
* ---------------------------------
* 40 | 1 |Tens minute|Units of Minute|
* ---------------------------------
* 41 | 1 | 1 |Tens Hr|Units of Hours |
* ---------------------------------
*/
fr = BCD (data[38] & 0x3f);
sec = BCD (data[39] & 0x7f);
min = BCD (data[40] & 0x7f);
hr = BCD (data[41] & 0x3f);
times = g_strdup_printf ("%02d:%02d:%02d", hr, min, sec);
GST_LOG_OBJECT (filter, " REC TIME %02d:%02d:%02d.%02d", hr, min, sec, fr);
gst_structure_set (st, "time", G_TYPE_STRING, times, NULL);
g_free (times);
}
/* MISC
* ---------------------------------
* 42 | CGMS |REC|ABS| 0 | 0 | 0 | 0 |
* ---------------------------------
*/
cgms = data[42] >> 6;
recst = (data[42] >> 5) & 0x1;
abst = (data[42] >> 4) & 0x1;
GST_LOG_OBJECT (filter, " CGMS:0x%x", cgms);
GST_LOG_OBJECT (filter, " Recording Start Point : %s",
(recst == 0) ? "PRESENT" : "ABSENT");
GST_LOG_OBJECT (filter, " ABST : %s",
(abst == 0) ? "DISCONTINUITY" : "NO DISCONTINUITY");
gst_structure_set (st, "recording-start-point", G_TYPE_BOOLEAN, !recst, NULL);
/* Extended DV Pack #1
* 43 - 47
*/
GST_LOG_OBJECT (filter, " Extended DV Pack #1 : 0x%x", data[43]);
/* Extended DV Pack #1
* 48 - 52
*/
GST_LOG_OBJECT (filter, " Extended DV Pack #2 : 0x%x", data[48]);
/* Extended DV Pack #1
* 53 - 57
*/
GST_LOG_OBJECT (filter, " Extended DV Pack #3 : 0x%x", data[53]);
return GST_FLOW_OK;
}
static GstFlowReturn
parse_audio_frame (GstHDVParse * filter, guint8 * data, guint64 size,
GstStructure * st)
{
guint32 etn;
guint8 nbmute, nbaau;
guint64 pts;
guint16 audio_comp;
guint8 bitrate, fs, compress, channel;
guint8 option, cgms;
gboolean acly, recst;
GST_LOG_OBJECT (filter, "Audio Frame Pack");
/* Byte | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* ---------------------------------
* 0 | Size (0x0f) |
* ---------------------------------
* 1 | |
* 2 | ETN |
* 3 | |
* ---------------------------------
* 4 |Nb Audio Mute | Number of AAU |
* ---------------------------------
*/
if (data[0] != 0x0f) {
GST_WARNING ("Invalid size for audio frame");
return GST_FLOW_ERROR;
}
etn = data[3] << 16 | data[2] << 8 | data[1];
GST_LOG_OBJECT (filter, " ETN : %" G_GUINT32_FORMAT, etn);
/* Pack-A Information
* ---------------------------------
* 4 |Nb Audio Mute | Number of AAU |
* ---------------------------------
* 5 | |
* 6 | PTS |
* 7 | |
* 8 | |
* ----------------------------- |
* 9 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | |
* ---------------------------------
* 10 | Audio |
* 11 | Compensation |
* ---------------------------------
*/
/* Number of Audio Mute Frames */
nbmute = data[4] >> 4;
/* Number of AAU */
nbaau = data[4] & 0x0f;
/* PTS of the first AAU immediatly following */
pts = (data[5] | data[6] << 8 | data[7] << 16 | data[8] << 24);
pts |= (guint64) (data[9] & 0x1) << 32;
if (G_UNLIKELY (VALIDATE && (data[9] & 0xfe))) {
return GST_FLOW_ERROR;
}
/* Amount of compensation */
audio_comp = data[10] | data[11] << 8;
GST_LOG_OBJECT (filter, " Pack-A Information");
GST_LOG_OBJECT (filter, " Nb Audio Mute Frames : %d", nbmute);
GST_LOG_OBJECT (filter, " Nb AAU : %d", nbaau);
GST_LOG_OBJECT (filter,
" PTS : %" GST_TIME_FORMAT " (%" G_GUINT64_FORMAT ")",
GST_TIME_ARGS (MPEGTIME_TO_GSTTIME (pts)), pts);
GST_LOG_OBJECT (filter, " Audio Compensation : %" G_GUINT32_FORMAT,
audio_comp);
/* Audio Mode
* ---------------------------------
* 12 | Bitrate Index | 0 |Samplerate |
* ---------------------------------
* 13 | Compression | Channels |
* ---------------------------------
* 14 | X | Anciliary Option |
* ---------------------------------
*
* X : Anciliary data present
*/
bitrate = data[12] >> 4;
fs = data[12] & 0x7;
if (G_UNLIKELY (VALIDATE && (data[12] & 0x08)))
return GST_FLOW_ERROR;
compress = data[13] >> 4;
channel = data[13] & 0xf;
acly = data[14] & 0x80;
option = data[14] & 0x7f;
GST_LOG_OBJECT (filter, " Audio Mode");
GST_LOG_OBJECT (filter, " Bitrate : %s (0x%x)",
(bitrate == 0xe) ? "384kbps" : "RESERVED", bitrate);
GST_LOG_OBJECT (filter, " Samplerate : %s (0x%x)",
(fs == 0x1) ? "48 kHz" : "RESERVED", fs);
GST_LOG_OBJECT (filter, " Compression : %s (0x%x)",
(compress == 0x2) ? "MPEG-1 Layer II" : "RESERVED", compress);
GST_LOG_OBJECT (filter, " Channels : %s (0x%x)",
(channel == 0) ? "Stereo" : "RESERVED", channel);
GST_LOG_OBJECT (filter, " Anciliary data %s %s (0x%x)",
acly ? "PRESENT" : "ABSENT",
(option == 0xc) ? "IEC 13818-3" : "ABSENT/RESERVED", option);
/*
* ---------------------------------
* 15 | CGMS | R | 0 | 0 | 0 | 0 | 0 |
* ---------------------------------
*
* R : Recording Start Point
*/
cgms = data[15] & 0xc0;
recst = data[15] & 0x20;
GST_LOG_OBJECT (filter, " Misc");
GST_LOG_OBJECT (filter, " CGMS : 0x%x", cgms);
GST_LOG_OBJECT (filter, " Recording Start Point %s",
(recst) ? "ABSENT" : "PRESENT");
gst_structure_set (st, "PTS", G_TYPE_UINT64, MPEGTIME_TO_GSTTIME (pts),
"recording-start-point", G_TYPE_BOOLEAN, !recst, NULL);
return GST_FLOW_OK;
}
static GstFlowReturn
gst_hdvparse_parse (GstHDVParse * filter, GstBuffer * buf)
{
GstFlowReturn res = GST_FLOW_OK;
guint8 *data = GST_BUFFER_DATA (buf);
guint64 offs = 0;
guint64 insize = GST_BUFFER_SIZE (buf);
GstStructure *st;
/* Byte | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
* ---------------------------------
* 0 | 0 | KEYWORD |
* (1) | LENGTH |
* ....
*
* KEYWORD :
* 0x00 - 0x3F : Constant length (5 bytes)
* 0x40 - 0x7F : Variable length (LENGTH + 1)
*
* LENGTH : if present, size of fields 1-N
*
* Known keyword values:
* 0x00-0x07 : AUX-V
* 0x08-0x3E : RESERVED
* 0x3F : AUX-N NO-INFO
* 0x40-0x43 : AUX-A
* 0x44-0x47 : AUX-V
* 0x48-0x4F : AUX-N
* 0x50-0x53 : AUX-SYS
* 0x54-0x7E : RESERVED
* 0x7F : AUX-N NULL PACK
*/
st = gst_structure_empty_new ("hdv-aux");
while (res == GST_FLOW_OK && (offs < insize)) {
guint8 kw = data[offs] & 0x7f;
guint8 size;
/* Variable size packs */
if (kw >= 0x40) {
size = data[offs + 1];
} else
size = 4;
/* Size validation */
GST_DEBUG ("kw:0x%x, insize:%" G_GUINT64_FORMAT ", offs:%" G_GUINT64_FORMAT
", size:%d", kw, insize, offs, size);
if (insize < offs + size) {
res = GST_FLOW_ERROR;
goto beach;
}
switch (kw) {
case 0x01:
GST_LOG ("BINARY GROUP");
offs += size + 1;
break;
case 0x07:
GST_LOG ("ETN pack");
break;
case 0x40:
GST_LOG ("Audio frame pack");
res = parse_audio_frame (filter, data + offs + 1, size, st);
offs += size + 2;
break;
case 0x3f:
GST_LOG ("NO INFO pack");
offs += size + 1;
break;
case 0x44:
GST_LOG ("Video frame pack");
res = parse_video_frame (filter, data + offs + 1, size, st);
offs += size + 2;
break;
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
GST_LOG ("DV multi-pack");
res = parse_dv_multi_pack (filter, data + offs + 1, size, st);
offs += size + 2;
break;
default:
GST_WARNING_OBJECT (filter, "Unknown AUX pack data of type 0x%x", kw);
res = GST_FLOW_ERROR;
}
}
beach:
if (gst_structure_n_fields (st)) {
GstMessage *msg;
/* Emit the element message */
msg = gst_message_new_element (GST_OBJECT (filter), st);
gst_element_post_message (GST_ELEMENT (filter), msg);
} else
gst_structure_free (st);
return res;
}
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
gst_hdvparse_transform_ip (GstBaseTransform * base, GstBuffer * outbuf)
{
GstHDVParse *filter = GST_HDVPARSE (base);
return gst_hdvparse_parse (filter, outbuf);
}
/* entry point to initialize the plug-in
* initialize the plug-in itself
* register the element factories and other features
*/
static gboolean
HDVParse_init (GstPlugin * HDVParse)
{
return gst_element_register (HDVParse, "hdvparse", GST_RANK_NONE,
GST_TYPE_HDVPARSE);
}
/* gstreamer looks for this structure to register HDVParses
*
* exchange the string 'Template HDVParse' with you HDVParse description
*/
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
hdvparse,
"HDV private stream parser",
HDVParse_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")
Reference in a new issue View git blame Copy permalink