Difference between revisions of "Commercial detection with silences"

catagrower.c

/* Copyright 2012 Crackers Phipps. */
/* Public domain. */
/* Compile with
   gcc -std=c99 -O catagrower.c -o catagrower
*/
/* This program will stop when the file has not grown for this many seconds. */
#define TIMEOUT 60

/* MythTV files are often large. */
#define _FILE_OFFSET_BITS 64

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

static void usage(const char *name) {
  fprintf(stderr, "Usage: %s <file>\n", name);
  fprintf(stderr, "<file>: file to be monitored.\n");
  fprintf(stderr, "The contents of the file will be copied to stdout.\n");
  fprintf(stderr, "Copying will stop when the file has stopped growing.\n");
}

int main(int argc, char **argv) {

  /* Check usage. */
  if (2 != argc) {
    usage(argv[0]);
    exit(1);
  }

  /* Load options. */
  int fd;
  if (-1 == (fd = open(argv[1], O_RDONLY))) {
    fprintf(stderr, "Could not open %s for reading.\n", argv[1]);
    usage(argv[0]);
    exit(2);
  }

#define BUFFSIZE 4096
  int timer = TIMEOUT;
  char buffer[BUFFSIZE];
  int bytes;
  while (timer > 0) {
    while (0 != (bytes = read(fd, buffer, BUFFSIZE))) {
      write (STDOUT_FILENO, buffer, bytes);
      timer = TIMEOUT;
    }
    sleep(1);
    timer--;
  }
  return 0;
}

mausc.c

/* Copyright 2013 Tinsel Phipps. */
/* Public domain. Links with libsndfile which is GPL. */
/* Compile with
   gcc -std=c99 -O mausc.c -o mausc -lsndfile -lm
   You may need the libsndfile-dev package installed.
*/
#include <stdlib.h>
#include <math.h>
#include <sndfile.h>
#include <errno.h>
#include <unistd.h>
#include <limits.h>

static void usage(const char *name) {
  fprintf(stderr, "Usage: %s <threshold> <min> <max> <rate>\n", name);
  fprintf(stderr, "<threshold>: silence threshold in dB.\n");
  fprintf(stderr, "<min>: minimum time for silence detection in seconds.\n");
  fprintf(stderr, "<max>: maximum length of breaks in seconds.\n");
  fprintf(stderr, "<rate>: frame rate of video.\n");
  fprintf(stderr, "An AU format file should be fed into this program.\n");
  fprintf(stderr, "Example: %s -70 0.15 400 25 < audio.au\n", name);
}

int main(int argc, char **argv) {

  /* Check usage. */
  if (5 != argc) {
    usage(argv[0]);
    exit(1);
  }

  /* Load options. */
  float threshold, min, max, rate;
  if (1 != sscanf(argv[1], "%f", &threshold)) {
    fprintf(stderr, "Could not parse threshold option into a number.\n");
    usage(argv[0]);
    exit(2);
  }
  if (1 != sscanf(argv[2], "%f", &min)) {
    fprintf(stderr, "Could not parse min option into a number.\n");
    usage(argv[0]);
    exit(2);
  }
  if (1 != sscanf(argv[3], "%f", &max)) {
    fprintf(stderr, "Could not parse max option into a number.\n");
    usage(argv[0]);
    exit(2);
  }
  if (1 != sscanf(argv[4], "%f", &rate)) {
    fprintf(stderr, "Could not parse rate option into a number.\n");
    usage(argv[0]);
    exit(2);
  }

  /* Scale threshold to integer range that libsndfile will use. */
  threshold = INT_MAX * pow(10, threshold / 20);
  /* Scale times to frames. */
  min = min * rate;
  max = max * rate;

  /* Check the input is an audiofile. */
  SNDFILE *input;
  SF_INFO metadata;
  input = sf_open_fd(STDIN_FILENO, SFM_READ, &metadata, SF_FALSE);
  if (NULL == input) {
    sf_perror(NULL);
    return sf_error(NULL);
  }

  /* Allocate data buffer to contain audio data from one video frame. */
  size_t frameSamples = metadata.channels * metadata.samplerate / rate;

  int *samples;
  samples = malloc(frameSamples * sizeof(int));
  if (NULL == samples) {
    perror(NULL);
    return errno;
  }

  /* Process the file one frame at a time and process cuts along the way. */
  int frames = 0;
  int silent = 0;
  int last_silent = 0;
  int gapend = 0;
  int gapstart = 0;
  int first_gapstart = 0;
  while (frameSamples == sf_read_int(input, samples, frameSamples)) {
    frames++;
    int maxabs = 0;
    for (unsigned i = 0; i < frameSamples; i++) {
      samples[i] = abs(samples[i]);
      maxabs = (maxabs > samples[i]) ? maxabs : samples[i];
    }
    last_silent = silent;
    silent = (maxabs < threshold);
    /* Remember first transition to silence. */
    if (silent && !gapstart) {
      gapstart = frames;
    }
    /* Store last transition out of silence. */
    if (!silent && last_silent) {
      /* Make sure it is long enough. */
      if (frames > gapstart + min) {
        gapend = frames;
        if (!first_gapstart) {
          first_gapstart = gapstart;
        }
      }
      gapstart = 0;
    }
    /* Create a skip when max frames have passed. */
    if (first_gapstart && gapend && frames > first_gapstart + max) {
      printf("%d %d\n", first_gapstart, gapend);
      fflush(stdout);
      gapstart = 0;
      gapend = 0;
      first_gapstart = 0;
    }
  }
  /* At end of file can have an unprocessed gap. */
  if (first_gapstart) {
    if (first_gapstart == gapstart) {
      gapend = frames;
    }
    printf("%d %d\n", first_gapstart, gapend);
  }
  return sf_close(input);
}

