hvirtual/libmpeg3/mpeg3io.c

   1 #include "mpeg3private.h"
   2 #include "mpeg3protos.h"
   3
   4 #include <mntent.h>
   5 #include <stdint.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <sys/stat.h>
   9
  10 mpeg3_fs_t* mpeg3_new_fs(char *path)
  11 {
  12         mpeg3_fs_t *fs = calloc(1, sizeof(mpeg3_fs_t));
  13         fs->buffer = calloc(1, MPEG3_IO_SIZE);
  14 // Force initial read
  15         fs->buffer_position = -0xffff;
  16         fs->css = mpeg3_new_css();
  17         strcpy(fs->path, path);
  18         return fs;
  19 }
  20
  21 int mpeg3_delete_fs(mpeg3_fs_t *fs)
  22 {
  23         mpeg3_delete_css(fs->css);
  24         free(fs->buffer);
  25         free(fs);
  26         return 0;
  27 }
  28
  29 int mpeg3_copy_fs(mpeg3_fs_t *dst, mpeg3_fs_t *src)
  30 {
  31         strcpy(dst->path, src->path);
  32         dst->current_byte = 0;
  33         return 0;
  34 }
  35
  36 int64_t mpeg3io_get_total_bytes(mpeg3_fs_t *fs)
  37 {
  38         struct stat64 ostat;
  39         stat64(fs->path, &ostat);
  40         fs->total_bytes = ostat.st_size;
  41         return fs->total_bytes;
  42
  43 /*
  44  *      fseek(fs->fd, 0, SEEK_END);
  45  *      fs->total_bytes = ftell(fs->fd);
  46  *      fseek(fs->fd, 0, SEEK_SET);
  47  *      return fs->total_bytes;
  48  */
  49 }
  50
  51 int64_t mpeg3io_path_total_bytes(char *path)
  52 {
  53         struct stat64 st;
  54         if(stat64(path, &st) < 0) return 0;
  55         return st.st_size;
  56 }
  57
  58 int mpeg3io_open_file(mpeg3_fs_t *fs)
  59 {
  60 /* Need to perform authentication before reading a single byte. */
  61         mpeg3_get_keys(fs->css, fs->path);
  62
  63 //printf("mpeg3io_open_file 1 %s\n", fs->path);
  64         if(!(fs->fd = fopen64(fs->path, "rb")))
  65         {
  66                 perror("mpeg3io_open_file");
  67                 return 1;
  68         }
  69
  70         fs->total_bytes = mpeg3io_get_total_bytes(fs);
  71
  72         if(!fs->total_bytes)
  73         {
  74                 fclose(fs->fd);
  75                 return 1;
  76         }
  77
  78         fs->current_byte = 0;
  79         fs->buffer_position = -0xffff;
  80         return 0;
  81 }
  82
  83 int mpeg3io_close_file(mpeg3_fs_t *fs)
  84 {
  85         if(fs->fd) fclose(fs->fd);
  86         fs->fd = 0;
  87         return 0;
  88 }
  89
  90 int mpeg3io_read_data(unsigned char *buffer, long bytes, mpeg3_fs_t *fs)
  91 {
  92         int result = 0, i, fragment_size;
  93
  94 //printf("mpeg3io_read_data 1 %d\n", bytes);
  95         for(i = 0; bytes > 0 && !result; )
  96         {
  97                 result = mpeg3io_sync_buffer(fs);
  98
  99                 fragment_size = MPEG3_IO_SIZE;
 100
 101                 if(fragment_size > bytes) fragment_size = bytes;
 102
 103                 if(fs->buffer_offset + fragment_size > fs->buffer_size)
 104                         fragment_size = fs->buffer_size - fs->buffer_offset;
 105
 106                 memcpy(buffer + i, fs->buffer + fs->buffer_offset, fragment_size);
 107
 108                 fs->buffer_offset += fragment_size;
 109                 fs->current_byte += fragment_size;
 110                 i += fragment_size;
 111                 bytes -= fragment_size;
 112 //printf("mpeg3io_read_data 10 %d\n", bytes);
 113         }
 114
 115 //printf("mpeg3io_read_data 100 %d\n", bytes);
 116         return (result && bytes);
 117 }
 118
 119 int mpeg3io_seek(mpeg3_fs_t *fs, int64_t byte)
 120 {
 121 //printf("mpeg3io_seek 1 %llx\n", byte);
 122         fs->current_byte = byte;
 123         return (fs->current_byte < 0) || (fs->current_byte > fs->total_bytes);
 124 }
 125
 126 int mpeg3io_seek_relative(mpeg3_fs_t *fs, long bytes)
 127 {
 128         fs->current_byte += bytes;
 129         return (fs->current_byte < 0) || (fs->current_byte > fs->total_bytes);
 130 }
 131
 132 void mpeg3io_read_buffer(mpeg3_fs_t *fs)
 133 {
 134 // Sequential reverse buffer
 135         if(fs->current_byte == fs->buffer_position - 1)
 136         {
 137                 fs->buffer_position = fs->current_byte - MPEG3_IO_SIZE + 1;
 138                 if(fs->buffer_position < 0) fs->buffer_position = 0;
 139
 140                 fs->buffer_size = fs->current_byte - fs->buffer_position + 1;
 141                 fs->buffer_offset = fs->buffer_size - 1;
 142
 143 //printf("mpeg3io_read_buffer 1 %x %x\n", fs->current_byte, fs->buffer_position);
 144                 fseeko64(fs->fd, fs->buffer_position, SEEK_SET);
 145 //printf("mpeg3io_read_buffer 10\n");
 146                 fs->buffer_size = fread(fs->buffer, 1, fs->buffer_size, fs->fd);
 147 //printf("mpeg3io_read_buffer 100\n");
 148         }
 149         else
 150 // Sequential forward buffer or random seek
 151         {
 152                 int result;
 153                 fs->buffer_position = fs->current_byte;
 154                 fs->buffer_offset = 0;
 155
 156 //printf("mpeg3io_read_buffer 200\n");
 157                 result = fseeko64(fs->fd, fs->buffer_position, SEEK_SET);
 158 //printf("mpeg3io_read_buffer 210\n");
 159                 fs->buffer_size = fread(fs->buffer, 1, MPEG3_IO_SIZE, fs->fd);
 160 //printf("mpeg3io_read_buffer 220\n");
 161 /*
 162  * printf(__FUNCTION__ " 2 result=%d ftell=%llx buffer_position=%llx %02x%02x%02x%02x%02x%02x%02x%02x %02x%02x\n",
 163  * result,
 164  * ftello64(fs->fd),
 165  * fs->buffer_position,
 166  * fs->buffer[0x0],
 167  * fs->buffer[0x1],
 168  * fs->buffer[0x2],
 169  * fs->buffer[0x3],
 170  * fs->buffer[0x4],
 171  * fs->buffer[0x5],
 172  * fs->buffer[0x6],
 173  * fs->buffer[0x7],
 174  * fs->buffer[0x12],
 175  * fs->buffer[0x13]);
 176  */
 177         }
 178 }
 179
 180 void mpeg3io_complete_path(char *complete_path, char *path)
 181 {
 182         if(path[0] != '/')
 183         {
 184                 char current_dir[MPEG3_STRLEN];
 185                 getcwd(current_dir, MPEG3_STRLEN);
 186                 sprintf(complete_path, "%s/%s", current_dir, path);
 187         }
 188         else
 189                 strcpy(complete_path, path);
 190 }
 191
 192 int mpeg3io_device(char *path, char *device)
 193 {
 194         struct stat64 file_st, device_st;
 195     struct mntent *mnt;
 196         FILE *fp;
 197
 198         if(stat64(path, &file_st) < 0)
 199         {
 200                 perror("mpeg3io_device");
 201                 return 1;
 202         }
 203
 204         fp = setmntent(MOUNTED, "r");
 205     while(fp && (mnt = getmntent(fp)))
 206         {
 207                 if(stat64(mnt->mnt_fsname, &device_st) < 0) continue;
 208                 if(device_st.st_rdev == file_st.st_dev)
 209                 {
 210                         strncpy(device, mnt->mnt_fsname, MPEG3_STRLEN);
 211                         break;
 212                 }
 213         }
 214         endmntent(fp);
 215
 216         return 0;
 217 }
 218
 219 void mpeg3io_get_directory(char *directory, char *path)
 220 {
 221         char *ptr = strrchr(path, '/');
 222         if(ptr)
 223         {
 224                 int i;
 225                 for(i = 0; i < ptr - path; i++)
 226                 {
 227                         directory[i] = path[i];
 228                 }
 229                 directory[i] = 0;
 230         }
 231 }
 232
 233 void mpeg3io_get_filename(char *filename, char *path)
 234 {
 235         char *ptr = strrchr(path, '/');
 236         if(!ptr)
 237                 ptr = path;
 238         else
 239                 ptr++;
 240
 241         strcpy(filename, ptr);
 242 }
 243
 244 void mpeg3io_joinpath(char *title_path, char *directory, char *new_filename)
 245 {
 246         sprintf(title_path, "%s/%s", directory, new_filename);
 247 }
 248
 249
 250 /* Find end of next 4 byte code */
 251 int mpeg3io_next_code(mpeg3_fs_t *fs, uint32_t code, int count)
 252 {
 253         uint32_t header = 0;
 254
 255         while(header != code &&
 256                 !mpeg3io_eof(fs) &&
 257                 count > 0)
 258         {
 259                 header <<= 8;
 260                 header |= mpeg3io_read_char(fs);
 261                 count--;
 262         }
 263
 264         return mpeg3io_eof(fs) || count <= 0;
 265 }
 266
 267 /* Find start of previous 4 byte code */
 268 int mpeg3io_prev_code(mpeg3_fs_t *fs, uint32_t code, int count)
 269 {
 270         uint32_t header = 0;
 271         while(header != code &&
 272                 !mpeg3io_bof(fs) &&
 273                 count > 0)
 274         {
 275                 mpeg3io_seek_relative(fs, -1);
 276                 header >>= 8;
 277                 header |= ((uint32_t)mpeg3io_read_char(fs)) << 24;
 278 //printf("mpeg3io_prev_code %08x\n", header);
 279                 mpeg3io_seek_relative(fs, -1);
 280                 count--;
 281         }
 282
 283         return mpeg3io_bof(fs) || count <= 0;
 284 }