summaryrefslogtreecommitdiffstats
path: root/gst
diff options
context:
space:
mode:
Diffstat (limited to 'gst')
-rw-r--r--gst/hdvparse/gsthdvparse.c849
1 files changed, 665 insertions, 184 deletions
diff --git a/gst/hdvparse/gsthdvparse.c b/gst/hdvparse/gsthdvparse.c
index 9914cfa2..73367247 100644
--- a/gst/hdvparse/gsthdvparse.c
+++ b/gst/hdvparse/gsthdvparse.c
@@ -35,6 +35,8 @@
#include "config.h"
#endif
+#include <math.h>
+
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
@@ -55,90 +57,25 @@ enum
PROP_0,
};
-static gchar *aperture_table[] = {
- "???",
- "cls",
- "1.0",
- "1.2",
- "1.4",
- "1.6",
- "1.7",
- "1.8",
- "2.0",
- "2.2",
- "2.4",
- "2.6",
- "2.8",
- "3.1",
- "3.4",
- "3.7",
- "4.0",
- "4.4",
- "4.8",
- "5.2",
- "5.6",
- "6.2",
- "6.8",
- "7.3",
- "8.0",
- "8.7",
- "9.6",
- "10",
- "11",
- "12",
- "14",
- "14",
- "16",
- "17",
- "18",
- "6.7"
-};
-/* Observations from my HDV Camera (Canon HV20 Pal)
- * FIXME : replace with with code once we've figured out the algorithm.
- * Shutter speed 0x4f 0x50
- * ------------------------------------
- * 1/6 F3 95
- * 1/8 90 91
- * 1/12 FA 8A
- * 1/15 C8 88
- * 1/24 7D 85
- * 1/30 64 84
- * 1/48 BE 82
- * 1/60 32 82
- * 1/100 51 81
- * 1/250 87 80
- * 1/500 43 80
- * 1/1000 22 80
- * 1/2000 11 80
- */
-typedef struct
-{
- guint vala, valb, shutter;
-} Shutter_t;
-
-static Shutter_t shutter_table[] = {
- {0xf3, 0x95, 6},
- {0x90, 0x91, 8},
- {0xfa, 0x8a, 12},
- {0xc8, 0x88, 15},
- {0x7d, 0x85, 24},
- {0x64, 0x84, 30},
- {0xbe, 0x82, 48},
- {0x32, 0x82, 60},
- {0x51, 0x81, 100},
- {0x87, 0x80, 250},
- {0x43, 0x80, 500},
- {0x22, 0x80, 1000},
- {0x11, 0x80, 2000}
-};
+
+#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 1
/* 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.
@@ -146,13 +83,14 @@ static Shutter_t shutter_table[] = {
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
- GST_STATIC_CAPS ("private/hdv-a1")
+ 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 ("private/hdv-a1,parsed=(boolean)True")
+ GST_STATIC_CAPS
+ ("hdv/aux-v,parsed=(boolean)True;hdv/aux-a,parsed=(boolean)True")
);
/* debug category for fltering log messages
@@ -167,6 +105,8 @@ GST_BOILERPLATE_FULL (GstHDVParse, gst_hdvparse, GstBaseTransform,
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 */
@@ -194,6 +134,8 @@ 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
@@ -208,123 +150,664 @@ gst_hdvparse_init (GstHDVParse * filter, GstHDVParseClass * klass)
gst_base_transform_set_passthrough (transform, TRUE);
}
-static guint
-get_shutter_speed (guint8 vala, guint8 valb)
+static GstCaps *
+gst_hdvparse_transform_caps (GstBaseTransform * trans, GstPadDirection dir,
+ GstCaps * incaps)
{
- guint i;
+ 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);
+ }
- for (i = 0; i < G_N_ELEMENTS (shutter_table); i++)
- if (shutter_table[i].vala == vala && shutter_table[i].valb == valb)
- return shutter_table[i].shutter;
- GST_WARNING ("Unknown shutter speed ! vala:0x%02x, valb:0x%02x", vala, valb);
- return 0;
+ return res;
}
-static void
-gst_hdvparse_parse (GstHDVParse * filter, GstBuffer * buf)
+
+static inline const gchar *
+sfr_to_framerate (guint8 sfr)
{
- guint8 *data = GST_BUFFER_DATA (buf);
- guint apertured, shutter;
- gfloat gain;
- gboolean dst = FALSE;
- GstStructure *str;
- GstMessage *msg;
-
- GST_MEMDUMP_OBJECT (filter, "BUFFER", data, GST_BUFFER_SIZE (buf));
-
- str = gst_structure_empty_new ("HDV");
-
- /* 0x1f - 0x23 : TimeCode */
-
- if (data[0x1f] != 0xff) {
- guint8 tframe, tsec, tmin, thour;
- gchar *timecode = NULL;
- tframe = BCD (data[0x1f] & 0x3f);
- tsec = BCD (data[0x20] & 0x7f);
- tmin = BCD (data[0x21] & 0x7f);
- thour = BCD (data[0x22] & 0x3f);
-
- timecode =
- g_strdup_printf ("%01d:%02d:%02d.%02d", thour, tmin, tsec, tframe);
- gst_structure_set (str, "timecode", G_TYPE_STRING, timecode, NULL);
- g_free (timecode);
- GST_LOG_OBJECT (filter, timecode);
+ 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)
+{
+ 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)));
+ 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) {
+ GST_LOG (" Gain:%02.2fdB", (agc - 1.0) * 1.5);
+ GST_LOG (" Gain:%02.2fdB", (agc * 3.0) - 3);
+ }
+ /* 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 : %d 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);
+ }
+ break;
+ default:
+ gst_util_dump_mem (data + offs, 5);
+ break;
+ }
+ size -= 5;
+ offs += 5;
}
+ return GST_FLOW_OK;
+}
- /* 0x23 : Timezone / Dailight Saving Time */
- /* 0x24 - 0x2a : Original time */
- if (data[0x23] != 0xff) {
- GDate *date = NULL;
- guint tzone = 0;
- guint day, month, year, hour, min, sec;
- gchar *datetime;
-
- tzone = data[0x23];
- dst = !(tzone & 0x80);
- tzone =
- BCD (tzone & 0x1f) > 12 ? BCD (tzone & 0x1f) - 12 : BCD (tzone & 0x1f);
- GST_LOG_OBJECT (filter, "TimeZone : %d, DST : %d", tzone, dst);
-
- day = BCD_M (data[0x24], 0x3f);
- month = BCD_M (data[0x25], 0x1f);
- year = BCD (data[0x26]);
- if (year > 90)
- year += 1900;
- else
- year += 2000;
- /* 0x27: ??? */
- sec = BCD_M (data[0x28], 0x7f);
- min = BCD_M (data[0x29], 0x7f);
- hour = BCD_M (data[0x2a], 0x3f);
-
- /* FIXME : we need a date/time object ! */
- date = g_date_new_dmy (day, month, year);
- datetime =
- g_strdup_printf ("%02d/%02d/%02d %02d:%02d:%02d", day, month, year,
- hour, min, sec);
- gst_structure_set (str, "date", GST_TYPE_DATE, date, "recording-time",
- G_TYPE_STRING, datetime, NULL);
- g_free (datetime);
- GST_LOG_OBJECT (filter, datetime);
+static GstFlowReturn
+parse_video_frame (GstHDVParse * filter, guint8 * data, guint64 size)
+{
+ 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;
}
- /* 0x2b : Various flags, including scene-change */
- if (!((data[0x2b] & 0x20) >> 5)) {
- GST_LOG_OBJECT (filter, "Scene change !");
- gst_structure_set (str, "scene-change", G_TYPE_BOOLEAN, TRUE, NULL);
+ 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);
+
+ /* 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;
+ /* 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);
+ GST_LOG_OBJECT (filter, " Timecode %02d:%02d:%02d.%02d", hr, min, sec, fr);
+ /* FIXME : Use framerate information from above to convert to GstClockTime */
}
+ if (data[29] & 0x2) {
+ gboolean ds, tm;
+ guint8 tz, day, dow, month, year;
+ /* 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[32] >> 7;
+ tm = (data[32] >> 6) & 0x1;
+ tz = BCD (data[32] & 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);
+ }
+ if (data[29] & 0x4) {
+ guint8 fr, sec, min, hr;
+ /* 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);
+ GST_LOG_OBJECT (filter, " REC TIME %02d:%02d:%02d.%02d", hr, min, sec, fr);
+ }
+
+ /* 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");
+
+ /* 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]);
- /* Check for partials */
- if (GST_BUFFER_SIZE (buf) < 0x50) {
- goto beach;
+ return GST_FLOW_OK;
+
+}
+
+static GstFlowReturn
+parse_audio_frame (GstHDVParse * filter, guint8 * data, guint64 size)
+{
+ 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;
}
- /* 0x43 : Aperture */
- apertured = data[0x43] & 0x3f;
- if (apertured < 35) {
- GST_LOG_OBJECT (filter, "Aperture : F%s", aperture_table[apertured]);
- gst_structure_set (str, "aperture", G_TYPE_STRING,
- aperture_table[apertured], NULL);
- } else {
- GST_LOG_OBJECT (filter, "Aperture : %d", apertured);
+ /* 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");
+ 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);
+
+ /* 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
+ */
+
+ gst_util_dump_mem (data, insize);
+
+ 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:%d, offs:%d, size:%d", kw, insize, offs, size);
+ if (insize < offs + size)
+ return GST_FLOW_ERROR;
+
+ 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);
+ 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);
+ 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);
+ offs += size + 2;
+ break;
+ default:
+ GST_WARNING_OBJECT (filter, "Unknown AUX pack data of type 0x%x", kw);
+ res = GST_FLOW_ERROR;
+ }
}
- /* 0x44 : Gain */
- gain = ((data[0x44] & 0xf) - 1) * 1.5;
- GST_LOG_OBJECT (filter, "Gain : %03f db", gain);
- gst_structure_set (str, "gain", G_TYPE_FLOAT, gain, NULL);
-
- /* 0x4f - 0x50 : Shutter */
- shutter = get_shutter_speed (data[0x4f], data[0x50]);
- GST_LOG_OBJECT (filter, "Shutter speed : 1/%d", shutter);
- if (shutter)
- gst_structure_set (str, "shutter-speed", GST_TYPE_FRACTION, 1, shutter,
- NULL);
-
-beach:
- msg = gst_message_new_element (GST_OBJECT (filter), str);
- gst_element_post_message (GST_ELEMENT (filter), msg);
- return;
+ return res;
+
}
/* GstBaseTransform vmethod implementations */
@@ -334,9 +817,7 @@ gst_hdvparse_transform_ip (GstBaseTransform * base, GstBuffer * outbuf)
{
GstHDVParse *filter = GST_HDVPARSE (base);
- gst_hdvparse_parse (filter, outbuf);
-
- return GST_FLOW_OK;
+ return gst_hdvparse_parse (filter, outbuf);
}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-26 07:28:07 +0000