mausc-wrapper

#!/usr/bin/env python
# Build a skiplist from silence in the audio track.
# Based on http://www.mythtv.org/wiki/Transcode_wrapper_stub
from MythTV import MythDB, Job, Recorded, findfile, MythLog
from os import path
from subprocess import Popen, PIPE
from optparse import OptionParser

def runjob(jobid=None, chanid=None, starttime=None):
    # Tunable settings (would like to retrieve per channel from the database)
    thresh = -70 # Silence threshold in dB.
    minquiet = 0.15 # Minimum time for silence detection in seconds.
    maxbreak = 400 # Maximum length of adverts breaks.
    rate = 25 # Frame rate of video. (should be automatic)

    db = MythDB()
    if jobid:
        job = Job(jobid, db=db)
        chanid = job.chanid
        starttime = job.starttime

    try:
        rec = Recorded((chanid, starttime), db=db)
    except:
        if jobid:
            job.update({'status':job.ERRORED,
                        'comment':'ERROR: Could not find recording.'})
        else:
            print 'Could not find recording.'
        exit(1)

    # Get program handle in standard format.
    starttime = rec.starttime
    chanid = rec.chanid

    sg = findfile(rec.basename, rec.storagegroup, db=db)
    if sg is None:
        if jobid:
            job.update({'status':job.ERRORED,
                        'comment':'ERROR: Local access to recording not found.'})
        else:
            print 'Local access to recording not found.'
        exit(1)

    infile = path.join(sg.dirname, rec.basename)

    # Purge any existing skip list.
    rec.markup.clean()
    rec.commflagged = 0
    rec.update()

    # Write out the file contents and keep going till recording is finished.
    p1 = Popen(["catagrower", infile],
               stdout = PIPE)
    # Pipe through avconv to extract uncompressed audio stream.
    p2 = Popen(["avconv", "-v", "8", "-i", "pipe:0", "-f", "au", "-ac", "6", "-"],
               stdin = p1.stdout, stdout = PIPE)
    # Pipe to mausc which will spit out a list of breaks.
    p3 = Popen(["mausc", str(thresh), str(minquiet), str(maxbreak), str(rate)],
               stdin = p2.stdout, stdout = PIPE)

    # Store breaks in the database.
    breaks = 0
    while 1:
        line = p3.stdout.readline()
        if not line:
            break
        start, end = line.split()
        rec.markup.append(start, rec.markup.MARK_COMM_START, None)
        rec.markup.append(end, rec.markup.MARK_COMM_END, None)
        rec.commflagged = 1
        rec.update()
        breaks = breaks + 1
        if jobid is None:
            print 'Got a break at frame %s' % start

    if jobid:
        job.update({'status':272,
                    'comment':'Audio commflag detected %s breaks.' % breaks
                    })
    else:
        print 'Audio commflag detected %s breaks.' % breaks

def main():
    parser = OptionParser(usage="usage: %prog [options] [jobid]")

    parser.add_option('--chanid', action='store', type='int',
                      dest='chanid', help='Use chanid for manual operation')
    parser.add_option('--starttime', action='store', type='string',
                      dest='stime', help='Use starttime for manual operation')
    MythLog.loadOptParse(parser)
    opts, args = parser.parse_args()

    if len(args) == 1:
        runjob(jobid=args[0])
    elif opts.chanid and opts.stime:
        runjob(chanid=opts.chanid, starttime=opts.stime)
    else:
        print 'Script must be provided either jobid, or chanid and starttime.'
        parser.print_help()
        exit(1)

