programstream.c

基于linux的DVD播放器程序

    
    data_buf_head = (data_buf_head_t *)data_buf_addr;
    
    /* send create decoder request msg*/
    ev.type = MsgEventQReqStreamBuf;
    ev.reqstreambuf.stream_id = id;
    ev.reqstreambuf.subtype = subtype;

    /* TODO how should we decide buf sizes? */
    switch(id) {
    case MPEG2_PRIVATE_STREAM_1:
      if((subtype&~0x1f) == 0x80) { // ac3, dts
	qsize = 100;
      } else if((subtype&~0x1f) == 0x20) { // spu
	qsize = 100;
      } else {
	qsize = 100;
      }
      break;
    case MPEG2_PRIVATE_STREAM_2:
      qsize = 100;
      break;
    default:
      qsize = 300;
      break;
    }

    ev.reqstreambuf.nr_of_elems = qsize;
    ev.reqstreambuf.data_buf_shmid = data_buf_head->shmid;
      
    if(MsgSendEvent(msgq, CLIENT_RESOURCE_MANAGER, &ev, 0) == -1) {
      fprintf(stderr, "demux: couldn't send streambuf request\n");
    }
    
    /* wait for answer */
    
    while(!id_registered(id, subtype)) {
      if(MsgNextEvent(msgq, &ev) != -1) {
	if(ev.type == MsgEventQGntStreamBuf) {
	  DPRINTF(1, "demux: got stream %x, %x buffer \n",
		  ev.gntstreambuf.stream_id,
		  ev.gntstreambuf.subtype);
	  attach_decoder_buffer(ev.gntstreambuf.stream_id,
				ev.gntstreambuf.subtype,
				ev.gntstreambuf.q_shmid);
	} else {
	  handle_events(&ev);
	}
      }
    }

  } else {
    /* TODO fix */
    /*
      id_add(...);

    */
  }
  
  return 0;
}

int id_get_output(uint8_t id, int subtype)
{
  MsgEvent_t ev;
  
  data_buf_head_t *data_buf_head;
  int qsize;
  
  if(msgqid != -1) {
    
    data_buf_head = (data_buf_head_t *)data_buf_addr;
    
    /* send create decoder request msg*/
    ev.type = MsgEventQReqStreamBuf;
    ev.reqstreambuf.stream_id = id;
    ev.reqstreambuf.subtype = subtype;

    /* TODO how should we decide buf sizes? */
    switch(id) {
    case MPEG2_PRIVATE_STREAM_1:
      if((subtype&~0x1f) == 0x80) {
	qsize = 100;
      } else if((subtype&~0x1f) == 0x20) {
	qsize = 100;
      } else {
	qsize = 100;
      }
      break;
    case MPEG2_PRIVATE_STREAM_2:
      qsize = 100;
      break;
    default:
      qsize = 300;
      break;
    }

    ev.reqstreambuf.nr_of_elems = qsize;
    ev.reqstreambuf.data_buf_shmid = data_buf_head->shmid;
      
    if(MsgSendEvent(msgq, CLIENT_RESOURCE_MANAGER, &ev, 0) == -1) {
      fprintf(stderr, "demux: couldn't send streambuf request\n");
    }
    
    /* wait for answer */
    
    while(!id_has_output(id, subtype)) {
      if(MsgNextEvent(msgq, &ev) != -1) {
	if(ev.type == MsgEventQGntStreamBuf) {
	  DPRINTF(1, "demux: got stream %x, %x buffer \n",
		  ev.gntstreambuf.stream_id,
		  ev.gntstreambuf.subtype);
	  attach_decoder_buffer(ev.gntstreambuf.stream_id,
				ev.gntstreambuf.subtype,
				ev.gntstreambuf.q_shmid);
	} else {
	  handle_events(&ev);
	}
      }
    }

  } else {
    /* TODO fix */
    /*
      id_add(...);

    */
  }
  
  return 0;
}

