/*
Copyright (C) 2004-2005, 2008, 2010-2011, 2013, 2017
Rocky Bernstein <rocky@gnu.org>
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/>.
*/
/*! Common image routines.
Because _img_private_t may vary over image formats, the routines are
included into the image drivers after _img_private_t is defined. In
order for the below routines to work, there is a large part of
_img_private_t that is common among image drivers. For example, see
image.h
*/
#include "image.h"
#include "image_common.h"
#include <cdio/util.h>
#include "_cdio_stdio.h"
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
/*!
Eject media -- there's nothing to do here except free resources.
We always return DRIVER_OP_UNSUPPORTED.
*/
driver_return_code_t
_eject_media_image(void *p_user_data)
{
_free_image (p_user_data);
return DRIVER_OP_UNSUPPORTED;
}
/*!
We don't need the image any more. Free all memory associated with
it.
*/
void
_free_image (void *p_user_data)
{
_img_private_t *p_env = p_user_data;
track_t i_track;
if (NULL == p_env) return;
for (i_track=0; i_track < p_env->gen.i_tracks; i_track++) {
track_info_t *p_tocent = &(p_env->tocent[i_track]);
CDIO_FREE_IF_NOT_NULL(p_tocent->filename);
CDIO_FREE_IF_NOT_NULL(p_tocent->isrc);
if (p_tocent->data_source) cdio_stdio_destroy(p_tocent->data_source);
}
CDIO_FREE_IF_NOT_NULL(p_env->psz_mcn);
CDIO_FREE_IF_NOT_NULL(p_env->psz_cue_name);
CDIO_FREE_IF_NOT_NULL(p_env->psz_access_mode);
cdtext_destroy(p_env->gen.cdtext);
cdio_generic_stdio_free(p_env);
free(p_env);
}
/*!
Return the value associated with the key "arg".
*/
const char *
_get_arg_image (void *user_data, const char key[])
{
_img_private_t *p_env = user_data;
if (!strcmp (key, "source")) {
return p_env->gen.source_name;
} else if (!strcmp (key, "cue")) {
return p_env->psz_cue_name;
} else if (!strcmp(key, "access-mode")) {
return "image";
} else if (!strcmp (key, "mmc-supported?")) {
return "false";
}
return NULL;
}
/*!
Return CD-Text object
*/
cdtext_t *
_get_cdtext_image (void *user_data)
{
generic_img_private_t *p_env = user_data;
if(!p_env)
return NULL;
return p_env->cdtext;
}
/*!
Get disc type associated with cd_obj.
*/
discmode_t
_get_discmode_image (void *p_user_data)
{
_img_private_t *p_env = p_user_data;
return p_env->disc_mode;
}
/*!
Return the the kind of drive capabilities of device.
*/
void
_get_drive_cap_image (const void *user_data,
cdio_drive_read_cap_t *p_read_cap,
cdio_drive_write_cap_t *p_write_cap,
cdio_drive_misc_cap_t *p_misc_cap)
{
*p_read_cap = CDIO_DRIVE_CAP_READ_CD_DA
| CDIO_DRIVE_CAP_READ_CD_G
| CDIO_DRIVE_CAP_READ_CD_R
| CDIO_DRIVE_CAP_READ_CD_RW
| CDIO_DRIVE_CAP_READ_MODE2_FORM1
| CDIO_DRIVE_CAP_READ_MODE2_FORM2
| CDIO_DRIVE_CAP_READ_MCN
;
*p_write_cap = 0;
/* In the future we may want to simulate
LOCK, OPEN_TRAY, CLOSE_TRAY, SELECT_SPEED, etc.
*/
*p_misc_cap = CDIO_DRIVE_CAP_MISC_FILE;
}
/*!
Return the number of of the first track.
CDIO_INVALID_TRACK is returned on error.
*/
track_t
_get_first_track_num_image(void *p_user_data)
{
_img_private_t *p_env = p_user_data;
if (!p_env->gen.toc_init)
p_env->gen.cdio->op.read_toc (p_user_data);
return p_env->gen.toc_init ? p_env->gen.i_first_track : CDIO_INVALID_TRACK;
}
/*!
Find out if media has changed since the last call.
@param p_user_data the CD object to be acted upon.
@return 1 if media has changed since last call, 0 if not. Error
return codes are the same as driver_return_code_t
There is no such thing as changing a media image so we will
always return 0 - no change.
*/
int
get_media_changed_image(const void *p_user_data)
{
return 0;
}
/*!
Return the media catalog number (MCN) from the CD or NULL if there
is none or we don't have the ability to get it.
Note: string is malloc'd so caller has to free() the returned
string when done with it.
*/
char *
_get_mcn_image(const void *p_user_data)
{
const _img_private_t *p_env = p_user_data;
if (!p_env || !p_env->psz_mcn) return NULL;
return strdup(p_env->psz_mcn);
}
/*!
Return the number of tracks.
*/
track_t
_get_num_tracks_image(void *p_user_data)
{
_img_private_t *p_env = p_user_data;
return p_env->gen.i_tracks;
}
/*!
Return the starting MSF (minutes/secs/frames) for the track number
track_num in obj. Tracks numbers start at 1.
The "leadout" track is specified either by
using track_num LEADOUT_TRACK or the total tracks+1.
*/
bool
_get_track_msf_image(void *p_user_data, track_t i_track, msf_t *msf)
{
const _img_private_t *p_env = p_user_data;
if (NULL == msf) return false;
if (i_track == CDIO_CDROM_LEADOUT_TRACK) i_track = p_env->gen.i_tracks+1;
if (i_track <= p_env->gen.i_tracks+1 && i_track != 0) {
*msf = p_env->tocent[i_track-p_env->gen.i_first_track].start_msf;
return true;
} else
return false;
}
/*! Return number of channels in track: 2 or 4; -2 if not
implemented or -1 for error.
Not meaningful if track is not an audio track.
*/
int
get_track_channels_image(const void *p_user_data, track_t i_track)
{
const _img_private_t *p_env = p_user_data;
return ( p_env->tocent[i_track-p_env->gen.i_first_track].flags
& FOUR_CHANNEL_AUDIO ) ? 4 : 2;
}
/*! Return 1 if copy is permitted on the track, 0 if not, or -1 for error.
Is this meaningful if not an audio track?
*/
track_flag_t
get_track_copy_permit_image(void *p_user_data, track_t i_track)
{
const _img_private_t *p_env = p_user_data;
return ( p_env->tocent[i_track-p_env->gen.i_first_track].flags
& COPY_PERMITTED ) ? CDIO_TRACK_FLAG_TRUE : CDIO_TRACK_FLAG_FALSE;
}
/*! Return 1 if track has pre-emphasis, 0 if not, or -1 for error.
Is this meaningful if not an audio track?
pre-emphasis is a non linear frequency response.
*/
track_flag_t
get_track_preemphasis_image(const void *p_user_data, track_t i_track)
{
const _img_private_t *p_env = p_user_data;
return ( p_env->tocent[i_track-p_env->gen.i_first_track].flags
& PRE_EMPHASIS ) ? CDIO_TRACK_FLAG_TRUE : CDIO_TRACK_FLAG_FALSE;
}
/*! Return the starting LBA for the pregap for track number i_track.
Track numbers start at 1.
CDIO_INVALID_LBA is returned on error.
*/
lba_t
get_track_pregap_lba_image(const void *p_user_data, track_t i_track)
{
const _img_private_t *p_env = p_user_data;
lba_t pregap, start_lba;
pregap = p_env->tocent[i_track-p_env->gen.i_first_track].pregap;
start_lba = p_env->tocent[i_track-p_env->gen.i_first_track].start_lba;
/* avoid initializing pregap to CDIO_INVALID_LBA by letting calloc
do the work. also, nero files have the pregap set equal
to the start of the track when there is no pregap
*/
if (!pregap || pregap == start_lba) {
pregap = CDIO_INVALID_LBA;
}
return pregap;
}
/*!
Return the International Standard Recording Code (ISRC) for track number
i_track in p_cdio. Track numbers start at 1.
Note: string is malloc'd so caller has to free() the returned
string when done with it.
*/
char *
get_track_isrc_image(const void *p_user_data, track_t i_track)
{
const _img_private_t *p_env = p_user_data;
char *isrc = p_env->tocent[i_track-p_env->gen.i_first_track].isrc;
if (isrc && isrc[0]) {
return strdup(isrc);
} else {
return NULL;
}
}
/*!
Read a data sector
@param p_cdio object to read from
@param p_buf place to read data into. The caller should make sure
this location can store at least ISO_BLOCKSIZE, M2RAW_SECTOR_SIZE,
or M2F2_SECTOR_SIZE depending on the kind of sector getting read. If
you don't know whether you have a Mode 1/2, Form 1/ Form 2/Formless
sector best to reserve space for the maximum, M2RAW_SECTOR_SIZE.
@param i_lsn sector to read
@param i_blocksize size of block. Should be either ISO_BLOCKSIZE
M2RAW_SECTOR_SIZE, or M2F2_SECTOR_SIZE. See comment above under
p_buf.
*/
driver_return_code_t
read_data_sectors_image ( void *p_user_data, void *p_buf,
lsn_t i_lsn, uint16_t i_blocksize,
uint32_t i_blocks )
{
const _img_private_t *p_env = p_user_data;
if (!p_env || !p_env->gen.cdio) return DRIVER_OP_UNINIT;
{
CdIo_t *p_cdio = p_env->gen.cdio;
track_t i_track = cdio_get_track(p_cdio, i_lsn);
track_format_t e_track_format = cdio_get_track_format(p_cdio, i_track);
switch(e_track_format) {
case TRACK_FORMAT_PSX:
case TRACK_FORMAT_AUDIO:
case TRACK_FORMAT_ERROR:
return DRIVER_OP_ERROR;
case TRACK_FORMAT_DATA:
return cdio_read_mode1_sectors (p_cdio, p_buf, i_lsn, false, i_blocks);
case TRACK_FORMAT_CDI:
case TRACK_FORMAT_XA:
return cdio_read_mode2_sectors (p_cdio, p_buf, i_lsn, false, i_blocks);
}
}
return DRIVER_OP_ERROR;
}
/*!
Set the arg "key" with "value" in the source device.
Currently "source" to set the source device in I/O operations
is the only valid key.
*/
driver_return_code_t
_set_arg_image (void *p_user_data, const char key[], const char value[])
{
_img_private_t *p_env = p_user_data;
if (!strcmp (key, "source"))
{
CDIO_FREE_IF_NOT_NULL(p_env->gen.source_name);
if (!value) return DRIVER_OP_ERROR;
p_env->gen.source_name = strdup (value);
}
else if (!strcmp (key, "cue"))
{
CDIO_FREE_IF_NOT_NULL(p_env->psz_cue_name);
if (!value) return DRIVER_OP_ERROR;
p_env->psz_cue_name = strdup (value);
}
else if (!strcmp (key, "access-mode"))
{
CDIO_FREE_IF_NOT_NULL(p_env->psz_access_mode);
if (!value) return DRIVER_OP_ERROR;
p_env->psz_access_mode = strdup (value);
}
else
return DRIVER_OP_ERROR;
return DRIVER_OP_SUCCESS;
}