if __name__ == '__main__':
    main()

silence.preset

 
# presets for silence.py
# use comma separated values: defaults are used for absent values
# For titles/callsign the name is a python regular expressions, case is ignored.
# Re Metachars are # . ^ $ * + ? { } [ ] \ | ( )
# If a title contains one of these, then escape it (using \) or replace it with full stop
# Names are matched to the START of a title/callsign so "e4" also matches "e4+1"
# First name match is used so put specific presets (ie. programmes) before general ones (channels)
#
# title/callsign, threshold, minquiet, mindetect, minbreak, maxsep, padding
# defaults          -75,       0.16,       6,       120,     120,    0.48,
#
frasier,               ,       0.28,        ,          ,      91,        , long pauses in prog
channel 4 news,        ,       1.00,       1,        55,        ,       0, short advert, many silences
milkshake,             ,       0.48,       8,        60,      61,        , ignore short silences in animation/links
rude tube,             ,       0.32,        ,       180,      61,        , ignore short silences in links

channel 4,             ,       0.24,
more 4,                ,       0.24,
dave,               -71,           ,        ,          ,        ,        , loud silences
quest,                 ,           ,        ,          ,      55,        , short silences, long breaks, short ads
channel 5,             ,       0.24,       2,          ,     300,        , cut news out of films 
itv,                   ,           ,        ,          ,        ,     1.0, long pad for films
film 4,                ,           ,        ,          ,        ,     1.0, long pad for films
bbc,                   ,       0.48,       1,        20,     360,       0, pre/post-roll  
cbeebies,              ,       0.48,       1,        20,     360,       0, pre/post-roll  
cbbc,                  ,       0.48,       1,        20,     360,       0, pre/post-roll  

catagrower.cpp

 
/* Copyright 2012 Crackers Phipps. */
/* Public domain. */

/* MythTV files are often large. */
#define _FILE_OFFSET_BITS 64

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

static void usage(const char *name) {
  fprintf(stderr, "Usage: %s <file> <timeout>\n", name);
  fprintf(stderr, "<file>   : file to be monitored.\n");
  fprintf(stderr, "<timeout>: secs to wait for input.\n");
  fprintf(stderr, "The contents of the file will be copied to stdout.\n");
  fprintf(stderr, "Copying will stop when the file has stopped growing.\n");
}

int main(int argc, char **argv) {

  /* Check usage. */
  if (3 != argc) {
    usage(argv[0]);
    exit(1);
  }

  /* Load options. */
  int fd;
  if (-1 == (fd = open(argv[1], O_RDONLY))) {
    fprintf(stderr, "Could not open %s for reading.\n", argv[1]);
    usage(argv[0]);
    exit(2);
  }
  const int timeout = atoi(argv[2]);

#define BUFFSIZE 4096
  int timer = timeout;
  char buffer[BUFFSIZE];
  int bytes;
  while (timer > 0) {
    while (0 != (bytes = read(fd, buffer, BUFFSIZE))) {
      if (-1 == write (STDOUT_FILENO, buffer, bytes)){
          fprintf(stderr, "Write failed.\n");
          exit(3);
        }
      timer = timeout;
    }
    sleep(1);
    timer--;
  }
  return 0;
}

silence.cpp

// Based on mausc.c by Tinsel Phipps.
// v1.0 Roger Siddons
// v2.0 Roger Siddons: Flag clusters asap, fix segfaults, optional headers
// v3.0 Roger Siddons: Remove lib dependencies & commfree
// Public domain. Requires libsndfile
// Detects commercial breaks using clusters of audio silences

#include <cstdlib>
#include <cmath>
#include <cerrno>
#include <climits>
#include <deque>
#include <sndfile.h>
#include <unistd.h>

typedef unsigned frameNumber_t;
typedef unsigned frameCount_t;

// Output to python wrapper requires prefix to indicate level
#define DELIMITER "@" // must correlate with python wrapper
char prefixdebug[7] = "debug" DELIMITER;
char prefixinfo[6]  = "info" DELIMITER;
char prefixerr[5]   = "err" DELIMITER;
char prefixcut[5]   = "cut" DELIMITER;

void error(const char* mesg, bool die = true)
{
    printf("%s%s\n", prefixerr, mesg);
    if (die)
        exit(1);
}