int id_stat(uint8_t id, uint8_t subtype)
{
    if(id != MPEG2_PRIVATE_STREAM_1) {
      return id_reg[id].state;
    } else {
      return id_reg_ps1[subtype].state;
    }
}

int id_infile(uint8_t id, uint8_t subtype)
{
  if(id != MPEG2_PRIVATE_STREAM_1) {
    return id_reg[id].infile;
  } else {
    return id_reg_ps1[subtype].infile;
  }
}

void id_setinfile(uint8_t id, uint8_t subtype, int newfile)
{
  if(id != MPEG2_PRIVATE_STREAM_1) {
    id_reg[id].infile = newfile;
  } else {
    id_reg_ps1[subtype].infile = newfile;
  }
}

char *id_qaddr(uint8_t id, uint8_t subtype)
{
  if(id != MPEG2_PRIVATE_STREAM_1) {
    return id_reg[id].shmaddr;
  } else {
    return id_reg_ps1[subtype].shmaddr;
  }
}

FILE *id_file(uint8_t id, uint8_t subtype)
{
  if(id != MPEG2_PRIVATE_STREAM_1) {
    return id_reg[id].file;
  } else {
    return id_reg_ps1[subtype].file;
  }
}
  
int id_registered(uint8_t id, uint8_t subtype)
{
  if(id != MPEG2_PRIVATE_STREAM_1) {
    if(id_reg[id].state != STREAM_NOT_REGISTERED) {
      return 1;
    }
  } else {
    if(id_reg_ps1[subtype].state != STREAM_NOT_REGISTERED) {
      return 1;
    }
  }

  return 0;
}


uint8_t type_registered(uint8_t id, uint8_t subtype)
{
  int n;
  uint8_t idtype;
  uint8_t idrange;
  
  if(id != MPEG2_PRIVATE_STREAM_1) {
    switch(id & 0xf0) {
    case 0xe0:
      idtype = 0xe0;
      idrange = 16;
      break;
    case 0xc0:
    case 0xd0:
      idtype = 0xc0;
      idrange = 32;
      break;
    default:
      fprintf(stderr, "demux: type_registered(), type not handled\n");
      return 0;
      break;
    }
    
    for(n = idtype; n < (idtype+idrange); n++) {
      if(id_stat(n, 0) == STREAM_DECODE) {
	return n;
      }
    }
  } else {
    switch(subtype & 0xf0) {
    case 0x20:
    case 0x30:
      idtype = 0x20;
      idrange = 32;
      break;
    case 0x80:
      if(subtype < 0x88) {
	idtype = 0x80;
	idrange = 8;
      } else {
	idtype = 0x88;
	idrange = 8;
      }
      break;
    default:
      fprintf(stderr, "demux: type_registered(), subtype not handled\n");
      return 0;
      break;
    }
    
    for(n = idtype; n < (idtype+idrange); n++) {
      if(id_stat(id, n) == STREAM_DECODE) {
	return n;
      }
    }
  } 
  return 0;
  
}

int switch_to_stream(uint8_t id, uint8_t subtype)
{
  uint8_t oldid;
  
  oldid = type_registered(id, subtype);
  if(oldid == 0) {
    if(id != MPEG2_PRIVATE_STREAM_1) {
      id_reg[id].state = STREAM_DECODE;
    } else {
      id_reg_ps1[subtype].state = STREAM_DISCARD;
    }
    return 1;
  }
  
  if(id != MPEG2_PRIVATE_STREAM_1) {
    if(id == oldid) {
      return 1;
    }
  } else {
    if(subtype == oldid) {
      return 1;
    }
  }
  
  
  if(id != MPEG2_PRIVATE_STREAM_1) {
    id_reg[id] = id_reg[oldid];
    id_reg[oldid].shmid = -1;
    id_reg[oldid].shmaddr = NULL;
    id_reg[oldid].state = STREAM_DISCARD;
    id_reg[oldid].file = NULL;
  } else {
    id_reg_ps1[subtype] = id_reg_ps1[oldid];
    id_reg_ps1[oldid].shmid = -1;
    id_reg_ps1[oldid].shmaddr = NULL;
    id_reg_ps1[oldid].state = STREAM_DISCARD;
    id_reg_ps1[oldid].file = NULL;
  }
  return 1;
}


