p_block.h

Go to the documentation of this file.

/*
  Copyright (C) 2004, 2005, 2008 Rocky Bernstein <rocky@gnu.org>
  Copyright (C) 2014 Robert Kausch <robert.kausch@freac.org>
  Copyright (C) by Monty (xiphmont@mit.edu)
 
  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  This program 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 General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _P_BLOCK_H_
#define _P_BLOCK_H_
 
#include <cdio/paranoia/paranoia.h>
#include <cdio/paranoia/cdda.h>
 
#define MIN_WORDS_OVERLAP    64     /* 16 bit words */
#define MIN_WORDS_SEARCH     64     /* 16 bit words */
#define MIN_WORDS_RIFT       16     /* 16 bit words */
#define MAX_SECTOR_OVERLAP   32     /* sectors */
#define MIN_SECTOR_EPSILON  128     /* words */
#define MIN_SECTOR_BACKUP    16     /* sectors */
#define JIGGLE_MODULO        15     /* sectors */
#define MIN_SILENCE_BOUNDARY 1024   /* 16 bit words */
#define CACHEMODEL_SECTORS   1200
 
#define min(x,y) ((x)>(y)?(y):(x))
#define max(x,y) ((x)<(y)?(y):(x))
 
#include "isort.h"
 
typedef struct {
  /* linked list */
  struct linked_element *head;
  struct linked_element *tail;
 
  void *(*new_poly)();
  void (*free_poly)(void *poly);
  long current;
  long active;
 
} linked_list_t;
 
typedef struct linked_element{
  void *ptr;
  struct linked_element *prev;
  struct linked_element *next;
  
  linked_list_t *list;
  int stamp;
} linked_element;
 
extern linked_list_t *new_list(void *(*new_fn)(void),void (*free)(void *));
extern linked_element *new_elem(linked_list_t *list);
extern linked_element *add_elem(linked_list_t *list,void *elem);
extern void free_list(linked_list_t *list,int free_ptr); /* unlink or free */
extern void free_elem(linked_element *e,int free_ptr); /* unlink or free */
extern void *get_elem(linked_element *e);
 
/* This is a shallow copy; it doesn't copy contained structures */
extern linked_list_t *copy_list(linked_list_t *p_list); 
 
typedef struct c_block {
  /* The buffer */
  int16_t *vector;
  long begin;
  long size;
 
  /* auxiliary support structures */
  unsigned char *flags; /* 1    known boundaries in read data
                           2    known blanked data
                           4    matched sample
                           8    reserved
                           16   reserved
                           32   reserved
                           64   reserved
                           128  reserved
                         */
 
  /* end of session cases */
  long lastsector;
  cdrom_paranoia_t *p;
  struct linked_element *e;
 
} c_block_t;
 
extern void free_c_block(c_block_t *c);
extern void i_cblock_destructor(c_block_t *c);
extern c_block_t *new_c_block(cdrom_paranoia_t *p);
 
typedef struct v_fragment_s {
  c_block_t *one;
 
  long begin;
  long size;
  int16_t *vector;
 
  /* end of session cases */
  long lastsector;
 
  /* linked list */
  cdrom_paranoia_t *p;
  struct linked_element *e;
 
} v_fragment_t;
 
extern void free_v_fragment(v_fragment_t *c);
extern v_fragment_t *new_v_fragment(cdrom_paranoia_t *p, c_block_t *one,
                                  long int begin, long int end, 
                                  int lastsector);
extern int16_t *v_buffer(v_fragment_t *v);
 
extern c_block_t *c_first(cdrom_paranoia_t *p);
extern c_block_t *c_last(cdrom_paranoia_t *p);
extern c_block_t *c_next(c_block_t *c);
extern c_block_t *c_prev(c_block_t *c);
 
extern v_fragment_t *v_first(cdrom_paranoia_t *p);
extern v_fragment_t *v_last(cdrom_paranoia_t *p);
extern v_fragment_t *v_next(v_fragment_t *v);
extern v_fragment_t *v_prev(v_fragment_t *v);
 
typedef struct root_block{
  long returnedlimit;   
  long lastsector;
  cdrom_paranoia_t *p;
 
  c_block_t *vector; /* doesn't use any sorting */
  int silenceflag;
  long silencebegin;
} root_block;
 
typedef struct offsets{
  
  long offpoints;
  long newpoints;
  long offaccum;
  long offdiff;
  long offmin;
  long offmax;
 
} offsets;
 
struct cdrom_paranoia_s {
  cdrom_drive_t *d;
 
  root_block root;           /* verified/reconstructed cached data */
  linked_list_t *cache;      /* our data as read from the cdrom */
  long int cache_limit;
  linked_list_t *fragments;  /* fragments of blocks that have been 'verified' */
  sort_info_t *sortcache;
 
  /* cache tracking */
  int cdcache_size;
  int cdcache_begin;
  int cdcache_end;
  int jitter;           
 
  paranoia_cb_mode_t enable;
  long int cursor;
  long int current_lastsector;
  long int current_firstsector;
 
  /* statistics for drift/overlap */
  struct offsets stage1;
  struct offsets stage2;
 
  long dynoverlap;
  long dyndrift;
 
  /* statistics for verification */
 
};
 
extern c_block_t *c_alloc(int16_t *vector,long begin,long size);
extern void c_set(c_block_t *v,long begin);
extern void c_insert(c_block_t *v,long pos,int16_t *b,long size);
extern void c_remove(c_block_t *v,long cutpos,long cutsize);
extern void c_overwrite(c_block_t *v,long pos,int16_t *b,long size);
extern void c_append(c_block_t *v, int16_t *vector, long size);
extern void c_removef(c_block_t *v, long cut);
 
#define ce(v) (v->begin+v->size)
#define cb(v) (v->begin)
#define cs(v) (v->size)
 
/* pos here is vector position from zero */
 
extern void recover_cache(cdrom_paranoia_t *p);
extern void i_paranoia_firstlast(cdrom_paranoia_t *p);
 
#define cv(c) (c->vector)
 
#define fe(f) (f->begin+f->size)
#define fb(f) (f->begin)
#define fs(f) (f->size)
#define fv(f) (v_buffer(f))
 
#ifndef DO_NOT_WANT_PARANOIA_COMPATIBILITY
#define linked_list linked_list_t
#endif /*DO_NOT_WANT_PARANOIA_COMPATIBILITY*/
 
#define CDP_COMPILE
#endif /*_P_BLOCK_H_*/