namespace Arg
// Program argument management
{
const float kvideoRate = 25.0;  // sample rate in fps (maps time to frame count)
const frameCount_t krateInMins = kvideoRate * 60; // frames per min
int useThreshold;               // Audio level of silence
frameCount_t useMinQuiet;       // Minimum length of a silence to register
unsigned useMinDetect;          // Minimum number of silences that constitute an advert
frameCount_t useMinLength;      // adverts must be at least this long
frameCount_t useMaxSep;         // silences must be closer than this to be in the same cluster
frameCount_t usePad;            // padding for each cut

void usage()
{
    error("Usage: silence <threshold> <minquiet> <mindetect> <minlength> <maxsep> <pad>", false);
    error("<threshold>: (float)  silence threshold in dB.", false);
    error("<minquiet> : (float)  minimum time for silence detection in seconds.", false);
    error("<mindetect>: (float)  minimum number of silences to constitute an advert.", false);
    error("<minlength>: (float)  minimum length of advert break in seconds.", false);
    error("<maxsep>   : (float)  maximum time between silences in an advert break in seconds.", false);
    error("<pad>      : (float)  padding for each cut point in seconds.", false);
    error("AU format audio is expected on stdin.", false);
    error("Example: silence -75 0.1 5 60 90 1 < audio.au");
}

void parse(int argc, char **argv)
// Parse args and convert to useable values (frames)
{
    if (7 != argc)
        usage();

    float argThreshold; // db
    float argMinQuiet; // secs
    float argMinDetect;
    float argMinLength; // secs
    float argMaxSep; // secs
    float argPad; // secs

    /* Load options. */
    if (1 != sscanf(argv[1], "%f", &argThreshold))
        error("Could not parse threshold option into a number");
    if (1 != sscanf(argv[2], "%f", &argMinQuiet))
        error("Could not parse minquiet option into a number");
    if (1 != sscanf(argv[3], "%f", &argMinDetect))
        error("Could not parse mindetect option into a number");
    if (1 != sscanf(argv[4], "%f", &argMinLength))
        error("Could not parse minlength option into a number");
    if (1 != sscanf(argv[5], "%f", &argMaxSep))
        error("Could not parse maxsep option into a number");
    if (1 != sscanf(argv[6], "%f", &argPad))
        error("Could not parse pad option into a number");

    /* Scale threshold to integer range that libsndfile will use. */
    useThreshold = rint(INT_MAX * pow(10, argThreshold / 20));

    /* Scale times to frames. */
    useMinQuiet  = ceil(argMinQuiet * kvideoRate);
    useMinDetect = (int)argMinDetect;
    useMinLength = ceil(argMinLength * kvideoRate);
    useMaxSep    = rint(argMaxSep * kvideoRate + 0.5);
    usePad       = rint(argPad * kvideoRate + 0.5);

    printf("%sThreshold=%.1f, MinQuiet=%.2f, MinDetect=%.1f, MinLength=%.1f, MaxSep=%.1f, Pad=%.2f\n",
           prefixdebug, argThreshold, argMinQuiet, argMinDetect, argMinLength, argMaxSep, argPad);
    printf("%sFrame rate is %.2f, Detecting silences below %d that last for at least %d frames\n",
           prefixdebug, kvideoRate, useThreshold, useMinQuiet);
    printf("%sClusters are composed of a minimum of %d silences closer than %d frames and must be\n",
           prefixdebug, useMinDetect, useMaxSep);
    printf("%slonger than %d frames in total. Cuts will be padded by %d frames\n",
           prefixdebug, useMinLength, usePad);
    printf("%s< preroll, > postroll, - advert, ? too few silences, # too short, = comm flagged\n", prefixdebug);
    printf("%s           Start - End    Start - End      Duration         Interval    Level/Count\n", prefixinfo);
    printf("%s          frame - frame (mmm:ss-mmm:ss) frame (mm:ss.s)  frame (mmm:ss)\n", prefixinfo);
}
}

class Silence
// Defines a silence
{
public:
    enum state_t {progStart, detection, progEnd};
    static const char state_log[3];

    const state_t state;       // type of silence
    const frameNumber_t start; // frame of start
    frameNumber_t end;         // frame of end
    frameCount_t length;       // number of frames
    frameCount_t interval;     // frames between end of last silence & start of this one
    double power;              // average power level

    Silence(frameNumber_t _start, double _power = 0, state_t _state = detection)
        : state(_state), start(_start), end(_start), length(1), interval(0), power(_power) {}

    void extend(frameNumber_t frame, double _power)
    // Define end of the silence
    {
        end = frame;
        length = frame - start + 1;
        // maintain running average power: = (oldpower * (newlength - 1) + newpower)/ newlength
        power += (_power - power)/length;
    }
};
// c++0x doesn't allow initialisation within class
const char Silence::state_log[3] = {'<', ' ', '>'};