int switch_from_to_stream(uint8_t oldid, uint8_t oldsubtype,
			  uint8_t newid, uint8_t newsubtype)
{
  
  if(oldid == 0) {
    if(newid != MPEG2_PRIVATE_STREAM_1) {
      id_reg[newid].state = STREAM_DECODE;
    } else {
      id_reg_ps1[newsubtype].state = STREAM_DECODE;
    }
    return 1;
  }
  
  if(newid != MPEG2_PRIVATE_STREAM_1) {
    if(newid == oldid) {
      DNOTE("%s", "equal(not private)\n");
      return 1;
    }
  } else {
    if(oldid == MPEG2_PRIVATE_STREAM_1) {
      if(newsubtype == oldsubtype) {
	DNOTE("%s", "equal(private)\n");
	return 1;
      }
    }
  }
  
  
  if(newid != MPEG2_PRIVATE_STREAM_1) {
    DNOTE("%s", "newid not private:\n");
    if(oldid != MPEG2_PRIVATE_STREAM_1) {
      DNOTE("%s", "oldid not private\n");
      id_reg[newid] = id_reg[oldid];
      id_reg[oldid].shmid = -1;
      id_reg[oldid].shmaddr = NULL;
      id_reg[oldid].state = STREAM_DISCARD;
      id_reg[oldid].file = NULL;
    } else {
      DNOTE("%s", "oldid private\n");
      id_reg[newid] = id_reg_ps1[oldsubtype];
      id_reg_ps1[oldsubtype].shmid = -1;
      id_reg_ps1[oldsubtype].shmaddr = NULL;
      id_reg_ps1[oldsubtype].state = STREAM_DISCARD;
      id_reg_ps1[oldsubtype].file = NULL;  
    }
  } else {
    DNOTE("%s", "newid private:\n");
    if(oldid != MPEG2_PRIVATE_STREAM_1) {
      DNOTE("%s", "oldid not private\n");
      id_reg_ps1[newsubtype] = id_reg[oldid];
      id_reg[oldid].shmid = -1;
      id_reg[oldid].shmaddr = NULL;
      id_reg[oldid].state = STREAM_DISCARD;
      id_reg[oldid].file = NULL;
    } else {
      DNOTE("%s", "oldid private\n");
      id_reg_ps1[newsubtype] = id_reg_ps1[oldsubtype];
      id_reg_ps1[oldsubtype].shmid = -1;
      id_reg_ps1[oldsubtype].shmaddr = NULL;
      id_reg_ps1[oldsubtype].state = STREAM_DISCARD;
      id_reg_ps1[oldsubtype].file = NULL;
    }
  }
  return 1;
}


int id_has_output(uint8_t stream_id, uint8_t subtype)
{
  
  if(stream_id != MPEG2_PRIVATE_STREAM_1) {
    if(id_reg[stream_id].shmid != -1) {
      return 1;
    } else {
      return 0;
    }
  } else {
    if(id_reg_ps1[subtype].shmid != -1) {
      return 1;
    } else {
      return 0;
    }
  }
}


void id_add(uint8_t stream_id, uint8_t subtype, stream_state_t state, int shmid, char *shmaddr, FILE *file)
{
    if(stream_id != MPEG2_PRIVATE_STREAM_1) {
      id_reg[stream_id].shmid = shmid;
      id_reg[stream_id].shmaddr = shmaddr;
      id_reg[stream_id].state = state;
      id_reg[stream_id].file = file;
      id_reg[stream_id].infile = -1;
      
    } else {
      id_reg_ps1[subtype].shmid = shmid;
      id_reg_ps1[subtype].shmaddr = shmaddr;
      id_reg_ps1[subtype].state = state;
      id_reg_ps1[subtype].file = file;
      id_reg_ps1[subtype].infile = -1;
 
    }
}
  

