comparison src/recpt1.c @ 163:57eae2aec60d

improve-channel-switching.patch.(https://gist.github.com/890635)

162:185ff17f89f7

/* prototypes */
int tune(char *channel, thread_data *tdata, char *device);
int close_tuner(thread_data *tdata);
static int get_device_id_by_name ( const char *name );
void calc_cn(int fd, int type);

static struct channel_info_list *open_list_file(
       char *type,
       struct channel_info_list *info_list)
{

        sscanf(rbuf.mtext, "ch=%s t=%d e=%d", channel, &recsec, &time_to_add);
        ch = atoi(channel);
//        fprintf(stderr, "ch=%d time=%d extend=%d\n", ch, recsec, time_to_add);

        if(ch && tdata->ch != ch) {
            /* stop stream */
            ioctl(tdata->tfd, STOP_REC, 0);
#if 0
            /* re-initialize decoder */
            if(tdata->decoder) {
//                b25_finish(tdata->decoder);
                b25_shutdown(tdata->decoder);

                    fprintf(stderr, "Cannot start b25 decoder\n");
                    fprintf(stderr, "Fall back to encrypted recording\n");
                }
            }
#endif
            /* tune to new channel */
            if(close_tuner(tdata) != 0)
                return NULL;

            /* wait for remainder */
            while(tdata->queue->num_used > 0) {
                usleep(10000);
            }

            tune(channel, tdata, NULL);

            /* restart recording */
            if(ioctl(tdata->tfd, START_REC, 0) < 0) {
                fprintf(stderr, "Tuner cannot start recording\n");
                return NULL;
            }
        }

        if(time_to_add) {
            tdata->recsec += time_to_add;
            fprintf(stderr, "Extended %d sec\n", time_to_add);
        }

                f_exit = TRUE;
                enqueue(p_queue, NULL);
                break;
            }
            else {
                continue;
            }
        }
        enqueue(p_queue, bufptr);

                bufptr->size = read(tdata.tfd, bufptr->buffer, MAX_READ_SIZE);
                if(bufptr->size <= 0) {
                    f_exit = TRUE;
                    enqueue(p_queue, NULL);
                    break;
                }
                enqueue(p_queue, bufptr);
            }
            break;
        }

163:57eae2aec60d

/* prototypes */
int tune(char *channel, thread_data *tdata, char *device);
int close_tuner(thread_data *tdata);
static int get_device_id_by_name ( const char *name );
void calc_cn(int fd, int type);
ISDB_T_FREQ_CONV_TABLE *searchrecoff(char *channel);

static struct channel_info_list *open_list_file(
       char *type,
       struct channel_info_list *info_list)
{

        sscanf(rbuf.mtext, "ch=%s t=%d e=%d", channel, &recsec, &time_to_add);
        ch = atoi(channel);
//        fprintf(stderr, "ch=%d time=%d extend=%d\n", ch, recsec, time_to_add);

        if(ch && tdata->ch != ch) {
#if 0
            /* re-initialize decoder */
            if(tdata->decoder) {
//                b25_finish(tdata->decoder);
                b25_shutdown(tdata->decoder);

                    fprintf(stderr, "Cannot start b25 decoder\n");
                    fprintf(stderr, "Fall back to encrypted recording\n");
                }
            }
#endif
            int current_type = tdata->table->type;
            ISDB_T_FREQ_CONV_TABLE *table = searchrecoff(channel);
            if (table == NULL) {
                fprintf(stderr, "Invalid Channel: %s\n", channel);
                goto CHECK_TIME_TO_ADD;
            }
            tdata->table = table;

            /* stop stream */
            ioctl(tdata->tfd, STOP_REC, 0);

            /* wait for remainder */
            while(tdata->queue->num_used > 0) {
                usleep(10000);
            }

            if (tdata->table->type != current_type) {
            /* re-open device */
                if(close_tuner(tdata) != 0)
                    return NULL;
          
                tune(channel, tdata, NULL);
            } else {
            /* SET_CHANNEL only */
            const FREQUENCY freq = {
                .frequencyno = tdata->table->set_freq,
                .slot = tdata->table->add_freq,
            };
            if(ioctl(tdata->tfd, SET_CHANNEL, &freq) < 0) {
                fprintf(stderr, "Cannot tune to the specified channel\n");
                tdata->ch = 0;
                goto CHECK_TIME_TO_ADD;
            }
                tdata->ch = ch;
                calc_cn(tdata->tfd, tdata->table->type);
            }
            /* restart recording */
            if(ioctl(tdata->tfd, START_REC, 0) < 0) {
                fprintf(stderr, "Tuner cannot start recording\n");
                return NULL;
            }
        }

CHECK_TIME_TO_ADD:
        if(time_to_add) {
            tdata->recsec += time_to_add;
            fprintf(stderr, "Extended %d sec\n", time_to_add);
        }

                f_exit = TRUE;
                enqueue(p_queue, NULL);
                break;
            }
            else {
                free(bufptr);
                bufptr = NULL;
                continue;
            }
        }
        enqueue(p_queue, bufptr);

                bufptr->size = read(tdata.tfd, bufptr->buffer, MAX_READ_SIZE);
                if(bufptr->size <= 0) {
                    f_exit = TRUE;
                    enqueue(p_queue, NULL);
                    break;
                } else {
                    free(bufptr);
                    bufptr = NULL;
                    break;
                }
                enqueue(p_queue, bufptr);
            }
            break;
        }