class Cluster
// A cluster of silences
{
private:
    void setState()
    {
        if (this->start->start == 1)
            state = preroll;
        else if (this->end->state == Silence::progEnd)
            state = postroll;
        else if (length < Arg::useMinLength)
            state = tooshort;
        else if (silenceCount < Arg::useMinDetect)
            state = toofew;
        else
            state = advert;
    }

public:
    // tooshort..unset are transient states - they may be updated, preroll..postroll are final
    enum state_t {tooshort, toofew, unset, preroll, advert, postroll};
    static const char state_log[6];

    static frameNumber_t completesAt; // frame where the most recent cluster will complete

    state_t state;          // type of cluster
    const Silence* start;   // first silence
    Silence* end;           // last silence
    frameNumber_t padStart, padEnd; // padded cluster start/end frames
    unsigned silenceCount;  // number of silences
    frameCount_t length;    // number of frames
    frameCount_t interval;  // frames between end of last cluster and start of this one

    Cluster(Silence* s) : state(unset), start(s), end(s), silenceCount(1), length(s->length), interval(0)
    {
        completesAt = end->end + Arg::useMaxSep; // finish cluster <maxsep> beyond silence end
        setState();
        // pad everything except pre-rolls
        padStart = (state == preroll ? 1 : start->start + Arg::usePad);
    }

    void extend(Silence* _end)
    // Define end of a cluster
    {
        end = _end;
        silenceCount++;
        length = end->end - start->start + 1;
        completesAt = end->end + Arg::useMaxSep; // finish cluster <maxsep> beyond silence end
        setState();
        // pad everything except post-rolls
        padEnd = end->end - (state == postroll ? 0 : Arg::usePad);
    }
};
// c++0x doesn't allow initialisation within class
const char Cluster::state_log[6] = {'#', '?', '.', '<', '-', '>'};
frameNumber_t Cluster::completesAt = 0;

class ClusterList
// Manages a list of detected silences and a list of assigned clusters
{
protected:
    // list of detected silences
    std::deque<Silence*> silence;

    // list of deduced clusters of the silences
    std::deque<Cluster*> cluster;

public:
    Silence* insertStartSilence()
    // Inserts a fake silence at the front of the silence list
    {
        // create a single frame silence at frame 1 and insert it at front
        Silence* ref = new Silence(1, 0, Silence::progStart);
        silence.push_front(ref);
        return ref;
    }

    void addSilence(Silence* newSilence)
    // Adds a silence detection to the end of the silence list
    {
        // set interval between this & previous silence/prog start
        newSilence->interval = newSilence->start
                - (silence.empty() ? 1 : silence.back()->end - 1);
        // store silence
        silence.push_back(newSilence);
    }

    void addCluster(Cluster* newCluster)
    // Adds a cluster to end of the cluster list
    {
        // set interval between new cluster & previous one/prog start
        newCluster->interval = newCluster->start->start
                - (cluster.empty() ? 1 : cluster.back()->end->end - 1);
        // store cluster
        cluster.push_back(newCluster);
    }
};

Silence* currentSilence; // the silence currently being detected/built
Cluster* currentCluster; // the cluster currently being built
ClusterList* clist;      // List of completed silences & clusters

void report(const char* err,
            const char type,
            const char* msg1,
            const frameNumber_t start,
            const frameNumber_t end,
            const frameNumber_t interval,
            const int power)
// Logs silences/clusters/cuts in a standard format
{
    frameCount_t duration = end - start + 1;

    printf("%s%c %7s %6d-%6d (%3d:%02ld-%3d:%02ld), %4d (%2d:%04.1f), %5d (%3d:%02ld), [%7d]\n",
           err, type, msg1, start, end,
           (start+13) / Arg::krateInMins, lrint(start / Arg::kvideoRate) % 60,
           (end+13) / Arg::krateInMins, lrint(end / Arg::kvideoRate) % 60,
           duration, (duration+1) / Arg::krateInMins, fmod(duration / Arg::kvideoRate, 60),
           interval, (interval+13) / Arg::krateInMins, lrint(interval / Arg::kvideoRate) % 60, power);
}