int init_id_reg(stream_state_t default_state)
{
  int n;
  
  for(n = 0; n < 256; n++) {
    id_reg[n].state = default_state;
    id_reg[n].shmid = -1;
    id_reg[n].shmaddr = NULL;
    id_reg[n].file = NULL;
  }

  for(n = 0; n < 256; n++) {
    id_reg_ps1[n].state = default_state;
    id_reg_ps1[n].shmid = -1;
    id_reg_ps1[n].shmaddr = NULL;
    id_reg_ps1[n].file = NULL;
  }
  
  id_reg[0xBE].state = STREAM_DISCARD; //padding stream
  
  return 0;
}


int attach_decoder_buffer(uint8_t stream_id, uint8_t subtype, int shmid)
{
  char *shmaddr;

#if DEBUG
  fprintf(stderr, "demux: shmid: %d\n", shmid);
#endif
  if(shmid >= 0) {
    if((shmaddr = shmat(shmid, NULL, SHM_SHARE_MMU)) == (void *)-1) {
      perror("demux: attach_decoder_buffer(), shmat()");
      return -1;
    }
    id_add(stream_id, subtype, STREAM_DECODE, shmid, shmaddr, NULL);
    
  } else {
    id_add(stream_id, subtype, STREAM_DISCARD, -1, NULL, NULL);
  }
    
  return 0;  
}


int attach_buffer(int shmid, int size)
{
  char *shmaddr;
  data_buf_head_t *data_buf_head;
  data_elem_t *data_elems;
  int n;
  
#if DEBUG
  fprintf(stderr, "demux: attach_buffer() shmid: %d\n", shmid);
#endif
  
  if(shmid >= 0) {
    if((shmaddr = shmat(shmid, NULL, SHM_SHARE_MMU)) == (void *)-1) {
      perror("demux: attach_buffer(), shmat()");
      exit(1);
    }

    data_buf_addr = shmaddr;
    data_buf_head = (data_buf_head_t *)data_buf_addr;
    data_buf_head->shmid = shmid;
    data_buf_head->nr_of_dataelems = 900;
    data_buf_head->write_nr = 0;
    data_buf_head->buffer_start_offset = (sizeof(data_buf_head_t) +
					  data_buf_head->nr_of_dataelems *
					  sizeof(data_elem_t) +
					  2047)/2048*2048;
    data_buf_head->buffer_size = (size - data_buf_head->buffer_start_offset)
      / 2048*2048;
    
    disk_buf = data_buf_addr + data_buf_head->buffer_start_offset;
    
#if DEBUG
    fprintf(stderr, "demux: setup disk_buf: %lu\n", (unsigned long)disk_buf);
#endif
    data_elems = (data_elem_t *)(data_buf_addr+sizeof(data_buf_head_t));
    for(n = 0; n < data_buf_head->nr_of_dataelems; n++) {
      data_elems[n].in_use = 0;
    }
    
  } else {
    return -1;
  }
    
  return 0;
}



int get_buffer(int size)
{
  MsgEvent_t ev;
  
  size+= sizeof(data_buf_head_t)+900*sizeof(data_elem_t);

  ev.type = MsgEventQReqBuf;
  ev.reqbuf.size = size;
  
  if(MsgSendEvent(msgq, CLIENT_RESOURCE_MANAGER, &ev, 0) == -1) {
    fprintf(stderr, "demux: couldn't send buffer request\n");
  }
  
  while(ev.type != MsgEventQGntBuf) {
    if(MsgNextEvent(msgq, &ev) != -1) {
      if(ev.type == MsgEventQGntBuf) {
	DPRINTF(1, "demux: got buffer id %d, size %d\n",
		ev.gntbuf.shmid,
		ev.gntbuf.size);
	return attach_buffer(ev.gntbuf.shmid,
			     ev.gntbuf.size);
      } else {
	handle_events(&ev);
      }
    }
  }
  
  return 0;
}


void flush_all_streams(int scr_id)
{
  MsgEvent_t ev;