/*
Copyright (C) 2004, 2005, 2007, 2008 Rocky Bernstein <rocky@gnu.org>
Copyright (C) 2014 Robert Kausch <robert.kausch@freac.org>
Copyright (C) 1998 Monty xiphmont@mit.edu
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
# define __CDIO_CONFIG_H__ 1
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <stdio.h>
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#include <limits.h>
#include "p_block.h"
#include <cdio/paranoia/cdda.h>
#include <cdio/paranoia/paranoia.h>
linked_list_t *new_list(void *(*newp)(void),void (*freep)(void *))
{
linked_list_t *ret=calloc(1,sizeof(linked_list_t));
ret->new_poly=newp;
ret->free_poly=freep;
return(ret);
}
linked_element *add_elem(linked_list_t *l,void *elem)
{
linked_element *ret=calloc(1,sizeof(linked_element));
ret->stamp=l->current++;
ret->ptr=elem;
ret->list=l;
if(l->head)
l->head->prev=ret;
else
l->tail=ret;
ret->next=l->head;
ret->prev=NULL;
l->head=ret;
l->active++;
return(ret);
}
linked_element *
new_elem(linked_list_t *p_list)
{
void *p_new=p_list->new_poly();
return(add_elem(p_list,p_new));
}
void
free_elem(linked_element *e,int free_ptr)
{
linked_list_t *l=e->list;
if(free_ptr)l->free_poly(e->ptr);
if(e==l->head)
l->head=e->next;
if(e==l->tail)
l->tail=e->prev;
if(e->prev)
e->prev->next=e->next;
if(e->next)
e->next->prev=e->prev;
l->active--;
free(e);
}
void
free_list(linked_list_t *list,int free_ptr)
{
while(list->head)
free_elem(list->head,free_ptr);
free(list);
}
void *get_elem(linked_element *e)
{
return(e->ptr);
}
linked_list_t *copy_list(linked_list_t *list)
{
linked_list_t *new=new_list(list->new_poly,list->free_poly);
linked_element *i=list->tail;
while(i){
add_elem(new,i->ptr);
i=i->prev;
}
return(new);
}
/**** C_block stuff ******************************************************/
static c_block_t *
i_cblock_constructor(cdrom_paranoia_t *p)
{
c_block_t *ret=calloc(1,sizeof(c_block_t));
return(ret);
}
void
i_cblock_destructor(c_block_t *c)
{
if(c){
if(c->vector)free(c->vector);
if(c->flags)free(c->flags);
c->e=NULL;
free(c);
}
}
c_block_t *
new_c_block(cdrom_paranoia_t *p)
{
linked_element *e=new_elem(p->cache);
c_block_t *c=e->ptr;
c->e=e;
c->p=p;
return(c);
}
void free_c_block(c_block_t *c)
{
/* also rid ourselves of v_fragments that reference this block */
v_fragment_t *v=v_first(c->p);
while(v){
v_fragment_t *next=v_next(v);
if(v->one==c)free_v_fragment(v);
v=next;
}
free_elem(c->e,1);
}
static v_fragment_t *
i_vfragment_constructor(void)
{
v_fragment_t *ret=calloc(1,sizeof(v_fragment_t));
return(ret);
}
static void
i_v_fragment_destructor(v_fragment_t *v)
{
free(v);
}
v_fragment_t *
new_v_fragment(cdrom_paranoia_t *p, c_block_t *one,
long int begin, long int end, int last)
{
linked_element *e=new_elem(p->fragments);
v_fragment_t *b=e->ptr;
b->e=e;
b->p=p;
b->one=one;
b->begin=begin;
b->vector=one->vector+begin-one->begin;
b->size=end-begin;
b->lastsector=last;
#if TRACE_PARANOIA
fprintf(stderr, "- Verified [%ld-%ld] (0x%04X...0x%04X)%s\n",
begin, end,
b->vector[0]&0xFFFF, b->vector[b->size-1]&0xFFFF,
last ? " *" : "");
#endif
return(b);
}
void free_v_fragment(v_fragment_t *v)
{
free_elem(v->e,1);
}
c_block_t *
c_first(cdrom_paranoia_t *p)
{
if(p->cache->head)
return(p->cache->head->ptr);
return(NULL);
}
c_block_t *
c_last(cdrom_paranoia_t *p)
{
if(p->cache->tail)
return(p->cache->tail->ptr);
return(NULL);
}
c_block_t *
c_next(c_block_t *c)
{
if(c->e->next)
return(c->e->next->ptr);
return(NULL);
}
c_block_t *
c_prev(c_block_t *c)
{
if(c->e->prev)
return(c->e->prev->ptr);
return(NULL);
}
v_fragment_t *
v_first(cdrom_paranoia_t *p)
{
if(p->fragments->head){
return(p->fragments->head->ptr);
}
return(NULL);
}
v_fragment_t *
v_last(cdrom_paranoia_t *p)
{
if(p->fragments->tail)
return(p->fragments->tail->ptr);
return(NULL);
}
v_fragment_t *
v_next(v_fragment_t *v)
{
if(v->e->next)
return(v->e->next->ptr);
return(NULL);
}
v_fragment_t *
v_prev(v_fragment_t *v)
{
if(v->e->prev)
return(v->e->prev->ptr);
return(NULL);
}
void
recover_cache(cdrom_paranoia_t *p)
{
linked_list_t *l=p->cache;
/* Are we at/over our allowed cache size? */
while(l->active>p->cache_limit)
/* cull from the tail of the list */
free_c_block(c_last(p));
}
int16_t *
v_buffer(v_fragment_t *v)
{
if(!v->one)return(NULL);
if(!cv(v->one))return(NULL);
return(v->vector);
}
/* alloc a c_block not on a cache list */
c_block_t *
c_alloc(int16_t *vector, long begin, long size)
{
c_block_t *c=calloc(1,sizeof(c_block_t));
c->vector=vector;
c->begin=begin;
c->size=size;
return(c);
}
void c_set(c_block_t *v,long begin){
v->begin=begin;
}
/* pos here is vector position from zero */
void
c_insert(c_block_t *v,long pos,int16_t *b,long size)
{
int vs=cs(v);
if(pos<0 || pos>vs)return;
if(v->vector) {
v->vector = realloc(v->vector,sizeof(int16_t)*(size+vs));
} else {
v->vector = calloc(1, sizeof(int16_t)*size);
}
if(pos<vs)memmove(v->vector+pos+size,v->vector+pos,
(vs-pos)*sizeof(int16_t));
memcpy(v->vector+pos,b,size*sizeof(int16_t));
v->size+=size;
}
void
c_remove(c_block_t *v, long cutpos, long cutsize)
{
int vs=cs(v);
if(cutpos<0 || cutpos>vs)return;
if(cutpos+cutsize>vs)cutsize=vs-cutpos;
if(cutsize<0)cutsize=vs-cutpos;
if(cutsize<1)return;
memmove(v->vector+cutpos,v->vector+cutpos+cutsize,
(vs-cutpos-cutsize)*sizeof(int16_t));
v->size-=cutsize;
}
void
c_overwrite(c_block_t *v,long pos,int16_t *b,long size)
{
int vs=cs(v);
if(pos<0)return;
if(pos+size>vs)size=vs-pos;
memcpy(v->vector+pos,b,size*sizeof(int16_t));
}
void
c_append(c_block_t *v, int16_t *vector, long size)
{
int vs=cs(v);
/* update the vector */
if(v->vector)
v->vector=realloc(v->vector,sizeof(int16_t)*(size+vs));
else {
v->vector=calloc(1, sizeof(int16_t)*size);
}
memcpy(v->vector+vs,vector,sizeof(int16_t)*size);
v->size+=size;
}
void
c_removef(c_block_t *v, long cut)
{
c_remove(v,0,cut);
v->begin+=cut;
}
/**** Initialization *************************************************/
/*! Get the beginning and ending sector bounds given cursor position.
There are a couple of subtle differences between this and the
cdda_firsttrack_sector and cdda_lasttrack_sector. If the cursor is
an a sector later than cdda_firsttrack_sector, that sectur will be
used. As for the difference between cdda_lasttrack_sector, if the CD
is mixed and there is a data track after the cursor but before the
last audio track, the end of the audio sector before that is used.
*/
void
i_paranoia_firstlast(cdrom_paranoia_t *p)
{
track_t i, j;
cdrom_drive_t *d=p->d;
const track_t i_first_track = cdio_get_first_track_num(d->p_cdio);
const track_t i_last_track = cdio_get_last_track_num(d->p_cdio);
p->current_lastsector = p->current_firstsector = -1;
i = cdda_sector_gettrack(d, p->cursor);
if ( CDIO_INVALID_TRACK != i ) {
if ( 0 == i ) i++;
j = i;
/* In the below loops, We assume the cursor already is on an audio
sector. Not sure if this is correct if p->cursor is in the pregap
before the first track.
*/
for ( ; i < i_last_track; i++)
if( !cdda_track_audiop(d,i) ) {
p->current_lastsector=cdda_track_lastsector(d,i-1);
break;
}
i = j;
for ( ; i >= i_first_track; i-- )
if( !cdda_track_audiop(d,i) ) {
p->current_firstsector = cdda_track_firstsector(d,i+1);
break;
}
}
if (p->current_lastsector == -1)
p->current_lastsector = cdda_disc_lastsector(d);
if(p->current_firstsector == -1)
p->current_firstsector = cdda_disc_firstsector(d);
}
cdrom_paranoia_t *
paranoia_init(cdrom_drive_t *d)
{
cdrom_paranoia_t *p=calloc(1,sizeof(cdrom_paranoia_t));
p->cache=new_list((void *)&i_cblock_constructor,
(void *)&i_cblock_destructor);
p->fragments=new_list((void *)&i_vfragment_constructor,
(void *)&i_v_fragment_destructor);
p->cdcache_begin= 9999999;
p->cdcache_end= 9999999;
p->cdcache_size=CACHEMODEL_SECTORS;
p->sortcache=sort_alloc(p->cdcache_size*CD_FRAMEWORDS);
p->d=d;
p->dynoverlap=MAX_SECTOR_OVERLAP*CD_FRAMEWORDS;
p->cache_limit=JIGGLE_MODULO;
p->enable=(paranoia_cb_mode_t)PARANOIA_MODE_FULL;
p->cursor=cdda_disc_firstsector(d);
/* One last one... in case data and audio tracks are mixed... */
i_paranoia_firstlast(p);
return(p);
}
void paranoia_set_range(cdrom_paranoia_t *p, long start, long end)
{
p->cursor = start;
p->current_firstsector = start;
p->current_lastsector = end;
}
/* sectors < 0 indicates a query. Returns the number of sectors before the call */
int paranoia_cachemodel_size(cdrom_paranoia_t *p,int sectors){
int ret = p->cdcache_size;
if(sectors>=0)
p->cdcache_size=sectors;
return ret;
}