void processSilence()
// Process a silence detection
{
    // ignore detections that are too short
    if (currentSilence->state == Silence::detection && currentSilence->length < Arg::useMinQuiet)
    {
        // throw it away
        delete currentSilence;
        currentSilence = NULL;
    }
    else
    {
        // record new silence
        clist->addSilence(currentSilence);

        // assign it to a cluster
        if (currentCluster)
        {
            // add to existing cluster
            currentCluster->extend(currentSilence);
        }
        else if (currentSilence->interval <= Arg::useMaxSep) // only possible for very first silence
        {
            // First silence is close to prog start so extend cluster to the start
            // by inserting a fake silence at prog start and starting the cluster there
            currentCluster = new Cluster(clist->insertStartSilence());
            currentCluster->extend(currentSilence);
        }
        else
        {
            // this silence is the start of a new cluster
            currentCluster = new Cluster(currentSilence);
        }
        report(prefixdebug, currentSilence->state_log[currentSilence->state], "Silence",
               currentSilence->start, currentSilence->end,
               currentSilence->interval, currentSilence->power);

        // silence is now owned by the list, start looking for next
        currentSilence = NULL;
    }
}

void processCluster()
// Process a completed cluster
{
    // record new cluster
    clist->addCluster(currentCluster);

    report(prefixinfo, currentCluster->state_log[currentCluster->state], "Cluster",
           currentCluster->start->start, currentCluster->end->end,
           currentCluster->interval, currentCluster->silenceCount);

    // only flag clusters at final state
    if (currentCluster->state > Cluster::unset)
        report(prefixcut, '=', "Cut", currentCluster->padStart, currentCluster->padEnd, 0, 0);

    // cluster is now owned by the list, start looking for next
    currentCluster = NULL;
}

int main(int argc, char **argv)
// Detect silences and allocate to clusters
{
    // Remove logging prefixes if writing to terminal
    if (isatty(1))
        prefixcut[0] = prefixinfo[0] = prefixdebug[0] = prefixerr[0] = '\0';

    // flush output buffer after every line
    setvbuf(stdout, NULL, _IOLBF, 0);

    Arg::parse(argc, argv);

    /* Check the input is an audiofile. */
    SF_INFO metadata;
    SNDFILE* input = sf_open_fd(STDIN_FILENO, SFM_READ, &metadata, SF_FALSE);
    if (NULL == input) {
        error("libsndfile error:", false);
        error(sf_strerror(NULL));
    }

    /* Allocate data buffer to contain audio data from one video frame. */
    const size_t frameSamples = metadata.channels * metadata.samplerate / Arg::kvideoRate;

    int* samples = (int*)malloc(frameSamples * sizeof(int));
    if (NULL == samples)
        error("Couldn't allocate memory");

    // create silence/cluster list
    clist = new ClusterList();

    // Process the input one frame at a time and process cuts along the way.
    frameNumber_t frames = 0;
    while (frameSamples == static_cast<size_t>(sf_read_int(input, samples, frameSamples)))
    {
        frames++;

        // determine average audio level in this frame
        long avgabs = 0;
        for (unsigned i = 0; i < frameSamples; i++)
            avgabs += abs(samples[i]);
        avgabs = avgabs / frameSamples;

        // check for a silence
        if (avgabs < Arg::useThreshold)
        {
            if (currentSilence)
            {
                // extend current silence
                currentSilence->extend(frames, avgabs);
            }
            else // transition to silence
            {
                // start a new silence
                currentSilence = new Silence(frames, avgabs);
            }
        }
        else if (currentSilence) // transition out of silence
        {
            processSilence();
        }
        // in noise: check for cluster completion
        else if (currentCluster && frames > currentCluster->completesAt)
        {
            processCluster();
        }
    }
    // Complete any current silence (prog may have finished in silence)
    if (currentSilence)
    {
        processSilence();
    }
    // extend any cluster close to prog end
    if (currentCluster && frames <= currentCluster->completesAt)
    {
        // generate a silence at prog end and extend cluster to it
        currentSilence = new Silence(frames, 0, Silence::progEnd);
        processSilence();
    }
    // Complete any final cluster
    if (currentCluster)
    {
        processCluster();
    }
}

silence.py

#!/usr/bin/env python
# Build a skiplist from silence in the audio track.
# Roger Siddons v1.0
# v2.0 Fix progid for job/player messages
# v3.0 Send player messages via Python
# v3.1 Fix commflag status, pad preset. Improve style & make Python 3 compatible

import MythTV
import os
import subprocess
import argparse
import collections
import re
import sys

kExe_Catagrower = '/usr/local/bin/catagrower'
kExe_Silence = '/usr/local/bin/silence'
kUpmix_Channels = '1'
kInput_Timeout = '60'


class MYLOG(MythTV.MythLog):
    "A specialised logger"

    def __init__(self, db):
        "Initialise logging"
        MythTV.MythLog.__init__(self, 'm', db)

    def log(self, msg, level=MythTV.MythLog.INFO):
        "Log message"
        # prepend string to msg so that rsyslog routes it to correct logfile
        MythTV.MythLog.log(self, MythTV.MythLog.COMMFLAG, level,
            'mythcommflag: ' + msg.rstrip('\n'))


class PRESET:
    "Manages the presets (parameters passed to the detection algorithm)"

    # define arg ordering and default values
    argname = ['thresh', 'minquiet', 'mindetect', 'minbreak', 'maxsep', 'pad']
    argval  = [  -75,       0.16,        6,          120,       120,    0.48]
    # dictionary holds value for each arg
    argdict = collections.OrderedDict(list(zip(argname, argval)))

    def _validate(self, k, v):
        "Converts arg input from string to float or None if invalid/not supplied"
        if v is None or v == '':
            return k, None
        try:
            return k, float(v)
        except ValueError:
            self.logger.log('Preset ' + k + ' (' + str(v) + ') is invalid - will use default',
                MYLOG.ERR)
            return k, None

    def __init__(self, _logger):
        "Initialise preset manager"
        self.logger = _logger

    def getFromArg(self, line):
        "Parses preset values from command-line string"
        self.logger.log('Parsing presets from "' + line + '"', MYLOG.DEBUG)
        if line:  # ignore empty string
            vals = [i.strip() for i in line.split(',')]  # split individual params
            # convert supplied values to float & match to appropriate arg name
            validargs = list(map(self._validate, self.argname, vals[0:len(self.argname)]))
            # remove missing/invalid values from list & replace default values with the rest
            self.argdict.update(v for v in validargs if v[1] is not None)

    def getFromFile(self, filename, title, callsign):
        "Gets preset values from a file"
        self.logger.log('Using preset file "' + filename + '"', MYLOG.DEBUG)
        try:
            with open(filename) as presets:
                for rawline in presets:
                    line = rawline.strip()
                    if line and (not line.startswith('#')):  # ignore empty & comment lines
                        vals = [i.strip() for i in line.split(',')]  # split individual params
                        # match preset name to recording title or channel
                        pattern = re.compile(vals[0], re.IGNORECASE)
                        if pattern.match(title) or pattern.match(callsign):
                            self.logger.log('Using preset "' + line.strip() + '"')
                            # convert supplied values to float & match to appropriate arg name
                            validargs = list(map(self._validate, self.argname,
                                                 vals[1:1 + len(self.argname)]))
                            # remove missing/invalid values from list &
                            # replace default values with the rest
                            self.argdict.update(v for v in validargs if v[1] is not None)
                            break
                else:
                    self.logger.log('No preset found for "' + title + '" or "' + callsign + '"')
        except IOError:
            self.logger.log('Presets file "' + filename + '" not found', MYLOG.ERR)
        return self.argdict

    def getValues(self):
        "Returns params as a list of strings"
        return [str(i) for i in list(self.argdict.values())]


def main():
    "Commflag a recording"

    # define options
    parser = argparse.ArgumentParser(description='Commflagger')
    parser.add_argument('--preset',
        help='Specify values as "Threshold, MinQuiet, MinDetect, MinLength, MaxSep, Pad"')
    parser.add_argument('--presetfile', help='Specify file containing preset values')
    parser.add_argument('--chanid', help='Use chanid for manual operation')
    parser.add_argument('--starttime', help='Use starttime for manual operation')
    parser.add_argument('jobid', nargs='?', help='Myth job id')

    # must set up log attributes before Db locks them
    MYLOG.loadArgParse(parser)
    MYLOG._setmask(MYLOG.COMMFLAG)

    # parse options
    args = parser.parse_args()

    db = MythTV.MythDB()
    logger = MYLOG(db)
    be = MythTV.BECache(None, False, db)

    if args.jobid:
        job = MythTV.Job(args.jobid, db)
        chanid = job.chanid
        starttime = job.starttime
        timeout = kInput_Timeout
    elif args.chanid and args.starttime:
        job = None
        chanid = args.chanid
        starttime = args.starttime
        timeout = '1'
    else:
        logger.log('Both chanid and starttime must be specified', MYLOG.ERR)
        sys.exit(1)

    # get recording
    try:
        rec = MythTV.Recorded((chanid, starttime), db)
    except:
        if job:
            job.update({'status': job.ERRORED, 'comment': 'ERROR: Could not find recording.'})
        logger.log('Could not find recording', MYLOG.ERR)
        sys.exit(1)

    channel = MythTV.Channel(chanid, db)

    logger.log('')
    logger.log('Processing: ' + str(channel.callsign) + ', ' + str(rec.starttime)
        + ', "' + str(rec.title) + ' - ' + str(rec.subtitle) + '"')

    sg = MythTV.findfile(rec.basename, rec.storagegroup, db)
    if sg is None:
        if job:
            job.update({'status': job.ERRORED,
                'comment': 'ERROR: Local access to recording not found.'})
        logger.log('Local access to recording not found', MYLOG.ERR)
        sys.exit(1)

    # player update message needs prog id (with time in Qt::ISODate format)
    progId = str(chanid) + '_' + str(starttime).replace(' ', 'T')

    # create params with default values
    param = PRESET(logger)
    # read any supplied presets
    if args.preset:
        param.getFromArg(args.preset)
    elif args.presetfile:  # use preset file
        param.getFromFile(args.presetfile, rec.title, channel.callsign)

    infile = os.path.join(sg.dirname, rec.basename)

    # Purge any existing skip list and flag as in-progress
    rec.commflagged = 2
    rec.markup.clean()
    rec.update()

    # Write out the file contents and keep going till recording is finished.
    p1 = subprocess.Popen([kExe_Catagrower, infile, timeout], stdout=subprocess.PIPE)
    # Pipe through ffmpeg to extract uncompressed audio stream.
    p2 = subprocess.Popen(["mythffmpeg", "-loglevel", "quiet", "-i", "pipe:0",
                          "-ar", "8000", "-f", "au", "-ac", kUpmix_Channels, "-"],
                          stdin=p1.stdout, stdout=subprocess.PIPE)
    # Pipe to silence which will spit out formatted log lines
    p3 = subprocess.Popen([kExe_Silence] + param.getValues(), stdin=p2.stdout,
                          stdout=subprocess.PIPE)

    # Process log output
    breaks = 0
    level = {'info': MYLOG.INFO, 'debug': MYLOG.DEBUG, 'err': MYLOG.ERR}
    while True:
        line = p3.stdout.readline()
        if line:
            flag, info = line.split('@', 1)
            if flag == 'cut':
                # extract numbers from log
                numbers = re.findall('\d+', info)
                logger.log(info)
                # mark advert in database
                rec.markup.append(int(numbers[0]), rec.markup.MARK_COMM_START, None)
                rec.markup.append(int(numbers[1]), rec.markup.MARK_COMM_END, None)
                rec.update()
                breaks += 1
                # send advert skiplist to MythPlayers
                tuplelist = [(str(x) + ':' + str(rec.markup.MARK_COMM_START),
                             str(y) + ':' + str(rec.markup.MARK_COMM_END))
                             for x, y in rec.markup.getskiplist()]
                mesg = 'COMMFLAG_UPDATE ' + progId + ' ' \
                    + ','.join([x for tuple in tuplelist for x in tuple])
                #logger.log('  Sending ' + mesg,  MYLOG.DEBUG)
                result = be.backendCommand("MESSAGE[]:[]" + mesg)
                if result != 'OK':
                    logger.log('Backend message failed, response = %s, message = MESSAGE[]:[]%s'
                               % (result, mesg), MYLOG.ERR)
            elif flag in level:
                logger.log(info, level.get(flag))
            else:  # unexpected prefix
                # use warning for unexpected log levels
                logger.log(flag, MYLOG.WARNING)
        else:
            break

    logger.log('Detected %s adverts.' % breaks)
    if job:
        job.update({'status': 272, 'comment': 'Detected %s adverts.' % breaks})

    # Signal comflagging has finished
    rec.commflagged = 1
    rec.update()

if __name__ == '__main__':
    main()

Makefile

CC        = g++
CFLAGS    = -c -Wall -std=c++0x
LIBPATH   = -L/usr/lib
TARGETDIR = /usr/local/bin

.PHONY: clean install

all: silence catagrower
	
catagrower: catagrower.o
	$(CC) catagrower.o -o $@
	
silence: silence.o
	$(CC) silence.o -o $@ $(LIBPATH) -lsndfile

.cpp.o:
	$(CC) $(CFLAGS) $< -o $@

install: silence catagrower silence.py
	install -p -t $(TARGETDIR) $^

clean: 
	-rm -f silence catagrower *.o